feat: add pool address

app/app.go

@@ -881,6 +881,7 @@ func NewMilkyWayApp(
 	app.PoolsKeeper = poolskeeper.NewKeeper(
 		app.appCodec,
 		keys[poolstypes.StoreKey],
+		app.AccountKeeper,
 	)
 
 	/****  Module Options ****/

proto/milkyway/pools/v1/models.proto

@@ -13,4 +13,8 @@ message Pool {
 
   // Denom represents the denomination of the tokens that are staked in the pool
   string denom = 2;
+
+  // Address represents the address of the account that is associated with this
+  // pool. This will be used to store tokens that users delegate to this pool.
+  string address = 3 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
 }

proto/milkyway/pools/v1/query.proto

@@ -33,7 +33,8 @@ message QueryPoolByIdRequest {
   uint32 pool_id = 1;
 }
 
-// QueryPoolByDenomRequest is the request type for the Query/PollByDenom RPC method.
+// QueryPoolByDenomRequest is the request type for the Query/PollByDenom RPC
+// method.
 message QueryPoolByDenomRequest {
   // Denom is the denom for which the pool is to be queried
   string denom = 1;

x/pools/keeper/alias_functions.go

@@ -2,11 +2,20 @@ package keeper
 
 import (
 	storetypes "cosmossdk.io/store/types"
+	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/milkyway-labs/milkyway/x/pools/types"
 )
 
+// createAccountIfNotExists creates an account if it does not exist
+func (k *Keeper) createAccountIfNotExists(ctx sdk.Context, address sdk.AccAddress) {
+	if !k.accountKeeper.HasAccount(ctx, address) {
+		defer telemetry.IncrCounter(1, "new", "account")
+		k.accountKeeper.SetAccount(ctx, k.accountKeeper.NewAccountWithAddress(ctx, address))
+	}
+}
+
 // IteratePools iterates over the pools in the store and performs a callback function
 func (k *Keeper) IteratePools(ctx sdk.Context, cb func(pool types.Pool) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
@@ -75,7 +84,10 @@ func (k *Keeper) CreateOrGetPoolByDenom(ctx sdk.Context, denom string) (types.Po
 	}
 
 	// Save the pool
-	k.SavePool(ctx, pool)
+	err = k.SavePool(ctx, pool)
+	if err != nil {
+		return types.Pool{}, err
+	}
 
 	// Increment the pool id
 	k.SetNextPoolID(ctx, poolID+1)

x/pools/keeper/alias_functions_test.go

@@ -24,7 +24,8 @@ func (suite *KeeperTestSuite) TestKeeper_GetPoolForDenom() {
 		{
 			name: "existing pool is returned properly",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			denom:    "umilk",
 			expFound: true,
@@ -82,7 +83,8 @@ func (suite *KeeperTestSuite) TestKeeper_CreateOrGetPoolByDenom() {
 		{
 			name: "existing pool is returned properly",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			denom:     "umilk",
 			shouldErr: false,

x/pools/keeper/common_test.go

@@ -91,5 +91,6 @@ func (suite *KeeperTestSuite) SetupTest() {
 	suite.k = keeper.NewKeeper(
 		suite.cdc,
 		suite.storeKey,
+		suite.ak,
 	)
 }

x/pools/keeper/genesis.go

@@ -32,6 +32,9 @@ func (k *Keeper) InitGenesis(ctx sdk.Context, data *types.GenesisState) {
 
 	// Store the pools
 	for _, pool := range data.Pools {
-		k.SavePool(ctx, pool)
+		err := k.SavePool(ctx, pool)
+		if err != nil {
+			panic(err)
+		}
 	}
 }

x/pools/keeper/genesis_test.go

@@ -26,8 +26,11 @@ func (suite *KeeperTestSuite) TestKeeper_ExportGenesis() {
 			name: "pools are exported properly",
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 1)
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
-				suite.k.SavePool(ctx, types.NewPool(2, "uatom"))
+
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
+				err = suite.k.SavePool(ctx, types.NewPool(2, "uatom"))
+				suite.Require().NoError(err)
 			},
 			expGenesis: &types.GenesisState{
 				NextPoolID: 1,

x/pools/keeper/grpc_query_test.go

@@ -25,7 +25,8 @@ func (suite *KeeperTestSuite) TestQueryServer_PoolById() {
 		{
 			name: "found pool is returned properly",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			request: &types.QueryPoolByIdRequest{
 				PoolId: 1,
@@ -76,7 +77,8 @@ func (suite *KeeperTestSuite) TestQueryServer_PoolByDenom() {
 		{
 			name: "found pool is returned properly",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			request: &types.QueryPoolByDenomRequest{
 				Denom: "umilk",

x/pools/keeper/invariants_test.go

@@ -17,40 +17,47 @@ func (suite *KeeperTestSuite) TestValidPoolsInvariant() {
 		{
 			name: "not found next service id breaks invariant",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			expBroken: true,
 		},
 		{
 			name: "service with id equals to next service id breaks invariant",
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 1)
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
 			},
 			expBroken: true,
 		},
 		{
 			name: "service with id higher than next service id breaks invariant",
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 1)
-				suite.k.SavePool(ctx, types.NewPool(2, "umilk"))
+				err := suite.k.SavePool(ctx, types.NewPool(2, "umilk"))
+				suite.Require().NoError(err)
 			},
 			expBroken: true,
 		},
 		{
 			name: "invalid service breaks invariant",
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 2)
-				suite.k.SavePool(ctx, types.NewPool(1, "invalid!"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "invalid!"))
+				suite.Require().NoError(err)
 			},
 			expBroken: true,
 		},
 		{
 			name: "valid data does not break invariant",
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 3)
-				suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
-				suite.k.SavePool(ctx, types.NewPool(2, "unit"))
+
+				err := suite.k.SavePool(ctx, types.NewPool(1, "umilk"))
+				suite.Require().NoError(err)
+				err = suite.k.SavePool(ctx, types.NewPool(2, "unit"))
+				suite.Require().NoError(err)
 			},
 			expBroken: false,
 		},

x/pools/keeper/keeper.go

@@ -12,12 +12,15 @@ import (
 type Keeper struct {
 	storeKey storetypes.StoreKey
 	cdc      codec.Codec
+
+	accountKeeper types.AccountKeeper
 }
 
-func NewKeeper(cdc codec.Codec, storeKey storetypes.StoreKey) *Keeper {
+func NewKeeper(cdc codec.Codec, storeKey storetypes.StoreKey, accountKeeper types.AccountKeeper) *Keeper {
 	return &Keeper{
-		storeKey: storeKey,
-		cdc:      cdc,
+		storeKey:      storeKey,
+		cdc:           cdc,
+		accountKeeper: accountKeeper,
 	}
 }
 

x/pools/keeper/pools.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/milkyway-labs/milkyway/x/pools/types"
 )
@@ -28,9 +29,18 @@ func (k *Keeper) GetNextPoolID(ctx sdk.Context) (serviceID uint32, err error) {
 // --------------------------------------------------------------------------------------------------------------------
 
 // SavePool stores the given pool inside the store
-func (k *Keeper) SavePool(ctx sdk.Context, pool types.Pool) {
+func (k *Keeper) SavePool(ctx sdk.Context, pool types.Pool) error {
 	store := ctx.KVStore(k.storeKey)
 	store.Set(types.GetPoolStoreKey(pool.ID), k.cdc.MustMarshal(&pool))
+
+	// Create the pool account if it does not exist
+	poolAddress, err := sdk.AccAddressFromBech32(pool.Address)
+	if err != nil {
+		return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid pool address: %s", pool.Address)
+	}
+	k.createAccountIfNotExists(ctx, poolAddress)
+
+	return nil
 }
 
 // GetPool retrieves the pool with the given ID from the store.

x/pools/keeper/pools_test.go

@@ -107,25 +107,37 @@ func (suite *KeeperTestSuite) TestKeeper_SavePool() {
 			store: func(ctx sdk.Context) {
 				suite.k.SetNextPoolID(ctx, 1)
 			},
-			shouldErr: true,
+			shouldErr: false,
 			pool:      types.NewPool(1, "uatom"),
 			check: func(ctx sdk.Context) {
+				// Make sure the pool is saved properly
 				pool, found := suite.k.GetPool(ctx, 1)
 				suite.Require().True(found)
 				suite.Require().Equal(types.NewPool(1, "uatom"), pool)
+
+				// Make sure the pool account is created
+				hasAccount := suite.ak.HasAccount(ctx, types.GetPoolAddress(1))
+				suite.Require().True(hasAccount)
 			},
 		},
 		{
 			name: "existing pool is overridden properly",
 			setup: func() {
 				suite.k.SetNextPoolID(suite.ctx, 1)
-				suite.k.SavePool(suite.ctx, types.NewPool(1, "uatom"))
+				err := suite.k.SavePool(suite.ctx, types.NewPool(1, "uatom"))
+				suite.Require().NoError(err)
 			},
-			pool: types.NewPool(1, "usdt"),
+			pool:      types.NewPool(1, "usdt"),
+			shouldErr: false,
 			check: func(ctx sdk.Context) {
+				// Make sure the pool is saved properly
 				pool, found := suite.k.GetPool(ctx, 1)
 				suite.Require().True(found)
 				suite.Require().Equal(types.NewPool(1, "usdt"), pool)
+
+				// Make sure the pool account is created
+				hasAccount := suite.ak.HasAccount(ctx, types.GetPoolAddress(1))
+				suite.Require().True(hasAccount)
 			},
 		},
 	}
@@ -141,7 +153,12 @@ func (suite *KeeperTestSuite) TestKeeper_SavePool() {
 				tc.store(ctx)
 			}
 
-			suite.k.SavePool(ctx, tc.pool)
+			err := suite.k.SavePool(ctx, tc.pool)
+			if tc.shouldErr {
+				suite.Require().Error(err)
+			} else {
+				suite.Require().NoError(err)
+			}
 
 			if tc.check != nil {
 				tc.check(ctx)
@@ -168,7 +185,8 @@ func (suite *KeeperTestSuite) TestKeeper_GetPool() {
 		{
 			name: "found pool is returned properly",
 			store: func(ctx sdk.Context) {
-				suite.k.SavePool(ctx, types.NewPool(1, "uatom"))
+				err := suite.k.SavePool(ctx, types.NewPool(1, "uatom"))
+				suite.Require().NoError(err)
 			},
 			poolID:   1,
 			expFound: true,

x/pools/types/expected_keepers.go

@@ -0,0 +1,13 @@
+package types
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type AccountKeeper interface {
+	NewAccountWithAddress(ctx context.Context, addr sdk.AccAddress) sdk.AccountI
+	HasAccount(ctx context.Context, addr sdk.AccAddress) bool
+	SetAccount(ctx context.Context, acc sdk.AccountI)
+}

x/pools/types/models.go

@@ -5,8 +5,14 @@ import (
 	"strconv"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
+// GetPoolAddress generates a pool address from its id
+func GetPoolAddress(poolID uint32) sdk.AccAddress {
+	return authtypes.NewModuleAddress(fmt.Sprintf("pool-%d", poolID))
+}
+
 // ParsePoolID parses a pool id from a string
 func ParsePoolID(value string) (uint32, error) {
 	parsed, err := strconv.ParseUint(value, 10, 32)
@@ -21,8 +27,9 @@ func ParsePoolID(value string) (uint32, error) {
 // NewPool creates a new Pool instance
 func NewPool(id uint32, denom string) Pool {
 	return Pool{
-		ID:    id,
-		Denom: denom,
+		ID:      id,
+		Denom:   denom,
+		Address: GetPoolAddress(id).String(),
 	}
 }
 
@@ -36,5 +43,10 @@ func (p *Pool) Validate() error {
 		return fmt.Errorf("invalid pool denom")
 	}
 
+	_, err := sdk.AccAddressFromBech32(p.Address)
+	if err != nil {
+		return fmt.Errorf("invalid pool address")
+	}
+
 	return nil
 }