update denom tests

app/test_helpers.go

@@ -15,6 +15,7 @@ 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"
@@ -55,6 +56,9 @@ func (t TestAppOpts) Get(s string) interface{} {
 	if s == FlagSCEnable {
 		return t.useSc
 	}
+	if s == tokenfactorykeeper.FlagDenomAllowListMaxSize {
+		return 3
+	}
 	return nil
 }
 

x/tokenfactory/client/cli/tx.go

@@ -136,7 +136,7 @@ func NewUpdateDenomCmd() *cobra.Command {
 			msg := types.NewMsgUpdateDenom(
 				clientCtx.GetFromAddress().String(),
 				args[0],
-				allowList,
+				&allowList,
 			)
 
 			return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)

x/tokenfactory/keeper/config.go

@@ -14,13 +14,13 @@ var DefaultConfig = Config{
 }
 
 const (
-	flagDenomAllowListMaxSize = "tokenfactory.denom_allow_list_max_size"
+	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 v := opts.Get(FlagDenomAllowListMaxSize); v != nil {
 		if cfg.DenomAllowListMaxSize, err = cast.ToIntE(v); err != nil {
 			return cfg, err
 		}

x/tokenfactory/keeper/createdenom.go

@@ -89,6 +89,10 @@ func (k Keeper) validateUpdateDenom(ctx sdk.Context, msg *types.MsgUpdateDenom)
 }
 
 func (k Keeper) validateAllowListSize(allowList *banktypes.AllowList) error {
+	if allowList == nil {
+		return types.ErrAllowListUndefined
+	}
+
 	if len(allowList.Addresses) > k.config.DenomAllowListMaxSize {
 		return types.ErrAllowListTooLarge
 	}

x/tokenfactory/keeper/createdenom_test.go

@@ -86,7 +86,7 @@ func (suite *KeeperTestSuite) TestCreateDenom() {
 			desc:     "valid allow list",
 			subdenom: "withallowlist",
 			allowList: &banktypes.AllowList{
-				Addresses: []string{suite.TestAccs[0].String(), suite.TestAccs[1].String()},
+				Addresses: []string{suite.TestAccs[0].String(), suite.TestAccs[1].String(), suite.TestAccs[2].String()},
 			},
 			valid: true,
 		},
@@ -98,6 +98,18 @@ 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,
+		},
 	} {
 		suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
 			if tc.setup != nil {
@@ -136,10 +148,150 @@ func (suite *KeeperTestSuite) TestCreateDenom() {
 						Denom: res.GetNewTokenDenom(),
 					})
 					suite.Require().NoError(err)
-					suite.Require().Equal(tc.allowList, allowListRes.AllowList)
+					suite.Require().Equal(tc.allowList, &allowListRes.AllowList)
+				}
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestUpdateDenom() {
+	for _, tc := range []struct {
+		desc      string
+		setup     func()
+		sender    string
+		subdenom  string
+		allowList *banktypes.AllowList // Ensure this is the correct type for your allow list
+		valid     bool
+		errMsg    string
+	}{
+		{
+			desc:     "subdenom too long",
+			subdenom: "assadsadsadasdasdsadsadsadsadsadsadsklkadaskkkdasdasedskhanhassyeunganassfnlksdflksafjlkasd",
+			valid:    false,
+			errMsg:   "subdenom too long, max length is 44 bytes",
+		},
+		{
+			desc:     "denom does not exist",
+			subdenom: "nonexistent",
+			valid:    false,
+			errMsg: fmt.Sprintf("denom: factory/%s/nonexistent: denom does not exist",
+				suite.TestAccs[0].String()),
+		},
+		{
+			desc: "denom allow list can be updated",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx),
+					types.NewMsgCreateDenom(suite.TestAccs[0].String(), "UPD"))
+				suite.Require().NoError(err)
+			},
+			subdenom: "UPD",
+			allowList: &banktypes.AllowList{
+				Addresses: []string{suite.TestAccs[0].String(), suite.TestAccs[1].String()},
+			},
+			valid: true,
+		},
+		{
+			desc: "denom allow list can be updated with empty list",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx),
+					types.NewMsgCreateDenom(suite.TestAccs[0].String(), "EMPT"))
+				suite.Require().NoError(err)
+			},
+			subdenom:  "EMPT",
+			allowList: &banktypes.AllowList{},
+			valid:     true,
+		},
+		{
+			desc: "error if allow list is undefined",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx),
+					types.NewMsgCreateDenom(suite.TestAccs[0].String(), "UND"))
+				suite.Require().NoError(err)
+			},
+			subdenom:  "UND",
+			allowList: nil,
+			valid:     false,
+			errMsg:    "allowlist undefined",
+		},
+		{
+			desc: "error if allow list is too large",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx),
+					types.NewMsgCreateDenom(suite.TestAccs[0].String(), "TLRG"))
+				suite.Require().NoError(err)
+			},
+			subdenom: "TLRG",
+			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",
+		},
+		{
+			desc:     "subdenom having invalid characters",
+			subdenom: "bit/***///&&&/coin",
+			valid:    false,
+			errMsg:   fmt.Sprintf("invalid denom: factory/%s/bit/***///&&&/coin", suite.TestAccs[0].String()),
+		},
+		{
+			desc: "invalid allow list with invalid address",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "invalidallowlist"))
+				suite.Require().NoError(err)
+			},
+			subdenom: "invalidallowlist",
+			allowList: &banktypes.AllowList{
+				Addresses: []string{"invalid_address"},
+			},
+			valid:  false,
+			errMsg: "invalid address invalid_address: decoding bech32 failed: invalid separator index -1",
+		},
+		{
+			desc: "sender is not the admin",
+			setup: func() {
+				_, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "SND"))
+				suite.Require().NoError(err)
+			},
+			subdenom:  "SND",
+			sender:    suite.TestAccs[1].String(),
+			allowList: &banktypes.AllowList{},
+			valid:     false,
+			errMsg:    fmt.Sprintf("denom: factory/%s/SND: denom does not exist", suite.TestAccs[1].String()),
+		},
+	} {
+		suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+			if tc.setup != nil {
+				tc.setup()
+			}
+			if tc.sender == "" {
+				tc.sender = suite.TestAccs[0].String()
+			}
+			msg := types.NewMsgUpdateDenom(tc.sender, tc.subdenom, tc.allowList)
+
+			// Update a denom
+			_, err := suite.msgServer.UpdateDenom(sdk.WrapSDKContext(suite.Ctx), msg)
+			if tc.valid {
+				suite.Require().NoError(err)
+
+				// Verify the allow list if provided
+				if tc.allowList != nil {
+					allowListRes, err := suite.queryClient.DenomAllowList(suite.Ctx.Context(), &types.QueryDenomAllowListRequest{
+						Denom: fmt.Sprintf("factory/%s/%s", suite.TestAccs[0].String(), tc.subdenom),
+					})
+					suite.Require().NoError(err)
+					suite.Require().Equal(tc.allowList, &allowListRes.AllowList)
 				}
 			} else {
 				suite.Require().Error(err)
+				suite.Require().Equal(tc.errMsg, err.Error())
 			}
 		})
 	}

x/tokenfactory/types/errors.go

@@ -30,4 +30,5 @@ var (
 	ErrEncodingDenomsFromCreator      = sdkerrors.Register(ModuleName, 19, "Error encoding denoms from creator as JSON")
 	ErrUnknownSeiTokenFactoryQuery    = sdkerrors.Register(ModuleName, 23, "Error unknown sei token factory query")
 	ErrAllowListTooLarge              = sdkerrors.Register(ModuleName, 24, "allowlist too large")
+	ErrAllowListUndefined             = sdkerrors.Register(ModuleName, 25, "allowlist undefined")
 )

x/tokenfactory/types/msgs.go

@@ -54,11 +54,11 @@ func (m MsgCreateDenom) GetSigners() []sdk.AccAddress {
 var _ sdk.Msg = &MsgUpdateDenom{}
 
 // NewMsgUpdateDenom creates a msg to update denom
-func NewMsgUpdateDenom(sender, subdenom string, allowList banktypes.AllowList) *MsgUpdateDenom {
+func NewMsgUpdateDenom(sender, subdenom string, allowList *banktypes.AllowList) *MsgUpdateDenom {
 	return &MsgUpdateDenom{
 		Sender:    sender,
 		Subdenom:  subdenom,
-		AllowList: &allowList,
+		AllowList: allowList,
 	}
 }