diff --git a/app/app.go b/app/app.go index b81f37b549..2c0f204c32 100644 --- a/app/app.go +++ b/app/app.go @@ -534,11 +534,6 @@ func New( ).SetHooks(epochmoduletypes.NewMultiEpochHooks( app.MintKeeper.Hooks())) - tokenFactoryConfig, err := tokenfactorykeeper.ReadConfig(appOpts) - if err != nil { - panic(fmt.Sprintf("error reading token factory config due to %s", err)) - } - app.TokenFactoryKeeper = tokenfactorykeeper.NewKeeper( appCodec, app.keys[tokenfactorytypes.StoreKey], @@ -546,7 +541,6 @@ func New( app.AccountKeeper, app.BankKeeper.(bankkeeper.BaseKeeper).WithMintCoinsRestriction(tokenfactorytypes.NewTokenFactoryDenomMintCoinsRestriction()), app.DistrKeeper, - tokenFactoryConfig, ) // The last arguments can contain custom message handlers, and custom query handlers, diff --git a/app/test_helpers.go b/app/test_helpers.go index 5e36a976a5..16c1c80c1f 100644 --- a/app/test_helpers.go +++ b/app/test_helpers.go @@ -15,7 +15,6 @@ import ( slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" "github.com/cosmos/cosmos-sdk/x/staking/teststaking" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - tokenfactorykeeper "github.com/sei-protocol/sei-chain/x/tokenfactory/keeper" "github.com/stretchr/testify/suite" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/config" @@ -56,9 +55,6 @@ func (t TestAppOpts) Get(s string) interface{} { if s == FlagSCEnable { return t.useSc } - if s == tokenfactorykeeper.FlagDenomAllowListMaxSize { - return 3 - } return nil } diff --git a/proto/tokenfactory/params.proto b/proto/tokenfactory/params.proto index 2542d680e3..af4efddd80 100644 --- a/proto/tokenfactory/params.proto +++ b/proto/tokenfactory/params.proto @@ -4,4 +4,6 @@ package seiprotocol.seichain.tokenfactory; option go_package = "github.com/sei-protocol/sei-chain/x/tokenfactory/types"; // Params defines the parameters for the tokenfactory module. -message Params {} +message Params { + uint32 denom_allowlist_max_size = 1; +} diff --git a/x/tokenfactory/keeper/config.go b/x/tokenfactory/keeper/config.go deleted file mode 100644 index 4fa177429c..0000000000 --- a/x/tokenfactory/keeper/config.go +++ /dev/null @@ -1,29 +0,0 @@ -package keeper - -import ( - servertypes "github.com/cosmos/cosmos-sdk/server/types" - "github.com/spf13/cast" -) - -type Config struct { - DenomAllowListMaxSize int `mapstructure:"denom_allow_list_max_size"` -} - -var DefaultConfig = Config{ - DenomAllowListMaxSize: 2000, -} - -const ( - FlagDenomAllowListMaxSize = "tokenfactory.denom_allow_list_max_size" -) - -func ReadConfig(opts servertypes.AppOptions) (Config, error) { - cfg := DefaultConfig // copy - var err error - if v := opts.Get(FlagDenomAllowListMaxSize); v != nil { - if cfg.DenomAllowListMaxSize, err = cast.ToIntE(v); err != nil { - return cfg, err - } - } - return cfg, nil -} diff --git a/x/tokenfactory/keeper/createdenom.go b/x/tokenfactory/keeper/createdenom.go index cdc3549815..4394ffb616 100644 --- a/x/tokenfactory/keeper/createdenom.go +++ b/x/tokenfactory/keeper/createdenom.go @@ -79,7 +79,7 @@ func (k Keeper) validateUpdateDenom(ctx sdk.Context, msg *types.MsgUpdateDenom) return "", types.ErrDenomDoesNotExist.Wrapf("denom: %s", msg.GetDenom()) } - err = k.validateAllowList(msg.AllowList) + err = k.validateAllowList(ctx, msg.AllowList) if err != nil { return "", err } @@ -87,19 +87,19 @@ func (k Keeper) validateUpdateDenom(ctx sdk.Context, msg *types.MsgUpdateDenom) return msg.GetDenom(), nil } -func (k Keeper) validateAllowListSize(allowList *banktypes.AllowList) error { +func (k Keeper) validateAllowListSize(ctx sdk.Context, allowList *banktypes.AllowList) error { if allowList == nil { return types.ErrAllowListUndefined } - if len(allowList.Addresses) > k.config.DenomAllowListMaxSize { + if len(allowList.Addresses) > int(k.GetDenomAllowListMaxSize(ctx)) { return types.ErrAllowListTooLarge } return nil } -func (k Keeper) validateAllowList(allowList *banktypes.AllowList) error { - err := k.validateAllowListSize(allowList) +func (k Keeper) validateAllowList(ctx sdk.Context, allowList *banktypes.AllowList) error { + err := k.validateAllowListSize(ctx, allowList) if err != nil { return err } diff --git a/x/tokenfactory/keeper/createdenom_test.go b/x/tokenfactory/keeper/createdenom_test.go index e24cb54315..a81c9c1175 100644 --- a/x/tokenfactory/keeper/createdenom_test.go +++ b/x/tokenfactory/keeper/createdenom_test.go @@ -2,7 +2,6 @@ package keeper_test import ( "fmt" - banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -51,6 +50,9 @@ func (suite *KeeperTestSuite) TestMsgCreateDenom() { } func (suite *KeeperTestSuite) TestCreateDenom() { + params, _ := suite.queryClient.Params(suite.Ctx.Context(), &types.QueryParamsRequest{}) + allowListSize := params.Params.DenomAllowlistMaxSize + largeAllowList := make([]string, allowListSize+1) for _, tc := range []struct { desc string setup func() @@ -99,16 +101,10 @@ func (suite *KeeperTestSuite) TestCreateDenom() { valid: false, }, { - desc: "list is too large", - subdenom: "test", - allowList: &banktypes.AllowList{ - Addresses: []string{ - suite.TestAccs[0].String(), - suite.TestAccs[1].String(), - suite.TestAccs[2].String(), - suite.TestAccs[2].String()}, - }, - valid: false, + desc: "list is too large", + subdenom: "test", + allowList: &banktypes.AllowList{Addresses: largeAllowList}, + valid: false, }, } { suite.Run(fmt.Sprintf("Case %s", tc.desc), func() { @@ -158,6 +154,9 @@ func (suite *KeeperTestSuite) TestCreateDenom() { } func (suite *KeeperTestSuite) TestUpdateDenom() { + params, _ := suite.queryClient.Params(suite.Ctx.Context(), &types.QueryParamsRequest{}) + allowListSize := params.Params.DenomAllowlistMaxSize + largeAllowList := make([]string, allowListSize+1) for _, tc := range []struct { desc string setup func() @@ -222,17 +221,10 @@ func (suite *KeeperTestSuite) TestUpdateDenom() { types.NewMsgCreateDenom(suite.TestAccs[0].String(), "TLRG")) suite.Require().NoError(err) }, - denom: fmt.Sprintf("factory/%s/TLRG", suite.TestAccs[0].String()), - allowList: &banktypes.AllowList{ - Addresses: []string{ - suite.TestAccs[0].String(), - suite.TestAccs[1].String(), - suite.TestAccs[2].String(), - suite.TestAccs[2].String(), - }, - }, - valid: false, - errMsg: "allowlist too large", + denom: fmt.Sprintf("factory/%s/TLRG", suite.TestAccs[0].String()), + allowList: &banktypes.AllowList{Addresses: largeAllowList}, + valid: false, + errMsg: "allowlist too large", }, { desc: "denom having invalid characters", diff --git a/x/tokenfactory/keeper/keeper.go b/x/tokenfactory/keeper/keeper.go index ed4ecc02ad..51a6d80a99 100644 --- a/x/tokenfactory/keeper/keeper.go +++ b/x/tokenfactory/keeper/keeper.go @@ -24,8 +24,6 @@ type ( accountKeeper types.AccountKeeper bankKeeper types.BankKeeper distrKeeper types.DistrKeeper - - config Config } ) @@ -37,7 +35,6 @@ func NewKeeper( accountKeeper types.AccountKeeper, bankKeeper types.BankKeeper, distrKeeper types.DistrKeeper, - config Config, ) Keeper { if !paramSpace.HasKeyTable() { paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) @@ -50,8 +47,6 @@ func NewKeeper( accountKeeper: accountKeeper, bankKeeper: bankKeeper, distrKeeper: distrKeeper, - - config: config, } } @@ -86,3 +81,9 @@ func (k Keeper) CreateModuleAccount(ctx sdk.Context) { moduleAcc := authtypes.NewEmptyModuleAccount(types.ModuleName, authtypes.Minter, authtypes.Burner) k.accountKeeper.SetModuleAccount(ctx, moduleAcc) } + +func (k Keeper) GetDenomAllowListMaxSize(ctx sdk.Context) uint32 { + var denomAllowListMaxSize uint32 + k.paramSpace.Get(ctx, types.DenomAllowListMaxSizeKey, &denomAllowListMaxSize) + return denomAllowListMaxSize +} diff --git a/x/tokenfactory/keeper/migrations.go b/x/tokenfactory/keeper/migrations.go index b58f47c09f..418ed89d9b 100644 --- a/x/tokenfactory/keeper/migrations.go +++ b/x/tokenfactory/keeper/migrations.go @@ -25,7 +25,7 @@ func NewMigrator(keeper Keeper) Migrator { // Migrate2to3 migrates from version 2 to 3. func (m Migrator) Migrate2to3(ctx sdk.Context) error { // Reset params after removing the denom creation fee param - defaultParams := types.DefaultParams() + defaultParams := types.Params{} m.keeper.paramSpace.SetParamSet(ctx, &defaultParams) // We remove the denom creation fee whitelist in this migration @@ -58,6 +58,13 @@ func (m Migrator) Migrate3to4(ctx sdk.Context) error { return nil } +func (m Migrator) Migrate4to5(ctx sdk.Context) error { + // Add new params and set all to defaults + defaultParams := types.DefaultParams() + m.keeper.SetParams(ctx, defaultParams) + return nil +} + func (m Migrator) SetMetadata(denomMetadata *banktypes.Metadata) { if len(denomMetadata.Base) == 0 { panic(fmt.Errorf("no base exists for denom %v", denomMetadata)) diff --git a/x/tokenfactory/keeper/migrations_test.go b/x/tokenfactory/keeper/migrations_test.go index e0db6d88b0..14ac521f6e 100644 --- a/x/tokenfactory/keeper/migrations_test.go +++ b/x/tokenfactory/keeper/migrations_test.go @@ -59,7 +59,7 @@ func TestMigrate2to3(t *testing.T) { store.Set(oldCreatorSpecificPrefix, []byte("garbage value whitelist creator")) require.True(t, store.Has(oldCreateDenomFeeWhitelistPrefix)) require.True(t, store.Has(oldCreatorSpecificPrefix)) - newKeeper := NewKeeper(cdc, storeKey, paramsSubspace, nil, bankkeeper.NewBaseKeeper(cdc, bankstorekey, nil, paramsSubspace, nil), nil, Config{DenomAllowListMaxSize: 100}) + newKeeper := NewKeeper(cdc, storeKey, paramsSubspace, nil, bankkeeper.NewBaseKeeper(cdc, bankstorekey, nil, paramsSubspace, nil), nil) m := NewMigrator(newKeeper) err := m.Migrate2to3(ctx) require.Nil(t, err) @@ -80,7 +80,7 @@ func TestMigrate2to3(t *testing.T) { func TestMigrate3To4(t *testing.T) { // Test migration with all metadata denom metadata := banktypes.Metadata{Description: sdk.DefaultBondDenom, Base: sdk.DefaultBondDenom, Display: sdk.DefaultBondDenom, Name: sdk.DefaultBondDenom, Symbol: sdk.DefaultBondDenom} - keeper := NewKeeper(nil, nil, typesparams.Subspace{}, nil, nil, nil, Config{DenomAllowListMaxSize: 100}) + _, keeper := getStoreAndKeeper(t) m := NewMigrator(keeper) m.SetMetadata(&metadata) require.Equal(t, sdk.DefaultBondDenom, metadata.Display) @@ -94,3 +94,38 @@ func TestMigrate3To4(t *testing.T) { require.Equal(t, testDenom, metadata.Name) require.Equal(t, testDenom, metadata.Symbol) } + +func TestMigrate4To5(t *testing.T) { + stateStore, keeper := getStoreAndKeeper(t) + m := NewMigrator(keeper) + ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger()) + err := m.Migrate4to5(ctx) + require.NoError(t, err) + require.NotPanics(t, func() { m.keeper.GetParams(ctx) }) + params := m.keeper.GetParams(ctx) + require.Equal(t, types.DefaultParams(), params) +} + +func getStoreAndKeeper(t *testing.T) (store.CommitMultiStore, Keeper) { + storeKey := sdk.NewKVStoreKey(types.StoreKey) + bankStoreKey := sdk.NewKVStoreKey(banktypes.StoreKey) + memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey) + + db := tmdb.NewMemDB() + stateStore := store.NewCommitMultiStore(db) + stateStore.MountStoreWithDB(storeKey, sdk.StoreTypeIAVL, db) + stateStore.MountStoreWithDB(bankStoreKey, sdk.StoreTypeIAVL, db) + stateStore.MountStoreWithDB(memStoreKey, sdk.StoreTypeMemory, nil) + require.NoError(t, stateStore.LoadLatestVersion()) + + registry := codectypes.NewInterfaceRegistry() + cdc := codec.NewProtoCodec(registry) + + paramsSubspace := typesparams.NewSubspace(cdc, + codec.NewLegacyAmino(), + storeKey, + memStoreKey, + "TokenfactoryParams", + ) + return stateStore, NewKeeper(nil, nil, paramsSubspace, nil, nil, nil) +} diff --git a/x/tokenfactory/keeper/msg_server.go b/x/tokenfactory/keeper/msg_server.go index e9b347ef19..ecb6d658fd 100644 --- a/x/tokenfactory/keeper/msg_server.go +++ b/x/tokenfactory/keeper/msg_server.go @@ -35,7 +35,7 @@ func (server msgServer) CreateDenom(goCtx context.Context, msg *types.MsgCreateD ) if msg.AllowList != nil { - err = server.validateAllowList(msg.AllowList) + err = server.validateAllowList(ctx, msg.AllowList) if err != nil { return nil, err } diff --git a/x/tokenfactory/module.go b/x/tokenfactory/module.go index c9279e187f..af5e0bebc0 100644 --- a/x/tokenfactory/module.go +++ b/x/tokenfactory/module.go @@ -149,6 +149,7 @@ func (am AppModule) RegisterServices(cfg module.Configurator) { _ = cfg.RegisterMigration(types.ModuleName, 1, func(ctx sdk.Context) error { return nil }) _ = cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3) _ = cfg.RegisterMigration(types.ModuleName, 3, m.Migrate3to4) + _ = cfg.RegisterMigration(types.ModuleName, 4, m.Migrate4to5) } // RegisterInvariants registers the x/tokenfactory module's invariants. @@ -194,7 +195,7 @@ func (am AppModuleBasic) ValidateGenesisStream(cdc codec.JSONCodec, config clien } // ConsensusVersion implements ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 4 } +func (AppModule) ConsensusVersion() uint64 { return 5 } // BeginBlock executes all ABCI BeginBlock logic respective to the tokenfactory module. func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} diff --git a/x/tokenfactory/types/keys.go b/x/tokenfactory/types/keys.go index 8fc6214de5..269cc875c2 100644 --- a/x/tokenfactory/types/keys.go +++ b/x/tokenfactory/types/keys.go @@ -30,6 +30,7 @@ var ( CreatorPrefixKey = "creator" AdminPrefixKey = "admin" CreateDenomFeeWhitelistKey = "createdenomfeewhitelist" + DenomAllowListMaxSizeKey = []byte("allowlistmaxsize") ) // GetDenomPrefixStore returns the store prefix where all the data associated with a specific denom diff --git a/x/tokenfactory/types/params.go b/x/tokenfactory/types/params.go index 52c8ce5c7f..544a837c49 100644 --- a/x/tokenfactory/types/params.go +++ b/x/tokenfactory/types/params.go @@ -1,25 +1,46 @@ package types import ( + "fmt" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) -// ParamTable for tokenfactory module. +// DefaultDenomAllowListMaxSize default denom allowlist max size and can be overridden by governance proposal. +const DefaultDenomAllowListMaxSize = 2000 + +// ParamKeyTable ParamTable for tokenfactory module. func ParamKeyTable() paramtypes.KeyTable { return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) } -// default tokenfactory module parameters. +// DefaultParams default tokenfactory module parameters. func DefaultParams() Params { - return Params{} + return Params{ + DenomAllowlistMaxSize: DefaultDenomAllowListMaxSize, + } } -// validate params. +// Validate validate params. func (p Params) Validate() error { + if err := validateDenomAllowListMaxSize(p.DenomAllowlistMaxSize); err != nil { + return err + } return nil } -// Implements params.ParamSet. +// ParamSetPairs Implements params.ParamSet. func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { - return paramtypes.ParamSetPairs{} + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(DenomAllowListMaxSizeKey, &p.DenomAllowlistMaxSize, validateDenomAllowListMaxSize), + } +} + +// validateDenomAllowListMaxSize validates a parameter value is within a valid range. +func validateDenomAllowListMaxSize(i interface{}) error { + _, ok := i.(uint32) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + return nil } diff --git a/x/tokenfactory/types/params.pb.go b/x/tokenfactory/types/params.pb.go index 74d3c5280a..5061f269fa 100644 --- a/x/tokenfactory/types/params.pb.go +++ b/x/tokenfactory/types/params.pb.go @@ -24,6 +24,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the tokenfactory module. type Params struct { + DenomAllowlistMaxSize uint32 `protobuf:"varint,1,opt,name=denom_allowlist_max_size,json=denomAllowlistMaxSize,proto3" json:"denom_allowlist_max_size,omitempty"` } func (m *Params) Reset() { *m = Params{} } @@ -59,6 +60,13 @@ func (m *Params) XXX_DiscardUnknown() { var xxx_messageInfo_Params proto.InternalMessageInfo +func (m *Params) GetDenomAllowlistMaxSize() uint32 { + if m != nil { + return m.DenomAllowlistMaxSize + } + return 0 +} + func init() { proto.RegisterType((*Params)(nil), "seiprotocol.seichain.tokenfactory.Params") } @@ -66,16 +74,19 @@ func init() { func init() { proto.RegisterFile("tokenfactory/params.proto", fileDescriptor_0f39a375875b281a) } var fileDescriptor_0f39a375875b281a = []byte{ - // 146 bytes of a gzipped FileDescriptorProto + // 194 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0xc9, 0xcf, 0x4e, 0xcd, 0x4b, 0x4b, 0x4c, 0x2e, 0xc9, 0x2f, 0xaa, 0xd4, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x2c, 0x4e, 0xcd, 0x04, 0xb3, 0x92, 0xf3, 0x73, 0xf4, - 0x8a, 0x53, 0x33, 0x93, 0x33, 0x12, 0x33, 0xf3, 0xf4, 0x90, 0xd5, 0x2b, 0x71, 0x70, 0xb1, 0x05, - 0x80, 0xb5, 0x38, 0x05, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, - 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x59, - 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x71, 0x6a, 0xa6, 0x2e, 0xcc, - 0x48, 0x30, 0x07, 0x6c, 0xa6, 0x7e, 0x85, 0x3e, 0x8a, 0x2b, 0x4a, 0x2a, 0x0b, 0x52, 0x8b, 0x93, - 0xd8, 0xc0, 0x0a, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x32, 0xb1, 0x98, 0xb4, 0xa2, 0x00, + 0x8a, 0x53, 0x33, 0x93, 0x33, 0x12, 0x33, 0xf3, 0xf4, 0x90, 0xd5, 0x2b, 0x39, 0x72, 0xb1, 0x05, + 0x80, 0xb5, 0x08, 0x99, 0x73, 0x49, 0xa4, 0xa4, 0xe6, 0xe5, 0xe7, 0xc6, 0x27, 0xe6, 0xe4, 0xe4, + 0x97, 0xe7, 0x64, 0x16, 0x97, 0xc4, 0xe7, 0x26, 0x56, 0xc4, 0x17, 0x67, 0x56, 0xa5, 0x4a, 0x30, + 0x2a, 0x30, 0x6a, 0xf0, 0x06, 0x89, 0x82, 0xe5, 0x1d, 0x61, 0xd2, 0xbe, 0x89, 0x15, 0xc1, 0x99, + 0x55, 0xa9, 0x4e, 0x01, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, + 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0x65, 0x96, + 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x5f, 0x9c, 0x9a, 0xa9, 0x0b, 0x73, + 0x0b, 0x98, 0x03, 0x76, 0x8c, 0x7e, 0x85, 0x3e, 0x8a, 0xf3, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, + 0xd8, 0xc0, 0x0a, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x4a, 0x3c, 0xf9, 0xdb, 0x00, 0x00, 0x00, } @@ -99,6 +110,11 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.DenomAllowlistMaxSize != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.DenomAllowlistMaxSize)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -119,6 +135,9 @@ func (m *Params) Size() (n int) { } var l int _ = l + if m.DenomAllowlistMaxSize != 0 { + n += 1 + sovParams(uint64(m.DenomAllowlistMaxSize)) + } return n } @@ -157,6 +176,25 @@ func (m *Params) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DenomAllowlistMaxSize", wireType) + } + m.DenomAllowlistMaxSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DenomAllowlistMaxSize |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipParams(dAtA[iNdEx:]) diff --git a/x/tokenfactory/types/params_test.go b/x/tokenfactory/types/params_test.go new file mode 100644 index 0000000000..b0c32db5c5 --- /dev/null +++ b/x/tokenfactory/types/params_test.go @@ -0,0 +1,154 @@ +package types + +import ( + "bytes" + "github.com/cosmos/cosmos-sdk/x/params/types" + "reflect" + "testing" +) + +func TestDefaultParams(t *testing.T) { + tests := []struct { + name string + want Params + }{ + { + name: "default params", + want: Params{ + DenomAllowlistMaxSize: 2000, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := DefaultParams(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("DefaultParams() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestParams_Validate(t *testing.T) { + type fields struct { + DenomAllowlistMaxSize uint32 + } + tests := []struct { + name string + fields fields + wantErr bool + errMsg string + }{ + { + name: "valid params", + fields: fields{ + DenomAllowlistMaxSize: 2000, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + p := Params{ + DenomAllowlistMaxSize: tt.fields.DenomAllowlistMaxSize, + } + err := p.Validate() + if (err != nil) != tt.wantErr { + t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr) + } + if err != nil && err.Error() != tt.errMsg { + t.Errorf("Validate() error message = %v, want %v", err.Error(), tt.errMsg) + } + }) + } +} + +func Test_validateDenomAllowListMaxSize(t *testing.T) { + type args struct { + i interface{} + } + tests := []struct { + name string + args args + wantErr bool + errMsg string + }{ + { + name: "valid denom allowlist max size", + args: args{ + i: uint32(2000), + }, + wantErr: false, + }, + { + name: "invalid denom allowlist max size", + args: args{ + i: int32(-1), + }, + wantErr: true, + errMsg: "invalid parameter type: int32", + }, + { + name: "invalid denom allowlist large int value", + args: args{ + i: 20000000000000, + }, + wantErr: true, + errMsg: "invalid parameter type: int", + }, + { + name: "invalid denom allowlist max size type", + args: args{ + i: "2000", + }, + wantErr: true, + errMsg: "invalid parameter type: string", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := validateDenomAllowListMaxSize(tt.args.i) + if (err != nil) != tt.wantErr { + t.Errorf("validateDenomAllowListMaxSize() error = %v, wantErr %v", err, tt.wantErr) + } + if err != nil && err.Error() != tt.errMsg { + t.Errorf("validateDenomAllowListMaxSize() error message = %v, want %v", err.Error(), tt.errMsg) + } + }) + } +} + +func TestParams_ParamSetPairs(t *testing.T) { + type fields struct { + DenomAllowlistMaxSize uint32 + } + allowListSize := uint32(20) + params := &Params{DenomAllowlistMaxSize: allowListSize} + tests := []struct { + name string + fields fields + want types.ParamSetPairs + }{ + { + name: "valid param set pairs", + fields: fields{ + DenomAllowlistMaxSize: allowListSize, + }, + want: types.ParamSetPairs{ + types.NewParamSetPair([]byte("allowlistmaxsize"), + ¶ms.DenomAllowlistMaxSize, + validateDenomAllowListMaxSize), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + p := params + got := p.ParamSetPairs() + if len(got) != len(tt.want) || !bytes.Equal(got[0].Key, tt.want[0].Key) || + got[0].Value != tt.want[0].Value || + reflect.ValueOf(got[0].ValidatorFn).Pointer() != reflect.ValueOf(tt.want[0].ValidatorFn).Pointer() { + t.Errorf("ParamSetPairs() = %v, want %v", got, tt.want) + } + }) + } +}