[Tokenomics] SettleSessionAccounting first implementation (emissions=burn)

app/app.go

@@ -7,6 +7,8 @@ import (
 	"os"
 	"path/filepath"
 
+	// this line is used by starport scaffolding # stargate/app/moduleImport
+
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
 	reflectionv1 "cosmossdk.io/api/cosmos/reflection/v1"
 	dbm "github.com/cometbft/cometbft-db"
@@ -108,8 +110,6 @@ import (
 	ibckeeper "github.com/cosmos/ibc-go/v7/modules/core/keeper"
 	solomachine "github.com/cosmos/ibc-go/v7/modules/light-clients/06-solomachine"
 	ibctm "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
-	"github.com/spf13/cast"
-
 	appparams "github.com/pokt-network/poktroll/app/params"
 	"github.com/pokt-network/poktroll/docs"
 	applicationmodule "github.com/pokt-network/poktroll/x/application"
@@ -133,6 +133,7 @@ import (
 	tokenomicsmodule "github.com/pokt-network/poktroll/x/tokenomics"
 	tokenomicsmodulekeeper "github.com/pokt-network/poktroll/x/tokenomics/keeper"
 	tokenomicsmoduletypes "github.com/pokt-network/poktroll/x/tokenomics/types"
+	"github.com/spf13/cast"
 )
 
 const (
@@ -651,6 +652,8 @@ func New(
 		keys[tokenomicsmoduletypes.MemStoreKey],
 		app.GetSubspace(tokenomicsmoduletypes.ModuleName),
 		app.BankKeeper,
+		app.ApplicationKeeper,
+		app.SupplierKeeper,
 		authority,
 	)
 	tokenomicsModule := tokenomicsmodule.NewAppModule(appCodec, app.TokenomicsKeeper, app.AccountKeeper, app.BankKeeper)

pkg/sdk/errors.go

@@ -1,6 +1,11 @@
 package sdk
 
-import sdkerrors "cosmossdk.io/errors"
+import (
+	sdkerrors "cosmossdk.io/errors"
+)
+
+// TODO_TECHDEBT: Do a source code wise find-replace using regex pattern match
+// of `sdkerrors\.Wrapf\(([a-zA-Z]+), ` with `$1.Wrapf(`
 
 var (
 	codespace                           = "poktrollsdk"

testutil/keeper/tokenomics.go

@@ -16,27 +16,76 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 
+	"github.com/pokt-network/poktroll/cmd/pocketd/cmd"
+	"github.com/pokt-network/poktroll/testutil/sample"
 	mocks "github.com/pokt-network/poktroll/testutil/tokenomics/mocks"
+	apptypes "github.com/pokt-network/poktroll/x/application/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+	suppliertypes "github.com/pokt-network/poktroll/x/supplier/types"
 	"github.com/pokt-network/poktroll/x/tokenomics/keeper"
 	"github.com/pokt-network/poktroll/x/tokenomics/types"
 )
 
-func TokenomicsKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
+func init() {
+	cmd.InitSDKConfig()
+}
+
+func TokenomicsKeeper(t testing.TB) (
+	k *keeper.Keeper, s sdk.Context,
+	appAddr, supplierAddr string,
+) {
 	storeKey := sdk.NewKVStoreKey(types.StoreKey)
 	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
 
+	// Initialize the in-memory tendermint database
 	db := tmdb.NewMemDB()
 	stateStore := store.NewCommitMultiStore(db)
 	stateStore.MountStoreWithDB(storeKey, storetypes.StoreTypeIAVL, db)
 	stateStore.MountStoreWithDB(memStoreKey, storetypes.StoreTypeMemory, nil)
 	require.NoError(t, stateStore.LoadLatestVersion())
 
+	// Initialize the codec and other necessary components
 	registry := codectypes.NewInterfaceRegistry()
 	cdc := codec.NewProtoCodec(registry)
+	ctrl := gomock.NewController(t)
 
+	// The on-chain governance address
 	authority := authtypes.NewModuleAddress("gov").String()
 
-	ctrl := gomock.NewController(t)
+	// Prepare the test application
+	application := apptypes.Application{
+		Address: sample.AccAddress(),
+		Stake:   &sdk.Coin{Denom: "upokt", Amount: sdk.NewInt(100000)},
+	}
+
+	// Prepare the test supplier
+	supplier := sharedtypes.Supplier{
+		Address: sample.AccAddress(),
+		Stake:   &sdk.Coin{Denom: "upokt", Amount: sdk.NewInt(100000)},
+	}
+
+	// Mock the application keeper
+	mockApplicationKeeper := mocks.NewMockApplicationKeeper(ctrl)
+	mockApplicationKeeper.EXPECT().
+		GetApplication(gomock.Any(), gomock.Eq(application.Address)).
+		Return(application, true).
+		AnyTimes()
+	mockApplicationKeeper.EXPECT().
+		GetApplication(gomock.Any(), gomock.Not(application.Address)).
+		Return(apptypes.Application{}, false).
+		AnyTimes()
+	mockApplicationKeeper.EXPECT().
+		SetApplication(gomock.Any(), gomock.Any()).
+		AnyTimes()
+
+	// Mock the supplier keeper
+	mockSupplierKeeper := mocks.NewMockSupplierKeeper(ctrl)
+	mockSupplierKeeper.EXPECT().
+		GetSupplier(gomock.Any(), supplier.Address).
+		Return(supplier, true).
+		AnyTimes()
+
+	// Mock the bank keeper
 	mockBankKeeper := mocks.NewMockBankKeeper(ctrl)
 	mockBankKeeper.EXPECT().
 		MintCoins(gomock.Any(), gomock.Any(), gomock.Any()).
@@ -45,36 +94,39 @@ func TokenomicsKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 		BurnCoins(gomock.Any(), gomock.Any(), gomock.Any()).
 		AnyTimes()
 	mockBankKeeper.EXPECT().
-		SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), types.ModuleName, gomock.Any()).
+		SendCoinsFromModuleToAccount(gomock.Any(), suppliertypes.ModuleName, gomock.Any(), gomock.Any()).
 		AnyTimes()
 	mockBankKeeper.EXPECT().
-		SendCoinsFromModuleToModule(gomock.Any(), types.ModuleName, gomock.Any(), gomock.Any()).
+		SendCoinsFromAccountToModule(gomock.Any(), gomock.Any(), apptypes.ModuleName, gomock.Any()).
 		AnyTimes()
 	mockBankKeeper.EXPECT().
-		SendCoinsFromAccountToModule(gomock.Any(), types.ModuleName, gomock.Any(), gomock.Any()).
+		UndelegateCoinsFromModuleToAccount(gomock.Any(), apptypes.ModuleName, gomock.Any(), gomock.Any()).
 		AnyTimes()
 
+	// Initialize the tokenomics keeper
 	paramsSubspace := typesparams.NewSubspace(cdc,
 		types.Amino,
 		storeKey,
 		memStoreKey,
 		"TokenomicsParams",
 	)
-	k := keeper.NewKeeper(
+	tokenomicsKeeper := keeper.NewKeeper(
 		cdc,
 		storeKey,
 		memStoreKey,
 		paramsSubspace,
 
 		mockBankKeeper,
+		mockApplicationKeeper,
+		mockSupplierKeeper,
 
 		authority,
 	)
 
 	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger())
 
 	// Initialize params
-	k.SetParams(ctx, types.DefaultParams())
+	tokenomicsKeeper.SetParams(ctx, types.DefaultParams())
 
-	return k, ctx
+	return tokenomicsKeeper, ctx, application.Address, supplier.Address
 }

x/session/types/errors.go

@@ -15,4 +15,5 @@ var (
 	ErrSessionInvalidAppAddress      = sdkerrors.Register(ModuleName, 5, "invalid application address for session")
 	ErrSessionInvalidService         = sdkerrors.Register(ModuleName, 6, "invalid service in session")
 	ErrSessionInvalidBlockHeight     = sdkerrors.Register(ModuleName, 7, "invalid block height for session")
+	ErrSessionInvalidSessionId       = sdkerrors.Register(ModuleName, 8, "invalid sessionId")
 )

x/session/types/query_get_session_request.go

@@ -1,7 +1,6 @@
 package types
 
 import (
-	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	sharedhelpers "github.com/pokt-network/poktroll/x/shared/helpers"
@@ -24,17 +23,17 @@ func NewQueryGetSessionRequest(appAddress, serviceId string, blockHeight int64)
 func (query *QueryGetSessionRequest) ValidateBasic() error {
 	// Validate the application address
 	if _, err := sdk.AccAddressFromBech32(query.ApplicationAddress); err != nil {
-		return sdkerrors.Wrapf(ErrSessionInvalidAppAddress, "invalid app address for session being retrieved %s; (%v)", query.ApplicationAddress, err)
+		return ErrSessionInvalidAppAddress.Wrapf("invalid app address for session being retrieved %s; (%v)", query.ApplicationAddress, err)
 	}
 
 	// Validate the Service ID
 	if !sharedhelpers.IsValidService(query.Service) {
-		return sdkerrors.Wrapf(ErrSessionInvalidService, "invalid service for session being retrieved %s;", query.Service)
+		return ErrSessionInvalidService.Wrapf("invalid service for session being retrieved %s;", query.Service)
 	}
 
 	// Validate the height for which a session is being retrieved
 	if query.BlockHeight < 0 { // Note that `0` defaults to the latest height rather than genesis
-		return sdkerrors.Wrapf(ErrSessionInvalidBlockHeight, "invalid block height for session being retrieved %d;", query.BlockHeight)
+		return ErrSessionInvalidBlockHeight.Wrapf("invalid block height for session being retrieved %d;", query.BlockHeight)
 	}
 	return nil
 }

x/session/types/session_header.go

@@ -0,0 +1,34 @@
+package types
+
+import (
+	sdkerrors "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// TODO_TECHDEBT: Make sure this is used everywhere we validate components
+// of the session header.
+func (sh *SessionHeader) ValidateBasic() error {
+	// Validate the application address
+	if _, err := sdk.AccAddressFromBech32(sh.ApplicationAddress); err != nil {
+		return sdkerrors.Wrapf(ErrSessionInvalidAppAddress, "invalid application address: %s; (%v)", sh.ApplicationAddress, err)
+	}
+
+	// Validate the session ID
+	// TODO_TECHDEBT: Introduce a `SessionId#ValidateBasic` method.
+	if sh.SessionId == "" {
+		return sdkerrors.Wrapf(ErrSessionInvalidSessionId, "invalid session ID: %s", sh.SessionId)
+	}
+
+	// Validate the service
+	// TODO_TECHDEBT: Introduce a `Service#ValidateBasic` method.
+	if sh.Service == nil {
+		return sdkerrors.Wrapf(ErrSessionInvalidService, "invalid service: %s", sh.Service)
+	}
+
+	// Check if session end height is greater than session start height
+	if sh.SessionEndBlockHeight <= sh.SessionStartBlockHeight {
+		return sdkerrors.Wrapf(ErrSessionInvalidBlockHeight, "session end block height cannot be less than or equal to session start block height")
+	}
+
+	return nil
+}

x/session/types/session_header_test.go

@@ -0,0 +1,86 @@
+package types_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/pokt-network/poktroll/testutil/sample"
+	"github.com/pokt-network/poktroll/x/session/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+)
+
+func TestSessionHeader_ValidateBasic(t *testing.T) {
+	tests := []struct {
+		desc string
+		sh   types.SessionHeader
+		err  error
+	}{
+		{
+			desc: "invalid - invalid application address",
+			sh: types.SessionHeader{
+				ApplicationAddress:      "invalid_address",
+				SessionId:               "valid_session_id",
+				Service:                 &sharedtypes.Service{},
+				SessionStartBlockHeight: 100,
+				SessionEndBlockHeight:   101,
+			},
+			err: types.ErrSessionInvalidAppAddress,
+		},
+		{
+			desc: "invalid - empty session id",
+			sh: types.SessionHeader{
+				ApplicationAddress:      sample.AccAddress(),
+				SessionId:               "",
+				Service:                 &sharedtypes.Service{},
+				SessionStartBlockHeight: 100,
+				SessionEndBlockHeight:   101,
+			},
+			err: types.ErrSessionInvalidSessionId,
+		},
+		{
+			desc: "invalid - nil service",
+			sh: types.SessionHeader{
+				ApplicationAddress:      sample.AccAddress(),
+				SessionId:               "valid_session_id",
+				Service:                 nil,
+				SessionStartBlockHeight: 100,
+				SessionEndBlockHeight:   101,
+			},
+			err: types.ErrSessionInvalidService,
+		},
+		{
+			desc: "invalid - start block height greater than end block height",
+			sh: types.SessionHeader{
+				ApplicationAddress:      sample.AccAddress(),
+				SessionId:               "valid_session_id",
+				Service:                 &sharedtypes.Service{},
+				SessionStartBlockHeight: 100,
+				SessionEndBlockHeight:   99,
+			},
+			err: types.ErrSessionInvalidBlockHeight,
+		},
+		{
+			desc: "valid",
+			sh: types.SessionHeader{
+				ApplicationAddress:      sample.AccAddress(),
+				SessionId:               "valid_session_id",
+				Service:                 &sharedtypes.Service{},
+				SessionStartBlockHeight: 100,
+				SessionEndBlockHeight:   101,
+			},
+			err: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			err := tt.sh.ValidateBasic()
+			if tt.err != nil {
+				require.ErrorIs(t, err, tt.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

x/tokenomics/genesis_test.go

@@ -18,7 +18,7 @@ func TestGenesis(t *testing.T) {
 		// this line is used by starport scaffolding # genesis/test/state
 	}
 
-	k, ctx := keepertest.TokenomicsKeeper(t)
+	k, ctx, _, _ := keepertest.TokenomicsKeeper(t)
 	tokenomics.InitGenesis(ctx, *k, genesisState)
 	got := tokenomics.ExportGenesis(ctx, *k)
 	require.NotNil(t, got)

x/tokenomics/keeper/keeper.go

@@ -24,7 +24,9 @@ type Keeper struct {
 	paramstore paramtypes.Subspace
 
 	// keeper dependencies
-	bankKeeper types.BankKeeper
+	appKeeper      types.ApplicationKeeper
+	supplierKeeper types.SupplierKeeper
+	bankKeeper     types.BankKeeper
 
 	// the address capable of executing a MsgUpdateParams message. Typically, this
 	// should be the x/gov module account.
@@ -39,6 +41,8 @@ func NewKeeper(
 
 	// keeper dependencies
 	bankKeeper types.BankKeeper,
+	appKeeper types.ApplicationKeeper,
+	supplierKeeper types.SupplierKeeper,
 
 	authority string,
 ) *Keeper {
@@ -53,6 +57,10 @@ func NewKeeper(
 		memKey:     memKey,
 		paramstore: ps,
 
+		bankKeeper:     bankKeeper,
+		appKeeper:      appKeeper,
+		supplierKeeper: supplierKeeper,
+
 		authority: authority,
 	}
 }

x/tokenomics/keeper/msg_server_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func setupMsgServer(t testing.TB) (types.MsgServer, context.Context) {
-	k, ctx := testkeeper.TokenomicsKeeper(t)
+	k, ctx, _, _ := testkeeper.TokenomicsKeeper(t)
 	return keeper.NewMsgServerImpl(*k), sdk.WrapSDKContext(ctx)
 }
 

x/tokenomics/keeper/msg_server_update_params.go

@@ -47,7 +47,7 @@ func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
 }
 
 // ComputeUnitsToTokensMultiplier returns the ComputeUnitsToTokensMultiplier param
-func (k Keeper) ComputeUnitsToTokensMultiplier(ctx sdk.Context) (res uint64) {
-	k.paramstore.Get(ctx, types.KeyComputeUnitsToTokensMultiplier, &res)
+func (k Keeper) ComputeUnitsToTokensMultiplier(ctx sdk.Context) (param uint64) {
+	k.paramstore.Get(ctx, types.KeyComputeUnitsToTokensMultiplier, &param)
 	return
 }