[Application] Enforce minimum stake when burning

config.yml

@@ -167,7 +167,7 @@ genesis:
         max_delegated_gateways: "7"
         min_stake:
           # TODO_MAINNET: Determine realistic amount for minimum application stake amount.
-          amount: "1000000" # 1 POKT
+          amount: "100000000" # 100 POKT
           denom: upokt
       applicationList:
         - address: pokt1mrqt5f7qh8uxs27cjm9t7v9e74a9vvdnq5jva4
@@ -179,7 +179,7 @@ genesis:
           stake:
             # NB: This value should be exactly 1upokt smaller than the value in
             # `supplier1_stake_config.yaml` so that the stake command causes a state change.
-            amount: "1000068"
+            amount: "100000068" # ~100 POKT
             denom: upokt
         - address: pokt1ad28jdap2zfanjd7hpkh984yveney6k9a42man
           delegatee_gateway_addresses: []
@@ -190,7 +190,7 @@ genesis:
           stake:
             # NB: This value should be exactly 1upokt smaller than the value in
             # `supplier1_stake_config.yaml` so that the stake command causes a state change.
-            amount: "1000068"
+            amount: "100000068" # ~100 POKT
             denom: upokt
     supplier:
       supplierList:

pkg/crypto/rings/client.go

@@ -46,6 +46,7 @@ type ringClient struct {
 // - polylog.Logger
 // - client.ApplicationQueryClient
 // - client.AccountQueryClient
+// - client.SharedQueryClient
 func NewRingClient(deps depinject.Config) (_ crypto.RingClient, err error) {
 	rc := new(ringClient)
 

tests/integration/application/min_stake_test.go

@@ -0,0 +1,177 @@
+package application
+
+import (
+	"context"
+	"testing"
+
+	cosmoslog "cosmossdk.io/log"
+	"cosmossdk.io/math"
+	cosmostypes "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/pokt-network/poktroll/app/volatile"
+	"github.com/pokt-network/poktroll/cmd/poktrolld/cmd"
+	_ "github.com/pokt-network/poktroll/pkg/polylog/polyzero"
+	"github.com/pokt-network/poktroll/testutil/keeper"
+	testproof "github.com/pokt-network/poktroll/testutil/proof"
+	"github.com/pokt-network/poktroll/testutil/sample"
+	apptypes "github.com/pokt-network/poktroll/x/application/types"
+	prooftypes "github.com/pokt-network/poktroll/x/proof/types"
+	sessiontypes "github.com/pokt-network/poktroll/x/session/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+)
+
+type applicationMinStakeTestSuite struct {
+	suite.Suite
+
+	ctx     context.Context
+	keepers keeper.TokenomicsModuleKeepers
+
+	serviceId,
+	appBech32,
+	supplierBech32 string
+
+	appStake *cosmostypes.Coin
+
+	numRelays,
+	numComputeUnitsPerRelay uint64
+}
+
+func TestApplicationMinStakeTestSuite(t *testing.T) {
+	cmd.InitSDKConfig()
+
+	suite.Run(t, new(applicationMinStakeTestSuite))
+}
+
+func (s *applicationMinStakeTestSuite) SetupTest() {
+	s.keepers, s.ctx = keeper.NewTokenomicsModuleKeepers(s.T(), cosmoslog.NewNopLogger())
+
+	s.serviceId = "svc1"
+	s.appBech32 = sample.AccAddress()
+	s.supplierBech32 = sample.AccAddress()
+	s.appStake = &apptypes.DefaultMinStake
+	s.numRelays = 10
+	s.numComputeUnitsPerRelay = 1
+
+	// Set block height to 1.
+	s.ctx = cosmostypes.UnwrapSDKContext(s.ctx).WithBlockHeight(1)
+}
+
+func (s *applicationMinStakeTestSuite) TestAppCannotStakeLessThanMinStake() {
+	s.T().Skip("this case is well covered in x/application/keeper/msg_server_stake_application_test.go")
+}
+
+func (s *applicationMinStakeTestSuite) TestAppIsUnbondedIfBelowMinStakeWhenSettling() {
+	// Assert that the application's initial bank balance is 0.
+	appBalance := s.getAppBalance()
+	require.Equal(s.T(), int64(0), appBalance.Amount.Int64())
+
+	// Add service 1
+	s.addService()
+
+	// Stake an application for service 1 with min stake.
+	s.stakeApp()
+
+	// Stake a supplier for service 1.
+	s.stakeSupplier()
+
+	// Get the session header.
+	sessionHeader := s.getSessionHeader()
+
+	// Create a claim whose settlement amount drops the application below min stake
+	claim := s.getClaim(sessionHeader)
+
+	// Process TLMs for the claim.
+	err := s.keepers.Keeper.ProcessTokenLogicModules(s.ctx, claim)
+	require.NoError(s.T(), err)
+
+	// Assert that the application was unbonded.
+	_, isAppFound := s.keepers.ApplicationKeeper.GetApplication(s.ctx, s.appBech32)
+	require.False(s.T(), isAppFound)
+
+	// Assert that the application's stake was returned to its bank balance.
+	expectedAppBurn := math.NewInt(int64(s.numRelays * s.numComputeUnitsPerRelay * sharedtypes.DefaultComputeUnitsToTokensMultiplier))
+	expectedAppBalance := s.appStake.SubAmount(expectedAppBurn)
+	appBalance = s.getAppBalance()
+	require.Equal(s.T(), expectedAppBalance.Amount.Int64(), appBalance.Amount.Int64())
+
+}
+
+// addService adds the test service to the service module state.
+func (s *applicationMinStakeTestSuite) addService() {
+	s.keepers.ServiceKeeper.SetService(s.ctx, sharedtypes.Service{
+		Id:                   s.serviceId,
+		ComputeUnitsPerRelay: 1,
+		OwnerAddress:         sample.AccAddress(), // random address.
+	})
+}
+
+// stakeApp stakes an application for service 1 with min stake.
+func (s *applicationMinStakeTestSuite) stakeApp() {
+	s.keepers.ApplicationKeeper.SetApplication(s.ctx, apptypes.Application{
+		Address:        s.appBech32,
+		Stake:          s.appStake,
+		ServiceConfigs: []*sharedtypes.ApplicationServiceConfig{{ServiceId: s.serviceId}},
+	})
+}
+
+// stakeSupplier stakes a supplier for service 1.
+func (s *applicationMinStakeTestSuite) stakeSupplier() {
+	// TODO_UPNEXT(@bryanchriswhite, #612): Replace supplierStake with suppleirtypes.DefaultMinStake.
+	supplierStake := cosmostypes.NewInt64Coin(volatile.DenomuPOKT, 1000000) // 1 POKT.
+	s.keepers.SupplierKeeper.SetSupplier(s.ctx, sharedtypes.Supplier{
+		OwnerAddress:    s.supplierBech32,
+		OperatorAddress: s.supplierBech32,
+		Stake:           &supplierStake,
+		Services: []*sharedtypes.SupplierServiceConfig{
+			{
+				ServiceId: s.serviceId,
+				RevShare: []*sharedtypes.ServiceRevenueShare{
+					{
+						Address:            s.supplierBech32,
+						RevSharePercentage: 1,
+					},
+				},
+			},
+		},
+	})
+}
+
+// getSessionHeader gets the session header for the test session.
+func (s *applicationMinStakeTestSuite) getSessionHeader() *sessiontypes.SessionHeader {
+	sdkCtx := cosmostypes.UnwrapSDKContext(s.ctx)
+	currentHeight := sdkCtx.BlockHeight()
+	sessionRes, err := s.keepers.SessionKeeper.GetSession(s.ctx, &sessiontypes.QueryGetSessionRequest{
+		ApplicationAddress: s.appBech32,
+		ServiceId:          s.serviceId,
+		BlockHeight:        currentHeight,
+	})
+	require.NoError(s.T(), err)
+
+	return sessionRes.GetSession().GetHeader()
+}
+
+// getClaim creates a claim whose settlement amount drops the application below min stake.
+func (s *applicationMinStakeTestSuite) getClaim(
+	sessionHeader *sessiontypes.SessionHeader,
+) *prooftypes.Claim {
+	claimRoot := testproof.SmstRootWithSumAndCount(s.numRelays*s.numComputeUnitsPerRelay, s.numRelays)
+
+	return &prooftypes.Claim{
+		SupplierOperatorAddress: s.supplierBech32,
+		SessionHeader:           sessionHeader,
+		RootHash:                claimRoot,
+	}
+}
+
+// getAppBalance returns the bank module balance for the application.
+func (s *applicationMinStakeTestSuite) getAppBalance() *cosmostypes.Coin {
+	appBalRes, err := s.keepers.BankKeeper.Balance(s.ctx, &banktypes.QueryBalanceRequest{
+		Address: s.appBech32, Denom: volatile.DenomuPOKT,
+	})
+	require.NoError(s.T(), err)
+
+	return appBalRes.GetBalance()
+}

testutil/keeper/tokenomics.go

@@ -160,6 +160,10 @@ func TokenomicsKeeperWithActorAddrs(t testing.TB) (
 	mockApplicationKeeper.EXPECT().
 		SetApplication(gomock.Any(), gomock.Any()).
 		AnyTimes()
+	mockApplicationKeeper.EXPECT().
+		UnbondApplication(gomock.Any(), gomock.Any()).
+		Return(nil).
+		AnyTimes()
 
 	// Mock the supplier keeper.
 	mockSupplierKeeper := mocks.NewMockSupplierKeeper(ctrl)

testutil/testkeyring/accounts.go

@@ -117,10 +117,12 @@ func (iter *PreGeneratedAccountIterator) Next() (_ *PreGeneratedAccount, ok bool
 	return iter.accounts[currentIndex], true
 }
 
+// MustNext returns the next account in the iterator. It panics if the iterator
+// is out of accounts; see testutil/testkeyring/gen_accounts.
 func (iter *PreGeneratedAccountIterator) MustNext() *PreGeneratedAccount {
 	account, ok := iter.Next()
 	if !ok {
-		panic("insufficient number of pre-generated accounts")
+		panic("insufficient number of pre-generated accounts; see testutil/testkeyring/gen_accounts")
 	}
 	return account
 }

x/application/keeper/msg_server_stake_application.go

@@ -51,6 +51,7 @@ func (k msgServer) StakeApplication(ctx context.Context, msg *types.MsgStakeAppl
 		logger.Info(fmt.Sprintf("Application is going to escrow an additional %+v coins", coinsToEscrow))
 
 		// If the application has initiated an unstake action, cancel it since it is staking again.
+		// TODO_UPNEXT:(@bryanchriswhite): assert that an EventApplicationUnbondingCanceled event was emitted.
 		foundApp.UnstakeSessionEndHeight = types.ApplicationNotUnstaking
 	}
 
@@ -67,12 +68,14 @@ func (k msgServer) StakeApplication(ctx context.Context, msg *types.MsgStakeAppl
 
 	// MUST ALWAYS have at least minimum stake.
 	minStake := k.GetParams(ctx).MinStake
+	// TODO_CONSIDERATION: If we support multiple native tokens, we will need to
+	// start checking the denom here.
 	if msg.Stake.Amount.LT(minStake.Amount) {
-		errFmt := "application %q must stake at least %s"
-		logger.Info(fmt.Sprintf(errFmt, msg.Address, minStake))
+		err = fmt.Errorf("application %q must stake at least %s", msg.GetAddress(), minStake)
+		logger.Info(err.Error())
 		return nil, status.Error(
 			codes.InvalidArgument,
-			types.ErrAppInvalidStake.Wrapf(errFmt, msg.Address, minStake).Error(),
+			types.ErrAppInvalidStake.Wrapf("%s", err).Error(),
 		)
 	}
 

x/application/keeper/msg_server_unstake_application.go

@@ -61,6 +61,8 @@ func (k msgServer) UnstakeApplication(
 	foundApp.UnstakeSessionEndHeight = uint64(shared.GetSessionEndHeight(&sharedParams, currentHeight))
 	k.SetApplication(ctx, foundApp)
 
+	// TODO_UPNEXT:(@bryanchriswhite): emit a new EventApplicationUnbondingBegin event.
+
 	isSuccessful = true
 	return &types.MsgUnstakeApplicationResponse{}, nil
 }

x/application/keeper/msg_server_unstake_application_test.go

@@ -57,6 +57,8 @@ func TestMsgServer_UnstakeApplication_Success(t *testing.T) {
 	_, err = srv.UnstakeApplication(ctx, unstakeMsg)
 	require.NoError(t, err)
 
+	// TODO_UPNEXT:(@bryanchriswhite): assert that an EventApplicationUnbondingBegin event was emitted.
+
 	// Make sure the application entered the unbonding period
 	foundApp, isAppFound = applicationModuleKeepers.GetApplication(ctx, unstakingAppAddr)
 	require.True(t, isAppFound)
@@ -70,6 +72,8 @@ func TestMsgServer_UnstakeApplication_Success(t *testing.T) {
 	err = applicationModuleKeepers.EndBlockerUnbondApplications(ctx)
 	require.NoError(t, err)
 
+	// TODO_UPNEXT:(@bryanchriswhite): assert that an EventApplicationUnbondingEnd event was emitted.
+
 	// Make sure the unstaking application is removed from the applications list when
 	// the unbonding period is over.
 	_, isAppFound = applicationModuleKeepers.GetApplication(ctx, unstakingAppAddr)
@@ -105,6 +109,8 @@ func TestMsgServer_UnstakeApplication_CancelUnbondingIfRestaked(t *testing.T) {
 	_, err = srv.UnstakeApplication(ctx, unstakeMsg)
 	require.NoError(t, err)
 
+	// TODO_UPNEXT:(@bryanchriswhite): assert that an EventApplicationUnbondingBegin event was emitted.
+
 	// Make sure the application entered the unbonding period
 	foundApp, isAppFound = applicationModuleKeepers.GetApplication(ctx, appAddr)
 	require.True(t, isAppFound)
@@ -117,6 +123,8 @@ func TestMsgServer_UnstakeApplication_CancelUnbondingIfRestaked(t *testing.T) {
 	_, err = srv.StakeApplication(ctx, stakeMsg)
 	require.NoError(t, err)
 
+	// TODO_UPNEXT:(@bryanchriswhite): assert that an EventApplicationUnbondingCanceled event was emitted.
+
 	// Make sure the application is no longer in the unbonding period
 	foundApp, isAppFound = applicationModuleKeepers.GetApplication(ctx, appAddr)
 	require.True(t, isAppFound)

x/application/keeper/unbond_applications.go

@@ -7,7 +7,7 @@ import (
 	cosmostypes "github.com/cosmos/cosmos-sdk/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	"github.com/pokt-network/poktroll/x/application/types"
+	apptypes "github.com/pokt-network/poktroll/x/application/types"
 	"github.com/pokt-network/poktroll/x/shared"
 )
 
@@ -22,8 +22,6 @@ func (k Keeper) EndBlockerUnbondApplications(ctx context.Context) error {
 		return nil
 	}
 
-	logger := k.Logger().With("method", "UnbondApplication")
-
 	// Iterate over all applications and unbond the ones that have finished the unbonding period.
 	// TODO_IMPROVE: Use an index to iterate over the applications that have initiated
 	// the unbonding action instead of iterating over all of them.
@@ -33,37 +31,51 @@ func (k Keeper) EndBlockerUnbondApplications(ctx context.Context) error {
 			continue
 		}
 
-		unbondingHeight := types.GetApplicationUnbondingHeight(&sharedParams, &application)
+		unbondingHeight := apptypes.GetApplicationUnbondingHeight(&sharedParams, &application)
 
 		// If the unbonding height is ahead of the current height, the application
 		// stays in the unbonding state.
 		if unbondingHeight > currentHeight {
 			continue
 		}
 
-		// Retrieve the account address of the application.
-		applicationAccAddress, err := cosmostypes.AccAddressFromBech32(application.Address)
-		if err != nil {
-			logger.Error(fmt.Sprintf("could not parse address %s", application.Address))
+		if err := k.UnbondApplication(ctx, &application); err != nil {
 			return err
 		}
 
-		// Send the coins from the application pool back to the application
-		err = k.bankKeeper.SendCoinsFromModuleToAccount(
-			ctx, types.ModuleName, applicationAccAddress, []sdk.Coin{*application.Stake},
-		)
-		if err != nil {
-			logger.Error(fmt.Sprintf(
-				"could not send %v coins from module %s to account %s due to %v",
-				application.Stake, applicationAccAddress, types.ModuleName, err,
-			))
-			return err
-		}
+		// TODO_UPNEXT(@bryanchriswhite): emit a new EventApplicationUnbondingEnd event.
+	}
 
-		// Update the Application in the store
-		k.RemoveApplication(ctx, applicationAccAddress.String())
-		logger.Info(fmt.Sprintf("Successfully removed the application: %+v", application))
+	return nil
+}
+
+// UnbondApplication transfers the application stake to the bank module balance for the
+// corresponding account and removes the application from the application module state.
+func (k Keeper) UnbondApplication(ctx context.Context, app *apptypes.Application) error {
+	logger := k.Logger().With("method", "UnbondApplication")
+
+	// Retrieve the account address of the application.
+	appAddr, err := cosmostypes.AccAddressFromBech32(app.Address)
+	if err != nil {
+		logger.Error(fmt.Sprintf("could not parse address %s", app.Address))
+		return err
 	}
 
+	// Send the coins from the application pool back to the application.
+	err = k.bankKeeper.SendCoinsFromModuleToAccount(
+		ctx, apptypes.ModuleName, appAddr, []sdk.Coin{*app.Stake},
+	)
+	if err != nil {
+		logger.Error(fmt.Sprintf(
+			"could not send %v coins from module %s to account %s due to %v",
+			app.Stake, appAddr, apptypes.ModuleName, err,
+		))
+		return err
+	}
+
+	// Remove the Application from the store.
+	k.RemoveApplication(ctx, app.GetAddress())
+	logger.Info(fmt.Sprintf("Successfully removed the application: %+v", app))
+
 	return nil
 }