test: MsgClaimMorseApplication

tests/integration/migration/morse_account_import_and_claim_test.go → tests/integration/migration/morse_claim_account_test.go

@@ -1,73 +1,16 @@
 package migration
 
 import (
-	"testing"
-
 	"cosmossdk.io/math"
-	sdk "github.com/cosmos/cosmos-sdk/types"
+	cosmostypes "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
 
 	"github.com/pokt-network/poktroll/app/volatile"
-	"github.com/pokt-network/poktroll/testutil/integration/suites"
 	"github.com/pokt-network/poktroll/testutil/sample"
 	migrationtypes "github.com/pokt-network/poktroll/x/migration/types"
 )
 
-type MigrationModuleTestSuite struct {
-	suites.MigrationModuleSuite
-
-	// numMorseClaimableAccounts is the number of morse claimable accounts to
-	// generate when calling #GenerateMorseAccountState.
-	numMorseClaimableAccounts int
-}
-
-func (s *MigrationModuleTestSuite) SetupTest() {
-	// Initialize a new integration app for the suite.
-	s.NewApp(s.T())
-
-	s.numMorseClaimableAccounts = 10
-
-	// Assign the app to nested suites.
-	// TODO_UPNEXT(@bryanchriswhite, #1043): Initialize the app module suite.
-	// s.AppSuite.SetApp(s.GetApp())
-}
-
-func TestMigrationModuleSuite(t *testing.T) {
-	suite.Run(t, &MigrationModuleTestSuite{})
-}
-
-// TestImportMorseClaimableAccounts exercises importing and persistence of morse claimable accounts.
-func (s *MigrationModuleTestSuite) TestImportMorseClaimableAccounts() {
-	s.GenerateMorseAccountState(s.T(), s.numMorseClaimableAccounts)
-	msgImportRes := s.ImportMorseClaimableAccounts(s.T())
-	morseAccountState := s.GetAccountState(s.T())
-	morseAccountStateHash, err := morseAccountState.GetHash()
-	require.NoError(s.T(), err)
-
-	expectedMsgImportRes := &migrationtypes.MsgImportMorseClaimableAccountsResponse{
-		StateHash:   morseAccountStateHash,
-		NumAccounts: uint64(s.numMorseClaimableAccounts),
-	}
-	require.Equal(s.T(), expectedMsgImportRes, msgImportRes)
-
-	foundMorseClaimableAccounts := s.QueryAllMorseClaimableAccounts(s.T())
-	require.Equal(s.T(), s.numMorseClaimableAccounts, len(foundMorseClaimableAccounts))
-
-	for _, expectedMorseClaimableAccount := range morseAccountState.Accounts {
-		isFound := false
-		for _, foundMorseClaimableAccount := range foundMorseClaimableAccounts {
-			if foundMorseClaimableAccount.GetMorseSrcAddress() == expectedMorseClaimableAccount.GetMorseSrcAddress() {
-				require.Equal(s.T(), *expectedMorseClaimableAccount, foundMorseClaimableAccount)
-				isFound = true
-				break
-			}
-		}
-		require.True(s.T(), isFound)
-	}
-}
-
 // TestClaimMorseAccount exercises claiming of MorseClaimableAccounts.
 // It only exercises claiming of account balances and does not exercise
 // the staking any actors as a result of claiming.
@@ -76,8 +19,9 @@ func (s *MigrationModuleTestSuite) TestClaimMorseAccount() {
 	s.ImportMorseClaimableAccounts(s.T())
 
 	shannonDestAddr := sample.AccAddress()
-
 	bankClient := s.GetBankQueryClient(s.T())
+
+	// Assert that the shannonDestAddr account initially has a zero balance.
 	shannonDestBalance, err := bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
 	require.NoError(s.T(), err)
 	require.True(s.T(), shannonDestBalance.IsZero())
@@ -111,5 +55,5 @@ func (s *MigrationModuleTestSuite) TestClaimMorseAccount() {
 	migrationModuleAddress := authtypes.NewModuleAddress(migrationtypes.ModuleName).String()
 	migrationModuleBalance, err := bankClient.GetBalance(s.SdkCtx(), migrationModuleAddress)
 	require.NoError(s.T(), err)
-	require.Equal(s.T(), sdk.NewCoin(volatile.DenomuPOKT, math.ZeroInt()), *migrationModuleBalance)
+	require.Equal(s.T(), cosmostypes.NewCoin(volatile.DenomuPOKT, math.ZeroInt()), *migrationModuleBalance)
 }

tests/integration/migration/morse_claim_app_test.go

@@ -0,0 +1,273 @@
+package migration
+
+import (
+	"strings"
+	"testing"
+
+	"cosmossdk.io/math"
+	cosmostypes "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/errors"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/pokt-network/poktroll/app/volatile"
+	"github.com/pokt-network/poktroll/testutil/sample"
+	"github.com/pokt-network/poktroll/testutil/testmigration"
+	apptypes "github.com/pokt-network/poktroll/x/application/types"
+	migrationtypes "github.com/pokt-network/poktroll/x/migration/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+)
+
+// TestClaimMorseApplication exercises claiming of a MorseClaimableAccount as a staked application.
+func (s *MigrationModuleTestSuite) TestClaimMorseApplication() {
+	s.GenerateMorseAccountState(s.T(), s.numMorseClaimableAccounts)
+	s.ImportMorseClaimableAccounts(s.T())
+
+	stakeOffset := cosmostypes.NewInt64Coin(volatile.DenomuPOKT, 9999)
+	testCases := []struct {
+		desc     string
+		getStake func() *cosmostypes.Coin
+	}{
+		{
+			desc:     "claim morse application with same staked/unstaked ratio (default)",
+			getStake: func() *cosmostypes.Coin { return nil },
+		},
+		{
+			desc: "claim morse application with same staked/unstaked ratio (explicit)",
+			getStake: func() *cosmostypes.Coin {
+				stake := s.GetAccountState(s.T()).Accounts[1].
+					GetApplicationStake()
+				return &stake
+			},
+		},
+		{
+			desc: "claim morse application with higher staked/unstaked ratio",
+			getStake: func() *cosmostypes.Coin {
+				stake := s.GetAccountState(s.T()).Accounts[2].
+					GetApplicationStake().
+					Add(stakeOffset)
+				return &stake
+			},
+		},
+		{
+			desc: "claim morse application with lower staked/unstaked ratio",
+			getStake: func() *cosmostypes.Coin {
+				stake := s.GetAccountState(s.T()).Accounts[3].
+					GetApplicationStake().
+					Sub(stakeOffset)
+				return &stake
+			},
+		},
+	}
+
+	for testCaseIdx, testCase := range testCases {
+		s.T().Run(testCase.desc, func(t *testing.T) {
+			shannonDestAddr := sample.AccAddress()
+			bankClient := s.GetBankQueryClient(s.T())
+
+			// Assert that the shannonDestAddr account initially has a zero balance.
+			shannonDestBalance, err := bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
+			require.NoError(s.T(), err)
+			require.Equal(s.T(), int64(0), shannonDestBalance.Amount.Int64())
+
+			morseSrcAddr, claimAppRes := s.ClaimMorseApplication(
+				s.T(), uint64(testCaseIdx+1),
+				shannonDestAddr,
+				testCase.getStake(),
+				s.appServiceConfig,
+			)
+
+			expectedMorseClaimableAccount := s.GetAccountState(s.T()).Accounts[testCaseIdx]
+			expectedStake := testCase.getStake()
+			if expectedStake == nil {
+				expectedStake = &expectedMorseClaimableAccount.ApplicationStake
+			}
+
+			expectedBalance := expectedMorseClaimableAccount.GetUnstakedBalance().
+				Add(expectedMorseClaimableAccount.GetApplicationStake()).
+				Add(expectedMorseClaimableAccount.GetSupplierStake()).
+				Sub(*expectedStake)
+
+			expectedClaimApplicationRes := &migrationtypes.MsgClaimMorseApplicationResponse{
+				MorseSrcAddress:         morseSrcAddr,
+				ClaimedBalance:          expectedBalance,
+				ClaimedApplicationStake: *expectedStake,
+				ClaimedAtHeight:         s.SdkCtx().BlockHeight() - 1,
+				ServiceId:               s.appServiceConfig.GetServiceId(),
+			}
+			require.Equal(s.T(), expectedClaimApplicationRes, claimAppRes)
+
+			// Assert that the MorseClaimableAccount was updated on-chain.
+			expectedMorseClaimableAccount.ShannonDestAddress = shannonDestAddr
+			expectedMorseClaimableAccount.ClaimedAtHeight = s.SdkCtx().BlockHeight() - 1
+			morseClaimableAccount := s.QueryMorseClaimableAccount(s.T(), morseSrcAddr)
+			require.Equal(s.T(), expectedMorseClaimableAccount, morseClaimableAccount)
+
+			// Assert that the shannonDestAddr account balance has been updated.
+			shannonDestBalance, err = bankClient.GetBalance(s.GetApp().GetSdkCtx(), shannonDestAddr)
+			require.NoError(s.T(), err)
+			require.Equal(s.T(), expectedBalance, *shannonDestBalance)
+
+			// Assert that the migration module account balance returns to zero.
+			migrationModuleAddress := authtypes.NewModuleAddress(migrationtypes.ModuleName).String()
+			migrationModuleBalance, err := bankClient.GetBalance(s.SdkCtx(), migrationModuleAddress)
+			require.NoError(s.T(), err)
+			require.Equal(s.T(), cosmostypes.NewCoin(volatile.DenomuPOKT, math.ZeroInt()), *migrationModuleBalance)
+
+			// Assert that the application was staked.
+			expectedApp := apptypes.Application{
+				Address:        shannonDestAddr,
+				Stake:          expectedStake,
+				ServiceConfigs: []*sharedtypes.ApplicationServiceConfig{s.appServiceConfig},
+			}
+			appClient := s.AppSuite.GetAppQueryClient(s.T())
+			app, err := appClient.GetApplication(s.SdkCtx(), shannonDestAddr)
+			require.NoError(s.T(), err)
+			require.Equal(s.T(), expectedApp, app)
+		})
+	}
+}
+
+func (s *MigrationModuleTestSuite) TestClaimMorseApplication_ErrorMinStake() {
+	s.GenerateMorseAccountState(s.T(), s.numMorseClaimableAccounts)
+	s.ImportMorseClaimableAccounts(s.T())
+
+	appClient := s.AppSuite.GetAppQueryClient(s.T())
+	appParams, err := appClient.GetParams(s.SdkCtx())
+	appMinStake := appParams.GetMinStake()
+	require.NoError(s.T(), err)
+	belowAppMinStake := appMinStake.Sub(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, 1))
+
+	shannonDestAddr := sample.AccAddress()
+	bankClient := s.GetBankQueryClient(s.T())
+
+	// Assert that the shannonDestAddr account initially has a zero balance.
+	shannonDestBalance, err := bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), int64(0), shannonDestBalance.Amount.Int64())
+
+	// Attempt to claim a Morse claimable account with a stake below the minimum.
+	morsePrivateKey := testmigration.NewMorsePrivateKey(s.T(), 1)
+	expectedMorseSrcAddr := morsePrivateKey.PubKey().Address().String()
+	require.Equal(s.T(),
+		expectedMorseSrcAddr,
+		s.GetAccountState(s.T()).Accounts[0].MorseSrcAddress,
+	)
+
+	morseClaimMsg, err := migrationtypes.NewMsgClaimMorseApplication(
+		shannonDestAddr,
+		expectedMorseSrcAddr,
+		morsePrivateKey,
+		&belowAppMinStake,
+		s.appServiceConfig,
+	)
+	require.NoError(s.T(), err)
+
+	// Claim a Morse claimable account.
+	_, err = s.GetApp().RunMsg(s.T(), morseClaimMsg)
+	require.Contains(s.T(), strings.ReplaceAll(err.Error(), `\`, ""), status.Error(
+		codes.InvalidArgument,
+		apptypes.ErrAppInvalidStake.Wrapf("application %q must stake at least %s",
+			shannonDestAddr, appMinStake,
+		).Error(),
+	).Error())
+
+	// Assert that the MorseClaimableAccount was NOT updated on-chain.
+	morseClaimableAccount := s.QueryMorseClaimableAccount(s.T(), morseClaimMsg.GetMorseSrcAddress())
+	require.Equal(s.T(), int64(0), morseClaimableAccount.GetClaimedAtHeight())
+	require.Equal(s.T(), "", morseClaimableAccount.GetShannonDestAddress())
+
+	// Assert that the shannonDestAddr account balance has NOT been updated.
+	shannonDestBalance, err = bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), int64(0), shannonDestBalance.Amount.Int64())
+
+	// Assert that the migration module account balance returns to zero.
+	migrationModuleAddress := authtypes.NewModuleAddress(migrationtypes.ModuleName).String()
+	migrationModuleBalance, err := bankClient.GetBalance(s.SdkCtx(), migrationModuleAddress)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), cosmostypes.NewCoin(volatile.DenomuPOKT, math.ZeroInt()), *migrationModuleBalance)
+
+	// Assert that the application was NOT staked.
+	_, err = appClient.GetApplication(s.SdkCtx(), shannonDestAddr)
+	require.EqualError(s.T(), err, status.Error(
+		codes.NotFound,
+		apptypes.ErrAppNotFound.Wrapf(
+			"app address: %s",
+			shannonDestAddr,
+		).Error(),
+	).Error())
+}
+
+func (s *MigrationModuleTestSuite) TestClaimMorseApplication_ErrorInsufficientStakeAvailable() {
+	s.GenerateMorseAccountState(s.T(), s.numMorseClaimableAccounts)
+	s.ImportMorseClaimableAccounts(s.T())
+
+	//aboveMaxAvailableStake := appMinStake.Sub(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, 1))
+	expectedMorseClaimableAccount := s.GetAccountState(s.T()).Accounts[0]
+	totalTokens := expectedMorseClaimableAccount.TotalTokens()
+	aboveMaxAvailableStake := totalTokens.Add(cosmostypes.NewInt64Coin(volatile.DenomuPOKT, 1))
+
+	shannonDestAddr := sample.AccAddress()
+	bankClient := s.GetBankQueryClient(s.T())
+
+	// Assert that the shannonDestAddr account initially has a zero balance.
+	shannonDestBalance, err := bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), int64(0), shannonDestBalance.Amount.Int64())
+
+	// Attempt to claim a Morse claimable account with a stake below the minimum.
+	morsePrivateKey := testmigration.NewMorsePrivateKey(s.T(), 1)
+	expectedMorseSrcAddr := morsePrivateKey.PubKey().Address().String()
+	require.Equal(s.T(),
+		expectedMorseSrcAddr,
+		s.GetAccountState(s.T()).Accounts[0].MorseSrcAddress,
+	)
+
+	morseClaimMsg, err := migrationtypes.NewMsgClaimMorseApplication(
+		shannonDestAddr,
+		expectedMorseSrcAddr,
+		morsePrivateKey,
+		&aboveMaxAvailableStake,
+		s.appServiceConfig,
+	)
+	require.NoError(s.T(), err)
+
+	// Claim a Morse claimable account.
+	_, err = s.GetApp().RunMsg(s.T(), morseClaimMsg)
+	require.ErrorContains(s.T(), err, status.Error(
+		codes.Internal,
+		errors.ErrInsufficientFunds.Wrapf("spendable balance %s is smaller than %s",
+			totalTokens, aboveMaxAvailableStake,
+		).Error(),
+	).Error())
+
+	// Assert that the MorseClaimableAccount was NOT updated on-chain.
+	morseClaimableAccount := s.QueryMorseClaimableAccount(s.T(), morseClaimMsg.GetMorseSrcAddress())
+	require.Equal(s.T(), int64(0), morseClaimableAccount.GetClaimedAtHeight())
+	require.Equal(s.T(), "", morseClaimableAccount.GetShannonDestAddress())
+
+	// Assert that the shannonDestAddr account balance has NOT been updated.
+	shannonDestBalance, err = bankClient.GetBalance(s.SdkCtx(), shannonDestAddr)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), int64(0), shannonDestBalance.Amount.Int64())
+
+	// Assert that the migration module account balance returns to zero.
+	migrationModuleAddress := authtypes.NewModuleAddress(migrationtypes.ModuleName).String()
+	migrationModuleBalance, err := bankClient.GetBalance(s.SdkCtx(), migrationModuleAddress)
+	require.NoError(s.T(), err)
+	require.Equal(s.T(), cosmostypes.NewCoin(volatile.DenomuPOKT, math.ZeroInt()), *migrationModuleBalance)
+
+	// Assert that the application was NOT staked.
+	appClient := s.AppSuite.GetAppQueryClient(s.T())
+	_, err = appClient.GetApplication(s.SdkCtx(), shannonDestAddr)
+	require.EqualError(s.T(), err, status.Error(
+		codes.NotFound,
+		apptypes.ErrAppNotFound.Wrapf(
+			"app address: %s",
+			shannonDestAddr,
+		).Error(),
+	).Error())
+}