wormchain: address comments on wormchain allowlisting

wormchain/README.md

@@ -31,3 +31,13 @@ See [development.md](./development.md)
 - [Cosmos SDK documentation](https://docs.cosmos.network)
 - [Cosmos SDK Tutorials](https://tutorials.cosmos.network)
 - [Discord](https://discord.gg/cosmosnetwork)
+
+## Allowlists
+
+Accounts on wormchain are allowlisted.  To be able to submit a tx on wormchain, you must have an account that is either:
+* A validator on wormchain that is part of a current or future guardian set, or
+* An account that is allowlisted by a current validator on wormchain.
+
+To create or delete an allowlist entry, you use a validator account.  Allowlist entries can become stale,
+meaning the owning validators are no longer part of the validator set.  Any validator can delete or replace stale entries.
+To manage allowlists, use the `wormchaind` client.

wormchain/app/app.go

@@ -16,7 +16,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/server/config"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/x/auth"
@@ -554,7 +553,7 @@ func New(
 	app.SetInitChainer(app.InitChainer)
 	app.SetBeginBlocker(app.BeginBlocker)
 
-	anteHandler, err := NewAnteHandler(
+	anteHandlerSdk, err := ante.NewAnteHandler(
 		ante.HandlerOptions{
 			AccountKeeper:   app.AccountKeeper,
 			BankKeeper:      app.BankKeeper,
@@ -562,13 +561,13 @@ func New(
 			FeegrantKeeper:  app.FeeGrantKeeper,
 			SigGasConsumer:  ante.DefaultSigVerificationGasConsumer,
 		},
-		app.WormholeKeeper,
 	)
 	if err != nil {
 		panic(err)
 	}
+	wrappedAnteHandler := WrapAnteHandler(anteHandlerSdk, app.WormholeKeeper)
 
-	app.SetAnteHandler(anteHandler)
+	app.SetAnteHandler(wrappedAnteHandler)
 	app.SetEndBlocker(app.EndBlocker)
 
 	if loadLatest {
@@ -585,45 +584,18 @@ func New(
 	return app
 }
 
-// Copied from https://github.com/wormhole-foundation/cosmos-sdk/blob/main/x/auth/ante/ante.go#L25
+// Wrap the standard cosmos-sdk antehandlers with our wormhole allowlist antehandler.
-// I don't think there is currently a way to extend the list used in x/auth without copying it out.
+func WrapAnteHandler(originalHandler sdk.AnteHandler, wormKeeper wormholemodulekeeper.Keeper) sdk.AnteHandler {
-func NewAnteHandler(options ante.HandlerOptions, wormKeeper wormholemodulekeeper.Keeper) (sdk.AnteHandler, error) {
+	whHandler := wormholemoduleante.NewWormholeAllowlistDecorator(wormKeeper)
-	if options.AccountKeeper == nil {
+	return func(ctx sdk.Context, tx sdk.Tx, simulate bool) (sdk.Context, error) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder")
+		newCtx, err := originalHandler(ctx, tx, simulate)
+		if err != nil {
+			return newCtx, err
 		}
-
+		return whHandler.AnteHandle(ctx, tx, simulate, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (sdk.Context, error) {
-	if options.BankKeeper == nil {
+			return ctx, nil
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder")
+		})
 	}
-
-	if options.SignModeHandler == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder")
-	}
-
-	sigGasConsumer := options.SigGasConsumer
-	if sigGasConsumer == nil {
-		sigGasConsumer = ante.DefaultSigVerificationGasConsumer
-	}
-
-	anteDecorators := []sdk.AnteDecorator{
-		ante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
-		ante.NewRejectExtensionOptionsDecorator(),
-		ante.NewMempoolFeeDecorator(),
-		ante.NewValidateBasicDecorator(),
-		ante.NewTxTimeoutHeightDecorator(),
-		ante.NewValidateMemoDecorator(options.AccountKeeper),
-		ante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
-		ante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper),
-		ante.NewSetPubKeyDecorator(options.AccountKeeper), // SetPubKeyDecorator must be called before all signature verification decorators
-		ante.NewValidateSigCountDecorator(options.AccountKeeper),
-		ante.NewSigGasConsumeDecorator(options.AccountKeeper, sigGasConsumer),
-		ante.NewSigVerificationDecorator(options.AccountKeeper, options.SignModeHandler),
-		ante.NewIncrementSequenceDecorator(options.AccountKeeper),
-		// our ante handler
-		wormholemoduleante.NewWormholeAllowlistDecorator(wormKeeper),
-	}
-
-	return sdk.ChainAnteDecorators(anteDecorators...), nil
 }
 
 // Name returns the name of the App

wormchain/proto/wormhole/query.proto

@@ -85,7 +85,7 @@ message QueryAllValidatorAllowlist {
 
 // all allowlisted entries by all validators
 message QueryAllValidatorAllowlistResponse {
-	repeated ValidatorAllowedAddress allowed_address = 1;
+	repeated ValidatorAllowedAddress allowlist = 1;
 	cosmos.base.query.v1beta1.PageResponse pagination = 2;
 }
 
@@ -97,7 +97,7 @@ message QueryValidatorAllowlist {
 // all allowlisted entries by a specific validator
 message QueryValidatorAllowlistResponse {
 	string validator_address = 1;
-	repeated ValidatorAllowedAddress allowed_address = 2;
+	repeated ValidatorAllowedAddress allowlist = 2;
 	cosmos.base.query.v1beta1.PageResponse pagination = 3;
 }
 

wormchain/proto/wormhole/tx.proto

@@ -11,8 +11,8 @@ service Msg {
   rpc ExecuteGovernanceVAA(MsgExecuteGovernanceVAA) returns (MsgExecuteGovernanceVAAResponse);
   rpc RegisterAccountAsGuardian(MsgRegisterAccountAsGuardian) returns (MsgRegisterAccountAsGuardianResponse);
 
-  rpc CreateAllowlist(MsgCreateAllowlistRequest) returns (MsgAllowlistResponse);
+  rpc CreateAllowlistEntry(MsgCreateAllowlistEntryRequest) returns (MsgAllowlistResponse);
-  rpc DeleteAllowlist(MsgDeleteAllowlistRequest) returns (MsgAllowlistResponse);
+  rpc DeleteAllowlistEntry(MsgDeleteAllowlistEntryRequest) returns (MsgAllowlistResponse);
 
   // StoreCode to submit Wasm code to the system
   rpc StoreCode(MsgStoreCode) returns (MsgStoreCodeResponse);
@@ -22,7 +22,7 @@ service Msg {
 // this line is used by starport scaffolding # proto/tx/rpc
 }
 
-message MsgCreateAllowlistRequest {
+message MsgCreateAllowlistEntryRequest {
   // signer should be a guardian validator in a current set or future set.
   string signer = 1;
   // the address to allowlist
@@ -31,7 +31,7 @@ message MsgCreateAllowlistRequest {
   string name = 3;
 }
 
-message MsgDeleteAllowlistRequest {
+message MsgDeleteAllowlistEntryRequest {
   // signer should be a guardian validator in a current set or future set.
   string signer = 1;
   // the address allowlist to remove

wormchain/testutil/keeper/wormhole.go

@@ -116,6 +116,8 @@ func WormholeKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 	)
 	ctx := sdk.NewContext(stateStore, tmproto.Header{
 		Time: time.Now(),
+		// The height should be at least 1, because the allowlist antehandler
+		// passes everything at height 0 for gen tx's.
 		Height: 1,
 	}, false, log.NewNopLogger())
 	appapp.MountKVStores(keys)

wormchain/x/wormhole/ante/ante.go

@@ -26,43 +26,32 @@ func (wh WormholeAllowlistDecorator) AnteHandle(request sdk.Request, tx sdk.Tx,
 		return next(request, tx, simulate)
 	}
 
-	verified_addresses := make(map[string]bool)
+	// We permit if there is a message with a signer satisfying either condition:
-
-	// For every message we should check:
 	// 1. There is an allowlist entry for the signer(s), OR
-	// 2. The signer(s) are validators in current or future guardian set.
+	// 2. The signer is a validators in a current or future guardian set.
-	// We cache the result for performance, since this is a ante handler that runs for everything.
+	// I.e. If one message has an allowed signer, then the transaction has a signature from that address.
 	for _, msg := range tx.GetMsgs() {
 		for _, signer := range msg.GetSigners() {
 			addr := signer.String()
-			// check for an address we may have already verified
-			if ok := verified_addresses[addr]; ok {
-				// ok
-				continue
-			}
 			// check for an allowlist
 			if wh.k.HasValidatorAllowedAddress(request, addr) {
 				allowed_entry := wh.k.GetValidatorAllowedAddress(request, addr)
 				// authenticate that the validator that made the allowlist is still valid
 				if wh.k.IsAddressValidatorOrFutureValidator(request, allowed_entry.ValidatorAddress) {
 					// ok
-					verified_addresses[addr] = true
+					return next(request, tx, simulate)
-					continue
 				}
 			}
 
 			// if allowlist did not pass, check if signer is a current or future validator
 			if wh.k.IsAddressValidatorOrFutureValidator(request, addr) {
 				// ok
-				verified_addresses[addr] = true
-				continue
-			}
-
-			// by this point, this signer is not allowlisted or a valid validator.
-			// not authorized!
-			return request, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "signer must be current validator or allowlisted by current validator")
-		}
-	}
-
 				return next(request, tx, simulate)
+			}
+		}
+	}
+
+	// By this point, there is no signer that is not allowlisted or is a validator.
+	// Not authorized!
+	return request, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "signer must be current validator or allowlisted by current validator")
 }

wormchain/x/wormhole/client/cli/tx_allowlist.go

@@ -27,7 +27,7 @@ func CmdCreateAllowedAddress() *cobra.Command {
 			address := args[0]
 			name := args[1]
 
-			msg := types.MsgCreateAllowlistRequest{
+			msg := types.MsgCreateAllowlistEntryRequest{
 				Signer:  clientCtx.GetFromAddress().String(),
 				Address: address,
 				Name:    name,
@@ -48,7 +48,7 @@ func CmdCreateAllowedAddress() *cobra.Command {
 func CmdDeleteAllowedAddress() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "delete-allowed-address [wormchain-address]",
-		Short:   "Remove an allowlist. The allowlist must be stale (only valid under old guardian set) or you must be the creator of the allowlist.",
+		Short:   "Remove an allowlist entry. The allowlist must be stale (only valid under old guardian set) or you must be the creator of the allowlist.",
 		Aliases: []string{"delete-allowlist", "remove-allowlist", "disallow"},
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -58,7 +58,7 @@ func CmdDeleteAllowedAddress() *cobra.Command {
 			}
 			address := args[0]
 
-			msg := types.MsgDeleteAllowlistRequest{
+			msg := types.MsgDeleteAllowlistEntryRequest{
 				Signer:  clientCtx.GetFromAddress().String(),
 				Address: address,
 			}

wormchain/x/wormhole/handler.go

@@ -29,11 +29,11 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgInstantiateContract:
 			res, err := msgServer.InstantiateContract(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-		case *types.MsgCreateAllowlistRequest:
+		case *types.MsgCreateAllowlistEntryRequest:
-			res, err := msgServer.CreateAllowlist(sdk.WrapSDKContext(ctx), msg)
+			res, err := msgServer.CreateAllowlistEntry(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-		case *types.MsgDeleteAllowlistRequest:
+		case *types.MsgDeleteAllowlistEntryRequest:
-			res, err := msgServer.DeleteAllowlist(sdk.WrapSDKContext(ctx), msg)
+			res, err := msgServer.DeleteAllowlistEntry(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
 			// this line is used by starport scaffolding # 1
 		default:

wormchain/x/wormhole/keeper/allowlist.go

@@ -54,21 +54,8 @@ func (k Keeper) GetAllAllowedAddresses(ctx sdk.Context) (list []types.ValidatorA
 // * Is in a future guardian set
 func (k Keeper) IsAddressValidatorOrFutureValidator(ctx sdk.Context, addr string) bool {
 	currentIndex, _ := k.GetConsensusGuardianSetIndex(ctx)
-	validators := k.GetAllGuardianValidator(ctx)
+	matchedValidator, found := k.GetGuardianValidatorByValidatorAddress(ctx, addr)
-	addrBz, err := sdk.AccAddressFromBech32(addr)
+	if !found {
-	var matchedValidator *types.GuardianValidator = nil
-	if err != nil {
-		return false
-	}
-	// look up the guardian validator
-	for _, val := range validators {
-		if bytes.Equal(val.ValidatorAddr, addrBz) {
-			matchedValidator = &val
-			break
-		}
-	}
-	// if no match, no match
-	if matchedValidator == nil {
 		return false
 	}
 	// check that the validator is in a current or future guardian set
@@ -84,3 +71,17 @@ func (k Keeper) IsAddressValidatorOrFutureValidator(ctx sdk.Context, addr string
 	}
 	return false
 }
+
+func (k Keeper) GetGuardianValidatorByValidatorAddress(ctx sdk.Context, addr string) (validator types.GuardianValidator, found bool) {
+	addrBz, err := sdk.AccAddressFromBech32(addr)
+	if err != nil {
+		return
+	}
+	validators := k.GetAllGuardianValidator(ctx)
+	for _, val := range validators {
+		if bytes.Equal(val.ValidatorAddr, addrBz) {
+			return val, true
+		}
+	}
+	return
+}

wormchain/x/wormhole/keeper/grpc_query_allowlist.go

@@ -20,9 +20,9 @@ func (k Keeper) AllowlistAll(c context.Context, req *types.QueryAllValidatorAllo
 	ctx := sdk.UnwrapSDKContext(c)
 
 	store := ctx.KVStore(k.storeKey)
-	sequenceCounterStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
+	allowedStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
 
-	pageRes, err := query.Paginate(sequenceCounterStore, req.Pagination, func(key []byte, value []byte) error {
+	pageRes, err := query.Paginate(allowedStore, req.Pagination, func(key []byte, value []byte) error {
 		var allowedAddress types.ValidatorAllowedAddress
 		if err := k.cdc.Unmarshal(value, &allowedAddress); err != nil {
 			return err
@@ -36,7 +36,7 @@ func (k Keeper) AllowlistAll(c context.Context, req *types.QueryAllValidatorAllo
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryAllValidatorAllowlistResponse{AllowedAddress: allowedAddresses, Pagination: pageRes}, nil
+	return &types.QueryAllValidatorAllowlistResponse{Allowlist: allowedAddresses, Pagination: pageRes}, nil
 }
 
 func (k Keeper) Allowlist(c context.Context, req *types.QueryValidatorAllowlist) (*types.QueryValidatorAllowlistResponse, error) {
@@ -44,29 +44,15 @@ func (k Keeper) Allowlist(c context.Context, req *types.QueryValidatorAllowlist)
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
 
-	var allowedAddresses []*types.ValidatorAllowedAddress
 	ctx := sdk.UnwrapSDKContext(c)
 
-	store := ctx.KVStore(k.storeKey)
+	allowedAddresses := k.GetAllAllowedAddresses(ctx)
-	sequenceCounterStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
+	allowlist := []*types.ValidatorAllowedAddress{}
-
+	for _, allowed := range allowedAddresses {
-	pageRes, err := query.Paginate(sequenceCounterStore, req.Pagination, func(key []byte, value []byte) error {
+		if allowed.ValidatorAddress == req.ValidatorAddress {
-		var allowedAddress types.ValidatorAllowedAddress
+			allowlist = append(allowlist, &allowed)
-		if err := k.cdc.Unmarshal(value, &allowedAddress); err != nil {
-			return err
 		}
-		// this will cause a less then expected amount to be returned in the pagination,
-		// but the alternative is to rework how pagination works, which is complex.
-		// this lists are not expected to be long anyways and won't need pagination.
-		if allowedAddress.ValidatorAddress == req.ValidatorAddress {
-			allowedAddresses = append(allowedAddresses, &allowedAddress)
-		}
-		return nil
-	})
-
-	if err != nil {
-		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryValidatorAllowlistResponse{AllowedAddress: allowedAddresses, Pagination: pageRes, ValidatorAddress: req.ValidatorAddress}, nil
+	return &types.QueryValidatorAllowlistResponse{Allowlist: allowlist, ValidatorAddress: req.ValidatorAddress}, nil
 }

wormchain/x/wormhole/keeper/msg_server_allowlist.go

@@ -8,7 +8,7 @@ import (
 	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
 )
 
-func (k msgServer) CreateAllowlist(goCtx context.Context, msg *types.MsgCreateAllowlistRequest) (*types.MsgAllowlistResponse, error) {
+func (k msgServer) CreateAllowlistEntry(goCtx context.Context, msg *types.MsgCreateAllowlistEntryRequest) (*types.MsgAllowlistResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	validator_address := msg.Signer
 	if !k.IsAddressValidatorOrFutureValidator(ctx, validator_address) {
@@ -32,7 +32,7 @@ func (k msgServer) CreateAllowlist(goCtx context.Context, msg *types.MsgCreateAl
 	return &types.MsgAllowlistResponse{}, nil
 }
 
-func (k msgServer) DeleteAllowlist(goCtx context.Context, msg *types.MsgDeleteAllowlistRequest) (*types.MsgAllowlistResponse, error) {
+func (k msgServer) DeleteAllowlistEntry(goCtx context.Context, msg *types.MsgDeleteAllowlistEntryRequest) (*types.MsgAllowlistResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	validator_address := msg.Signer
 	if !k.IsAddressValidatorOrFutureValidator(ctx, validator_address) {

wormchain/x/wormhole/keeper/msg_server_allowlist_test.go

@@ -58,7 +58,7 @@ func getRandomAddress() string {
 	return sdk.AccAddress(validatorAddr[:]).String()
 }
 
-func TestAllowlist(t *testing.T) {
+func TestAllowlistEntry(t *testing.T) {
 	k, ctx := keepertest.WormholeKeeper(t)
 	guardians, _ := createNGuardianValidator(k, ctx, 10)
 	k.SetConfig(ctx, types.Config{
@@ -76,89 +76,107 @@ func TestAllowlist(t *testing.T) {
 	context := sdk.WrapSDKContext(ctx)
 	msgServer := keeper.NewMsgServerImpl(*k)
 
-	// Test creating allowlist works using a validator
+	// Test creating AllowlistEntry works using a validator
-	new_address := getRandomAddress()
+	new_addresses := []string{
-	_, err := msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+		getRandomAddress(),
+		getRandomAddress(),
+		getRandomAddress(),
+	}
+	for _, addr := range new_addresses {
+		_, err := msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 			Signer:  getSigner(&guardians[0]),
-		Address: new_address,
+			Address: addr,
 		})
 		assert.NoError(t, err)
+	}
 	// Test creating the same address again is rejected
 	for _, g := range guardians {
-		_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+		for _, addr := range new_addresses {
+
+			_, err := msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 				Signer:  getSigner(&g),
-			Address: new_address,
+				Address: addr,
 			})
 			assert.Error(t, err)
 		}
+	}
 
 	// Test address can be Deleted
-	_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
+	_, err := msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
-		Address: new_address,
+		Address: new_addresses[0],
 	})
 	assert.NoError(t, err)
 	// Can't be deleted again since it doesn't exist
-	_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
+	_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
-		Address: new_address,
+		Address: new_addresses[0],
 	})
 	assert.Error(t, err)
 	// Can be added again
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
-		Address: new_address,
+		Address: new_addresses[0],
 	})
 	assert.NoError(t, err)
 
-	// another guardian cannot delete an allowlist they did not create
+	// another guardian cannot delete an AllowlistEntry they did not create
 	for _, g := range guardians[1:] {
-		_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
+		_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
 			Signer:  getSigner(&g),
-			Address: new_address,
+			Address: new_addresses[0],
 		})
 		assert.Error(t, err)
 	}
 
-	// Cannot make allowlist if not a validator
+	// Cannot make AllowlistEntry if not a validator
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getRandomAddress(),
 		Address: getRandomAddress(),
 	})
 	assert.Error(t, err)
 
-	// Cannot make allowlist if the guardian set changes
+	// Cannot make AllowlistEntry if the guardian set changes
 	oldGuardian := guardians[0]
 	guardians, _ = createNGuardianValidator(k, ctx, 10)
 	createNewGuardianSet(k, ctx, guardians)
 	err = k.TrySwitchToNewConsensusGuardianSet(ctx)
 	assert.NoError(t, err)
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getSigner(&oldGuardian),
 		Address: getRandomAddress(),
 	})
 	assert.Error(t, err)
 
 	// still works with new guardian set
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
 		Address: getRandomAddress(),
 	})
 	assert.NoError(t, err)
 
-	// Anyone can remove stale allowlists
+	// Anyone can remove stale AllowlistEntrys
 	// (new_address list is now stale as it's validator is no longer in validator set)
-	_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
+	_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[9]),
-		Address: new_address,
+		Address: new_addresses[0],
 	})
 	assert.NoError(t, err)
 
+	// stale addresses will get overwritten by new validator
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
+		Signer:  getSigner(&guardians[0]),
+		Address: new_addresses[1],
+	})
+	assert.NoError(t, err)
+	allowed := k.GetValidatorAllowedAddress(ctx, new_addresses[1])
+	assert.Equal(t, allowed.ValidatorAddress, getSigner(&guardians[0]))
+
 	_ = msgServer
 	_ = context
 }
 
-func TestAllowlistAnteHandler(t *testing.T) {
+func TestAllowlistEntryAnteHandler(t *testing.T) {
 	k, ctx := keepertest.WormholeKeeper(t)
 	guardians, privateKeys := createNGuardianValidator(k, ctx, 10)
 	_ = privateKeys
@@ -198,7 +216,7 @@ func TestAllowlistAnteHandler(t *testing.T) {
 	assert.Error(t, err)
 
 	// Test ante handler accepts new address when whitelisted
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
 		Address: new_address,
 	})
@@ -206,8 +224,8 @@ func TestAllowlistAnteHandler(t *testing.T) {
 	_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
 	assert.NoError(t, err)
 
-	// Test ante handler rejects when allowlist is removed
+	// Test ante handler rejects when AllowlistEntry is removed
-	_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
+	_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
 		Address: new_address,
 	})
@@ -216,8 +234,8 @@ func TestAllowlistAnteHandler(t *testing.T) {
 	_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
 	assert.Error(t, err)
 
-	// (add back the allowlist)
+	// (add back the AllowlistEntry)
-	_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
+	_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
 		Signer:  getSigner(&guardians[0]),
 		Address: new_address,
 	})
@@ -225,17 +243,6 @@ func TestAllowlistAnteHandler(t *testing.T) {
 	_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
 	assert.NoError(t, err)
 
-	// test that the ante handler rejects when a 2nd not-allowed msg is snuck in >:)
-	_, err = anteHandler.AnteHandle(ctx, &MockTx{
-		Msgs: []sdk.Msg{
-			// good
-			getMsgWithSigner(new_address),
-			// bad
-			getMsgWithSigner(getRandomAddress()),
-		},
-	}, false, MockNext)
-	assert.Error(t, err)
-
 	// test ante handler rejects address that is no longer valid
 	// due to validator set advancing
 	// 1. new guardian set

wormchain/x/wormhole/types/codec.go

@@ -13,8 +13,8 @@ func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgRegisterAccountAsGuardian{}, "wormhole/RegisterAccountAsGuardian", nil)
 	cdc.RegisterConcrete(&MsgStoreCode{}, "wormhole/StoreCode", nil)
 	cdc.RegisterConcrete(&MsgInstantiateContract{}, "wormhole/InstantiateContract", nil)
-	cdc.RegisterConcrete(&MsgCreateAllowlistRequest{}, "wormhole/CreateAllowlistRequest", nil)
+	cdc.RegisterConcrete(&MsgCreateAllowlistEntryRequest{}, "wormhole/CreateAllowlistEntryRequest", nil)
-	cdc.RegisterConcrete(&MsgDeleteAllowlistRequest{}, "wormhole/DeleteAllowlistRequest", nil)
+	cdc.RegisterConcrete(&MsgDeleteAllowlistEntryRequest{}, "wormhole/DeleteAllowlistEntryRequest", nil)
 	// this line is used by starport scaffolding # 2
 }
 
@@ -23,8 +23,8 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 		&MsgExecuteGovernanceVAA{},
 		&MsgStoreCode{},
 		&MsgInstantiateContract{},
-		&MsgCreateAllowlistRequest{},
+		&MsgCreateAllowlistEntryRequest{},
-		&MsgDeleteAllowlistRequest{},
+		&MsgDeleteAllowlistEntryRequest{},
 	)
 	registry.RegisterImplementations((*gov.Content)(nil),
 		&GovernanceWormholeMessageProposal{},

wormchain/x/wormhole/types/message_allowlist.go

@@ -5,18 +5,18 @@ import (
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
-var _ sdk.Msg = &MsgCreateAllowlistRequest{}
+var _ sdk.Msg = &MsgCreateAllowlistEntryRequest{}
-var _ sdk.Msg = &MsgDeleteAllowlistRequest{}
+var _ sdk.Msg = &MsgDeleteAllowlistEntryRequest{}
 
-func (msg *MsgCreateAllowlistRequest) Route() string {
+func (msg *MsgCreateAllowlistEntryRequest) Route() string {
 	return RouterKey
 }
 
-func (msg *MsgCreateAllowlistRequest) Type() string {
+func (msg *MsgCreateAllowlistEntryRequest) Type() string {
-	return "CreateAllowlistRequest"
+	return "CreateAllowlistEntryRequest"
 }
 
-func (msg *MsgCreateAllowlistRequest) GetSigners() []sdk.AccAddress {
+func (msg *MsgCreateAllowlistEntryRequest) GetSigners() []sdk.AccAddress {
 	signer, err := sdk.AccAddressFromBech32(msg.Signer)
 	if err != nil {
 		panic(err)
@@ -24,12 +24,12 @@ func (msg *MsgCreateAllowlistRequest) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{signer}
 }
 
-func (msg *MsgCreateAllowlistRequest) GetSignBytes() []byte {
+func (msg *MsgCreateAllowlistEntryRequest) GetSignBytes() []byte {
 	bz := ModuleCdc.MustMarshalJSON(msg)
 	return sdk.MustSortJSON(bz)
 }
 
-func (msg *MsgCreateAllowlistRequest) ValidateBasic() error {
+func (msg *MsgCreateAllowlistEntryRequest) ValidateBasic() error {
 	_, err := sdk.AccAddressFromBech32(msg.Signer)
 	if err != nil {
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
@@ -43,15 +43,15 @@ func (msg *MsgCreateAllowlistRequest) ValidateBasic() error {
 	return nil
 }
 
-func (msg *MsgDeleteAllowlistRequest) Route() string {
+func (msg *MsgDeleteAllowlistEntryRequest) Route() string {
 	return RouterKey
 }
 
-func (msg *MsgDeleteAllowlistRequest) Type() string {
+func (msg *MsgDeleteAllowlistEntryRequest) Type() string {
-	return "DeleteAllowlistRequest"
+	return "DeleteAllowlistEntryRequest"
 }
 
-func (msg *MsgDeleteAllowlistRequest) GetSigners() []sdk.AccAddress {
+func (msg *MsgDeleteAllowlistEntryRequest) GetSigners() []sdk.AccAddress {
 	signer, err := sdk.AccAddressFromBech32(msg.Signer)
 	if err != nil {
 		panic(err)
@@ -59,15 +59,20 @@ func (msg *MsgDeleteAllowlistRequest) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{signer}
 }
 
-func (msg *MsgDeleteAllowlistRequest) GetSignBytes() []byte {
+func (msg *MsgDeleteAllowlistEntryRequest) GetSignBytes() []byte {
 	bz := ModuleCdc.MustMarshalJSON(msg)
 	return sdk.MustSortJSON(bz)
 }
 
-func (msg *MsgDeleteAllowlistRequest) ValidateBasic() error {
+func (msg *MsgDeleteAllowlistEntryRequest) ValidateBasic() error {
 	_, err := sdk.AccAddressFromBech32(msg.Signer)
 	if err != nil {
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
 	}
+
+	_, err = sdk.AccAddressFromBech32(msg.Address)
+	if err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid allowlist address (%s)", err)
+	}
 	return nil
 }

wormchain/x/wormhole/types/query.pb.go

@@ -76,7 +76,7 @@ func (m *QueryAllValidatorAllowlist) GetPagination() *query.PageRequest {
 
 // all allowlisted entries by all validators
 type QueryAllValidatorAllowlistResponse struct {
-	AllowedAddress []*ValidatorAllowedAddress `protobuf:"bytes,1,rep,name=allowed_address,json=allowedAddress,proto3" json:"allowed_address,omitempty"`
+	Allowlist  []*ValidatorAllowedAddress `protobuf:"bytes,1,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
 	Pagination *query.PageResponse        `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
@@ -113,9 +113,9 @@ func (m *QueryAllValidatorAllowlistResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryAllValidatorAllowlistResponse proto.InternalMessageInfo
 
-func (m *QueryAllValidatorAllowlistResponse) GetAllowedAddress() []*ValidatorAllowedAddress {
+func (m *QueryAllValidatorAllowlistResponse) GetAllowlist() []*ValidatorAllowedAddress {
 	if m != nil {
-		return m.AllowedAddress
+		return m.Allowlist
 	}
 	return nil
 }
@@ -182,7 +182,7 @@ func (m *QueryValidatorAllowlist) GetPagination() *query.PageRequest {
 // all allowlisted entries by a specific validator
 type QueryValidatorAllowlistResponse struct {
 	ValidatorAddress string                     `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
-	AllowedAddress   []*ValidatorAllowedAddress `protobuf:"bytes,2,rep,name=allowed_address,json=allowedAddress,proto3" json:"allowed_address,omitempty"`
+	Allowlist        []*ValidatorAllowedAddress `protobuf:"bytes,2,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
 	Pagination       *query.PageResponse        `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
@@ -226,9 +226,9 @@ func (m *QueryValidatorAllowlistResponse) GetValidatorAddress() string {
 	return ""
 }
 
-func (m *QueryValidatorAllowlistResponse) GetAllowedAddress() []*ValidatorAllowedAddress {
+func (m *QueryValidatorAllowlistResponse) GetAllowlist() []*ValidatorAllowedAddress {
 	if m != nil {
-		return m.AllowedAddress
+		return m.Allowlist
 	}
 	return nil
 }
@@ -1254,88 +1254,88 @@ func init() {
 func init() { proto.RegisterFile("wormhole/query.proto", fileDescriptor_273185ecc792fa38) }
 
 var fileDescriptor_273185ecc792fa38 = []byte{
-	// 1285 bytes of a gzipped FileDescriptorProto
+	// 1281 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x99, 0x4f, 0x6f, 0xdc, 0xc4,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x99, 0x4f, 0x6f, 0xdc, 0xc4,
-	0x1b, 0xc7, 0x33, 0xd9, 0x5f, 0x2b, 0x65, 0xd2, 0x5f, 0x93, 0x0c, 0x69, 0x52, 0x0c, 0xda, 0x2c,
+	0x1b, 0xc7, 0x33, 0xbb, 0xbf, 0x56, 0xca, 0xa4, 0x3f, 0x9a, 0x0c, 0x69, 0x52, 0x0c, 0xda, 0x2c,
-	0x06, 0x95, 0xd0, 0x0a, 0x9b, 0x24, 0x22, 0x69, 0x5a, 0x4a, 0xba, 0xd9, 0xb2, 0xbb, 0x49, 0x83,
+	0x06, 0x95, 0xd0, 0x0a, 0x9b, 0x24, 0x22, 0x69, 0x5a, 0x4a, 0xba, 0xbb, 0x25, 0xbb, 0x49, 0x83,
-	0x94, 0x6e, 0x24, 0x0e, 0x20, 0xb4, 0x72, 0x76, 0x27, 0x5e, 0x57, 0x8e, 0xbd, 0x5d, 0x7b, 0xdb,
+	0x94, 0x6e, 0x24, 0x0e, 0xa0, 0x6a, 0xe5, 0xec, 0x4e, 0x1c, 0x57, 0x8e, 0xbd, 0x5d, 0x7b, 0xdb,
-	0x86, 0x28, 0x07, 0x90, 0xb8, 0x70, 0x88, 0x10, 0xbc, 0x14, 0x5e, 0x00, 0x07, 0x2e, 0x3d, 0x56,
+	0x86, 0x28, 0x17, 0x24, 0x2e, 0x1c, 0x22, 0x04, 0x2f, 0x85, 0x17, 0xc0, 0x81, 0x4b, 0x0f, 0x1c,
-	0xaa, 0xc4, 0x1f, 0x55, 0x42, 0x28, 0xa9, 0x38, 0xc0, 0x81, 0x2b, 0x42, 0x1c, 0x90, 0xc7, 0x8f,
+	0x2a, 0x55, 0xe2, 0x8f, 0x2a, 0x21, 0x94, 0x54, 0x1c, 0xe0, 0xc0, 0x0d, 0x21, 0xc4, 0x01, 0x79,
-	0xbd, 0x5e, 0xaf, 0x6d, 0x6c, 0xaf, 0xcb, 0xcd, 0x99, 0x19, 0x7f, 0xe7, 0xf9, 0x3c, 0xf3, 0xcc,
+	0xfc, 0xd8, 0xeb, 0xf5, 0xda, 0xc6, 0xf6, 0x3a, 0xb7, 0xed, 0xcc, 0xf8, 0x3b, 0xcf, 0xe7, 0x99,
-	0xcc, 0x77, 0x1d, 0x3c, 0xfd, 0x40, 0xef, 0xec, 0xb7, 0x74, 0x95, 0x8a, 0xf7, 0xba, 0xb4, 0x73,
+	0x67, 0x66, 0xbe, 0x99, 0xe2, 0xc9, 0x87, 0x7a, 0x67, 0x6f, 0x57, 0x57, 0xa9, 0x78, 0xbf, 0x4b,
-	0x20, 0xb4, 0x3b, 0xba, 0xa9, 0x93, 0x4b, 0x4e, 0x6b, 0x7d, 0x4f, 0xef, 0x6a, 0x4d, 0xc9, 0x54,
+	0x3b, 0xfb, 0x42, 0xbb, 0xa3, 0x9b, 0x3a, 0xb9, 0xe4, 0xb4, 0x36, 0x76, 0xf4, 0xae, 0xd6, 0x92,
-	0x74, 0x4d, 0xb0, 0xda, 0x1a, 0x2d, 0x49, 0xb1, 0x9f, 0xac, 0x5e, 0xee, 0x65, 0x59, 0xd7, 0x65,
+	0x4c, 0x45, 0xd7, 0x04, 0xab, 0xad, 0xb9, 0x2b, 0x29, 0xf6, 0x2f, 0xab, 0x97, 0x7b, 0x45, 0xd6,
-	0x95, 0x8a, 0x52, 0x5b, 0x11, 0x25, 0x4d, 0xd3, 0x4d, 0x36, 0xd2, 0xb0, 0x55, 0xb8, 0xcb, 0x0d,
+	0x75, 0x59, 0xa5, 0xa2, 0xd4, 0x56, 0x44, 0x49, 0xd3, 0x74, 0x93, 0x8d, 0x34, 0x6c, 0x15, 0xee,
-	0xdd, 0xd8, 0xd7, 0x0d, 0x71, 0x57, 0x32, 0x40, 0x5e, 0xbc, 0xbf, 0xb0, 0x4b, 0x4d, 0x69, 0x41,
+	0x72, 0x53, 0x37, 0xf6, 0x74, 0x43, 0xdc, 0x96, 0x0c, 0x90, 0x17, 0x1f, 0xcc, 0x6d, 0x53, 0x53,
-	0x6c, 0x4b, 0xb2, 0xa2, 0xd9, 0xb2, 0xf6, 0xd8, 0x59, 0x37, 0x0e, 0xb9, 0x2b, 0x75, 0x9a, 0x8a,
+	0x9a, 0x13, 0xdb, 0x92, 0xac, 0x68, 0xb6, 0xac, 0x3d, 0x76, 0xda, 0x8d, 0x43, 0xee, 0x4a, 0x9d,
-	0xe4, 0x74, 0x5c, 0x70, 0x3b, 0x1a, 0xba, 0xb6, 0xa7, 0xc8, 0xd0, 0x5c, 0x70, 0x9b, 0x3b, 0xb4,
+	0x96, 0x22, 0x39, 0x1d, 0x17, 0xdc, 0x8e, 0xa6, 0xae, 0xed, 0x28, 0x32, 0x34, 0x17, 0xdd, 0xe6,
-	0xad, 0x4a, 0x07, 0x75, 0xab, 0x99, 0x36, 0x3c, 0x8a, 0x73, 0xee, 0x08, 0x83, 0xde, 0xeb, 0x52,
+	0x0e, 0x6d, 0xab, 0xd2, 0x7e, 0xc3, 0x6a, 0xa6, 0x4d, 0x8f, 0xe2, 0x8c, 0x3b, 0xc2, 0xa0, 0xf7,
-	0xad, 0x41, 0xeb, 0x0d, 0xbd, 0xab, 0x99, 0xb4, 0x03, 0x03, 0xae, 0x78, 0x95, 0x0d, 0xaa, 0x19,
+	0xbb, 0x54, 0x6b, 0xd2, 0x46, 0x53, 0xef, 0x6a, 0x26, 0xed, 0xc0, 0x80, 0x2b, 0x5e, 0x65, 0x83,
-	0x5d, 0xa3, 0xee, 0x4c, 0x5e, 0x37, 0xa8, 0x59, 0x57, 0xb4, 0x26, 0x7d, 0x08, 0x83, 0xa7, 0x65,
+	0x6a, 0x46, 0xd7, 0x68, 0x38, 0x93, 0x37, 0x0c, 0x6a, 0x36, 0x14, 0xad, 0x45, 0x1f, 0xc1, 0xe0,
-	0x5d, 0xd6, 0xd9, 0xa3, 0x68, 0x3d, 0xd9, 0xad, 0x7c, 0x13, 0x73, 0x77, 0x2c, 0xae, 0xa2, 0xaa,
+	0x49, 0x59, 0x97, 0x75, 0xf6, 0x53, 0xb4, 0x7e, 0xd9, 0xad, 0x7c, 0x0b, 0x73, 0x77, 0x2c, 0xae,
-	0x7e, 0x20, 0xa9, 0x4a, 0x53, 0x32, 0xf5, 0x4e, 0x51, 0x55, 0xf5, 0x07, 0xaa, 0x62, 0x98, 0xa4,
+	0x92, 0xaa, 0x7e, 0x28, 0xa9, 0x4a, 0x4b, 0x32, 0xf5, 0x4e, 0x49, 0x55, 0xf5, 0x87, 0xaa, 0x62,
-	0x8c, 0x71, 0x8f, 0xf3, 0x22, 0x2a, 0xa0, 0xf9, 0xf1, 0xc5, 0x4b, 0x82, 0x9d, 0x14, 0xc1, 0x4a,
+	0x98, 0x64, 0x15, 0xe3, 0x1e, 0xe7, 0x45, 0x54, 0x44, 0xb3, 0x63, 0xf3, 0x97, 0x04, 0x3b, 0x29,
-	0x8a, 0x60, 0xe7, 0x1c, 0x92, 0x22, 0x6c, 0x4b, 0x32, 0xad, 0x59, 0xb1, 0x1a, 0x66, 0xcd, 0xf3,
+	0x82, 0x95, 0x14, 0xc1, 0xce, 0x39, 0x24, 0x45, 0xd8, 0x94, 0x64, 0x5a, 0xb7, 0x62, 0x35, 0xcc,
-	0x26, 0xff, 0x03, 0xc2, 0x7c, 0xf8, 0x34, 0x35, 0x6a, 0xb4, 0xad, 0xf8, 0x49, 0x0b, 0x4f, 0x48,
+	0xba, 0xe7, 0x4b, 0xfe, 0x3b, 0x84, 0xf9, 0xf0, 0x69, 0xea, 0xd4, 0x68, 0x5b, 0xf1, 0x93, 0xbb,
-	0x56, 0x23, 0x6d, 0xd6, 0xa5, 0x66, 0xb3, 0x43, 0x0d, 0xe3, 0x22, 0x2a, 0xe4, 0xe6, 0xc7, 0x17,
+	0x78, 0x54, 0x72, 0x1a, 0x2f, 0xa2, 0x62, 0x7e, 0x76, 0x6c, 0x7e, 0x45, 0x88, 0xb7, 0x90, 0x42,
-	0xd7, 0x84, 0x78, 0xcb, 0x29, 0xf4, 0x8b, 0xd3, 0x66, 0xd1, 0x96, 0xa9, 0x9d, 0x97, 0xfa, 0xfe,
+	0xbf, 0x2c, 0x6d, 0x95, 0x5a, 0xad, 0x0e, 0x35, 0x8c, 0x7a, 0x4f, 0x91, 0x54, 0xfb, 0x68, 0x72,
-	0x26, 0x95, 0x3e, 0xb0, 0x51, 0x06, 0xf6, 0xfa, 0xbf, 0x82, 0xd9, 0x61, 0xf6, 0x91, 0x1d, 0x23,
+	0x8c, 0xe6, 0x8d, 0xff, 0xa4, 0xb1, 0x63, 0xeb, 0xc3, 0x39, 0x42, 0x78, 0x9a, 0xe1, 0x04, 0xa4,
-	0x3c, 0xcb, 0xc8, 0x02, 0xb2, 0x77, 0x05, 0x4f, 0xdd, 0x77, 0x5a, 0x3d, 0x40, 0x68, 0x7e, 0xac,
+	0xec, 0x0a, 0x9e, 0x78, 0xe0, 0xb4, 0x36, 0x24, 0x3b, 0x08, 0x96, 0xb9, 0xd1, 0xfa, 0xb8, 0xdb,
-	0x36, 0xe9, 0x76, 0x38, 0x11, 0x95, 0x03, 0x22, 0x4a, 0x93, 0xea, 0x4f, 0x47, 0xf1, 0x5c, 0x48,
+	0x01, 0xc1, 0xf9, 0xf2, 0x9b, 0x4b, 0x9d, 0xdf, 0x3f, 0x11, 0x9e, 0x09, 0x09, 0xc8, 0x4d, 0x6e,
-	0x40, 0x6e, 0x9e, 0x13, 0x05, 0x16, 0xb0, 0x28, 0xa3, 0xff, 0xc5, 0xa2, 0xe4, 0xd2, 0x2f, 0xca,
+	0xa2, 0xc0, 0xfa, 0x56, 0x22, 0x77, 0xca, 0x2b, 0x91, 0x4f, 0xbf, 0x12, 0xf3, 0x50, 0xbe, 0x55,
-	0x22, 0x14, 0x75, 0x85, 0x9a, 0x15, 0xd8, 0x0e, 0x3b, 0xd4, 0x84, 0x6c, 0x91, 0x69, 0x7c, 0x86,
+	0x6a, 0x56, 0xa1, 0xf0, 0xb7, 0xa8, 0x09, 0x29, 0x22, 0x93, 0xf8, 0x0c, 0xdb, 0x01, 0x0c, 0xf3,
-	0xed, 0x0b, 0x46, 0xfc, 0xff, 0x9a, 0xfd, 0x07, 0xff, 0x09, 0x7e, 0x29, 0xf0, 0x1d, 0x48, 0xd9,
+	0xff, 0x75, 0xfb, 0x1f, 0xfc, 0x27, 0xf8, 0xe5, 0xc0, 0x6f, 0x20, 0x4f, 0x1f, 0xe3, 0x31, 0x4f,
-	0x47, 0x78, 0xdc, 0xd3, 0x0c, 0x5b, 0x61, 0x29, 0x6e, 0x06, 0x3c, 0xaf, 0xae, 0xff, 0xef, 0xd1,
+	0x33, 0x14, 0xfd, 0x42, 0x5c, 0x78, 0xcf, 0xa7, 0xe5, 0xff, 0x3d, 0xfe, 0x79, 0x66, 0xa4, 0xee,
-	0xcf, 0x73, 0x23, 0x35, 0xaf, 0x9a, 0x77, 0x13, 0x06, 0xc4, 0x9b, 0xd5, 0x26, 0xfc, 0x0e, 0x01,
+	0x55, 0xf3, 0x6e, 0xb7, 0x80, 0x78, 0xb3, 0xda, 0x6e, 0xdf, 0x22, 0x40, 0xf4, 0x4f, 0x13, 0x86,
-	0xa2, 0x7f, 0x9a, 0x30, 0xc4, 0x5c, 0x76, 0x88, 0xd9, 0x6d, 0xb8, 0x59, 0x7c, 0xc1, 0x59, 0xa7,
+	0x98, 0xcf, 0x0e, 0x31, 0xbb, 0x5d, 0x36, 0x8d, 0x2f, 0x38, 0xeb, 0x54, 0x61, 0x07, 0x27, 0xa0,
-	0x12, 0x3b, 0x4e, 0x01, 0x95, 0xdf, 0xc3, 0x33, 0xfe, 0x0e, 0x00, 0xdb, 0xc2, 0x67, 0xed, 0x16,
+	0xf2, 0x3b, 0x78, 0xca, 0xdf, 0x01, 0x60, 0x1b, 0xf8, 0xac, 0xdd, 0x02, 0xc9, 0x13, 0xe2, 0x32,
-	0x48, 0x9e, 0x10, 0x97, 0xc9, 0x7e, 0x0b, 0x70, 0x40, 0x83, 0x5f, 0x81, 0xfd, 0x55, 0xb1, 0x52,
+	0xd9, 0x5f, 0x01, 0x0e, 0x68, 0xf0, 0x4b, 0xb0, 0xa9, 0xaa, 0x56, 0xea, 0xac, 0x23, 0x7a, 0xd3,
-	0x67, 0x1d, 0xdc, 0xdb, 0xee, 0xb9, 0x1d, 0x58, 0x61, 0x63, 0x4e, 0x85, 0x1d, 0x23, 0x5c, 0x08,
+	0x3d, 0xa1, 0x03, 0x2b, 0x6c, 0xd4, 0xa9, 0xb0, 0x23, 0x84, 0x8b, 0xe1, 0x5f, 0x42, 0xac, 0xf7,
-	0x7f, 0x13, 0x62, 0xbd, 0x8b, 0x27, 0x3b, 0xbe, 0x3e, 0x88, 0xfa, 0x6a, 0xdc, 0xa8, 0xfd, 0xda,
+	0xf0, 0x78, 0xc7, 0xd7, 0x07, 0x51, 0x5f, 0x8d, 0x1b, 0xb5, 0x5f, 0x1b, 0xe2, 0x1f, 0xd0, 0xe5,
-	0x10, 0xff, 0x80, 0x2e, 0xaf, 0x00, 0x49, 0x51, 0x55, 0xc3, 0x48, 0x32, 0xbc, 0x00, 0x0a, 0xe1,
+	0x15, 0x20, 0x29, 0xa9, 0x6a, 0x18, 0x49, 0x56, 0xb5, 0xf7, 0x83, 0xc3, 0x1e, 0x38, 0x57, 0x24,
-	0x73, 0x45, 0xb2, 0xe7, 0x9e, 0x07, 0x7b, 0x76, 0xf5, 0xb8, 0x8c, 0xf3, 0xce, 0xa2, 0xee, 0xc0,
+	0x7b, 0xfe, 0x34, 0xd8, 0xb3, 0xab, 0xc7, 0x45, 0x5c, 0x70, 0x16, 0x75, 0x0b, 0xee, 0xe3, 0x8a,
-	0x2d, 0x5d, 0xb2, 0x2f, 0xe9, 0xe8, 0x6a, 0xf8, 0x02, 0xf5, 0xea, 0x68, 0xe0, 0x45, 0x48, 0x88,
+	0x7d, 0x1d, 0x47, 0x57, 0xc3, 0xe7, 0xa8, 0x57, 0x47, 0x03, 0x1f, 0x42, 0x42, 0x64, 0x7c, 0xde,
-	0x8c, 0x27, 0x8c, 0xfe, 0x2e, 0x58, 0x82, 0x95, 0xb8, 0xf9, 0xf0, 0x29, 0x43, 0x3a, 0xfc, 0xaa,
+	0xe8, 0xef, 0x82, 0x25, 0x58, 0x8a, 0x9b, 0x0f, 0x9f, 0x32, 0xa4, 0xc3, 0xaf, 0xca, 0xef, 0x02,
-	0x7c, 0x0b, 0x20, 0x8a, 0xaa, 0x1a, 0x02, 0x91, 0x55, 0x21, 0x3c, 0x41, 0xbd, 0xa2, 0x4b, 0x84,
+	0x44, 0x49, 0x55, 0x43, 0x20, 0xb2, 0x2a, 0x84, 0xa7, 0xa8, 0x57, 0x74, 0x89, 0xb0, 0xf3, 0xd9,
-	0x9d, 0xcb, 0x1e, 0x3b, 0xbb, 0x22, 0xb8, 0x8c, 0xe7, 0x3d, 0x67, 0x8f, 0xed, 0xc4, 0x3c, 0xa7,
+	0x63, 0x67, 0x57, 0x04, 0x97, 0xf1, 0xac, 0xe7, 0xec, 0xb1, 0x3d, 0x97, 0xe7, 0xf4, 0x5b, 0xb3,
-	0xdf, 0x86, 0xb5, 0xe2, 0xce, 0x39, 0xf5, 0x0d, 0xc2, 0x6f, 0xc4, 0x18, 0x0c, 0xb9, 0xf8, 0x1c,
+	0x56, 0xdc, 0x39, 0xa7, 0xbe, 0x46, 0xf8, 0xcd, 0x18, 0x83, 0x21, 0x17, 0x9f, 0x21, 0xfc, 0x52,
-	0xe1, 0x17, 0x43, 0x47, 0xc1, 0x3a, 0x14, 0x13, 0x9c, 0x67, 0xc1, 0x42, 0x90, 0xa0, 0xf0, 0x99,
+	0xe8, 0x28, 0x58, 0x87, 0x52, 0x82, 0xf3, 0x2c, 0x58, 0x08, 0x12, 0x14, 0x3e, 0x13, 0x7f, 0xab,
-	0xf8, 0x5b, 0xbd, 0xb3, 0xcb, 0xe9, 0x73, 0xaf, 0x75, 0xa7, 0x46, 0x0a, 0x78, 0xdc, 0x71, 0x9f,
+	0x77, 0x76, 0x39, 0x7d, 0xee, 0x8d, 0xee, 0xd4, 0x48, 0x11, 0x8f, 0x39, 0x3e, 0xf3, 0x36, 0xdd,
-	0xb7, 0xe9, 0x01, 0x0b, 0xee, 0x5c, 0xcd, 0xdb, 0xc4, 0x7f, 0x85, 0xf0, 0x2b, 0x11, 0x32, 0xc0,
+	0x67, 0xc1, 0x9d, 0xab, 0x7b, 0x9b, 0xf8, 0x2f, 0x11, 0x7e, 0x35, 0x42, 0x06, 0x98, 0xf7, 0xf0,
-	0xbc, 0x8f, 0xa7, 0x64, 0x7f, 0x27, 0xa0, 0xae, 0x26, 0xbd, 0x8e, 0x5c, 0x01, 0x40, 0x1c, 0x54,
+	0x84, 0xec, 0xef, 0x04, 0xd4, 0xe5, 0xa4, 0xd7, 0x91, 0x2b, 0x00, 0x88, 0x83, 0xca, 0xfc, 0xbd,
-	0xe6, 0xef, 0xf6, 0x8e, 0xa6, 0x50, 0xb4, 0xac, 0xca, 0xff, 0xa9, 0x93, 0x80, 0xe0, 0xc9, 0xa2,
+	0xde, 0xd1, 0x14, 0x8a, 0x96, 0x55, 0xf9, 0x3f, 0x73, 0x12, 0x10, 0x3c, 0x59, 0x74, 0x02, 0xf2,
-	0x13, 0x90, 0x7b, 0x3e, 0x09, 0xc8, 0x6e, 0x1b, 0xbc, 0x06, 0x2e, 0x7f, 0x4b, 0x32, 0xa9, 0x61,
+	0xa7, 0x93, 0x80, 0xec, 0xb6, 0xc1, 0xeb, 0xe0, 0xe7, 0x37, 0x24, 0x93, 0x1a, 0x66, 0xd8, 0x06,
-	0x86, 0x6d, 0x80, 0x8f, 0xf1, 0xab, 0x91, 0xa3, 0x20, 0x09, 0xcb, 0x78, 0x46, 0x0d, 0x1c, 0x01,
+	0xb8, 0x8b, 0x5f, 0x8b, 0x1c, 0x05, 0x49, 0x58, 0xc4, 0x53, 0x6a, 0xe0, 0x08, 0xf0, 0x6d, 0x21,
-	0xbe, 0x2d, 0xa4, 0x77, 0xf1, 0xcf, 0x59, 0x7c, 0x86, 0xe9, 0x93, 0xa7, 0xa8, 0xcf, 0xd1, 0x90,
+	0xbd, 0xf3, 0x7f, 0x4d, 0xe3, 0x33, 0x4c, 0x9f, 0x3c, 0x43, 0x7d, 0x8e, 0x86, 0x94, 0xe3, 0xe6,
-	0xf5, 0xb8, 0xb9, 0x0b, 0x37, 0x8f, 0x5c, 0x69, 0x28, 0x0d, 0x1b, 0x8d, 0x2f, 0x7d, 0xf6, 0xe4,
+	0x2e, 0xdc, 0x3c, 0x72, 0x95, 0xa1, 0x34, 0x6c, 0x34, 0xbe, 0xf2, 0xe9, 0xd3, 0xe7, 0x5f, 0xe5,
-	0xd9, 0xd7, 0xa3, 0x37, 0xc8, 0x75, 0x31, 0x40, 0x4c, 0x74, 0xc5, 0xc4, 0x81, 0x5f, 0x94, 0x3b,
+	0x6e, 0x90, 0xeb, 0x62, 0x80, 0x98, 0xe8, 0x8a, 0x89, 0x03, 0x7f, 0x3b, 0x6e, 0x51, 0x53, 0x3c,
-	0xd4, 0x14, 0x0f, 0xd9, 0xfd, 0x71, 0x44, 0xbe, 0x47, 0xf8, 0xbc, 0x47, 0xbc, 0xa8, 0xaa, 0x09,
+	0x60, 0xf7, 0xc7, 0x21, 0xf9, 0x1e, 0xe1, 0x17, 0x3c, 0xe2, 0x25, 0x55, 0x4d, 0x08, 0x18, 0xe8,
-	0x01, 0x03, 0xdd, 0x66, 0x42, 0xc0, 0x60, 0x2b, 0xc9, 0x5f, 0x67, 0x80, 0x6f, 0x93, 0xa5, 0x14,
+	0x36, 0x13, 0x02, 0x06, 0x5b, 0x49, 0xfe, 0x3a, 0x03, 0x7c, 0x87, 0x2c, 0xa4, 0x00, 0x24, 0xdf,
-	0x80, 0xe4, 0x5b, 0xe4, 0xf8, 0x35, 0x72, 0x23, 0x69, 0xb6, 0xfb, 0x2c, 0x21, 0xf7, 0x6e, 0xda,
+	0x20, 0xc7, 0xaf, 0x91, 0x1b, 0x49, 0xb3, 0xdd, 0x67, 0x09, 0xb9, 0xf7, 0xd2, 0x7e, 0x0e, 0x18,
-	0xd7, 0x01, 0x63, 0x99, 0x61, 0xbc, 0x45, 0x84, 0xb8, 0x18, 0xf6, 0x0f, 0x7c, 0xf2, 0x07, 0xc2,
+	0x8b, 0x0c, 0xe3, 0x6d, 0x22, 0xc4, 0xc5, 0xb0, 0xff, 0x94, 0x27, 0x7f, 0x20, 0x3c, 0x5e, 0x1f,
-	0x93, 0xb5, 0x01, 0xc7, 0x91, 0x34, 0x98, 0x10, 0x4f, 0xc6, 0x55, 0x87, 0x17, 0x02, 0xbe, 0x2a,
+	0x70, 0x1c, 0x49, 0x83, 0x09, 0xf1, 0x64, 0x5c, 0x6d, 0x78, 0x21, 0xe0, 0xab, 0x31, 0xbe, 0x32,
-	0xe3, 0x5b, 0x27, 0x37, 0xe3, 0xf2, 0xf9, 0x6d, 0x94, 0x5b, 0x8c, 0xbf, 0x21, 0xfc, 0x82, 0x7f,
+	0xb9, 0x19, 0x97, 0xcf, 0x6f, 0xa3, 0xdc, 0x62, 0xfc, 0x0d, 0xe1, 0x17, 0xfd, 0xd3, 0x58, 0x15,
-	0x1a, 0xab, 0x22, 0x2b, 0x49, 0xab, 0x29, 0x1b, 0xe8, 0x08, 0x97, 0xc9, 0xdf, 0x64, 0xd0, 0xd7,
+	0x59, 0x4d, 0x5a, 0x4d, 0xd9, 0x40, 0x47, 0xb8, 0x4c, 0xfe, 0x26, 0x83, 0xbe, 0x46, 0xae, 0xa6,
-	0xc8, 0xd5, 0xb4, 0xd0, 0xe4, 0x77, 0x84, 0x27, 0x7c, 0x0e, 0x83, 0x94, 0x93, 0x2e, 0x4a, 0xb0,
+	0x85, 0x26, 0xbf, 0x23, 0x7c, 0xde, 0xe7, 0x30, 0xc8, 0x6a, 0xd2, 0x45, 0x09, 0xf6, 0x59, 0x5c,
-	0xcf, 0xe2, 0x2a, 0x43, 0xeb, 0x00, 0x66, 0x85, 0x61, 0x16, 0xc9, 0x5a, 0x5c, 0x4c, 0x9f, 0x39,
+	0x75, 0x68, 0x1d, 0xc0, 0xac, 0x32, 0xcc, 0x12, 0x59, 0x89, 0x8b, 0xe9, 0x33, 0x47, 0xee, 0xd2,
-	0x72, 0x97, 0xf6, 0x57, 0x84, 0x89, 0x6f, 0x12, 0x6b, 0x65, 0xcb, 0x49, 0x17, 0x24, 0x13, 0xe0,
+	0xfe, 0x8a, 0x30, 0xf1, 0x4d, 0x62, 0xad, 0xec, 0x6a, 0xd2, 0x05, 0xc9, 0x04, 0x38, 0xdc, 0x35,
-	0x70, 0xd7, 0xc8, 0xaf, 0x31, 0xe0, 0x55, 0xb2, 0x92, 0x12, 0x98, 0x1c, 0x8f, 0x46, 0x58, 0x2d,
+	0xf2, 0x2b, 0x0c, 0x78, 0x99, 0x2c, 0xa5, 0x04, 0x26, 0x47, 0xb9, 0x08, 0xab, 0x45, 0x36, 0x53,
-	0xb2, 0x9d, 0xe2, 0x2c, 0x89, 0x34, 0x82, 0xdc, 0x9d, 0x0c, 0x15, 0x21, 0x07, 0x5b, 0x2c, 0x07,
+	0x9c, 0x25, 0x91, 0x46, 0x90, 0xbb, 0x93, 0xa1, 0x22, 0xe4, 0x60, 0x83, 0xe5, 0x60, 0x95, 0xdc,
-	0x65, 0x72, 0x2b, 0xc1, 0x81, 0x15, 0xfa, 0xdd, 0x90, 0xfc, 0x85, 0xf0, 0xd4, 0x80, 0x8d, 0x20,
+	0x4a, 0x70, 0x60, 0x85, 0xbe, 0x10, 0x92, 0xbf, 0x11, 0x9e, 0x18, 0xb0, 0x11, 0xa4, 0x96, 0xf6,
-	0xd5, 0xb4, 0x37, 0xa0, 0xdf, 0x54, 0x71, 0x1b, 0x19, 0x28, 0x01, 0xf8, 0x36, 0x03, 0xdf, 0x24,
+	0x06, 0xf4, 0x9b, 0x2a, 0x6e, 0x2d, 0x03, 0x25, 0x00, 0xdf, 0x64, 0xe0, 0xeb, 0xa4, 0x96, 0xf4,
-	0xd5, 0xa4, 0x17, 0x4e, 0xdd, 0xfd, 0xde, 0x25, 0x1e, 0x7a, 0x9c, 0xea, 0x91, 0x75, 0x86, 0x4f,
+	0xc2, 0x69, 0xb8, 0x8f, 0x5c, 0xe2, 0x81, 0xc7, 0xa9, 0x1e, 0x5a, 0x67, 0xf8, 0xe4, 0xc0, 0x7c,
-	0x0f, 0xcc, 0x67, 0x15, 0x7e, 0x35, 0xed, 0x05, 0x39, 0x24, 0x7f, 0x94, 0x63, 0xe4, 0xd7, 0x19,
+	0x56, 0xe1, 0xd7, 0xd2, 0x5e, 0x90, 0x43, 0xf2, 0x47, 0x39, 0x46, 0xbe, 0xcc, 0xf8, 0xdf, 0x25,
-	0xff, 0x3b, 0xe4, 0x5a, 0x7a, 0x7e, 0xf2, 0x37, 0xc2, 0x33, 0xc1, 0x9e, 0x8c, 0x6c, 0x26, 0x8a,
+	0xd7, 0xd2, 0xf3, 0x93, 0x7f, 0x10, 0x9e, 0x0a, 0xf6, 0x64, 0x64, 0x3d, 0x51, 0xa4, 0x91, 0xf6,
-	0x34, 0xd2, 0xfe, 0x71, 0xb7, 0x33, 0xd1, 0x02, 0xee, 0x0d, 0xc6, 0x5d, 0x22, 0xc5, 0xb8, 0xdc,
+	0x8f, 0xbb, 0x9d, 0x89, 0x16, 0x70, 0xaf, 0x31, 0xee, 0x0a, 0x29, 0xc5, 0xe5, 0xb6, 0x4d, 0x63,
-	0xb6, 0x69, 0x0c, 0xaa, 0xf6, 0x9f, 0x10, 0x3e, 0xe7, 0x7e, 0x2a, 0x4d, 0xe5, 0xa6, 0x06, 0xbf,
+	0x50, 0xb5, 0xff, 0x84, 0xf0, 0x39, 0xf7, 0x7d, 0x34, 0x95, 0x9b, 0x1a, 0x7c, 0x66, 0xe5, 0xd6,
-	0xb8, 0x72, 0x9b, 0xc3, 0x6b, 0xb8, 0xac, 0xab, 0x8c, 0x75, 0x89, 0x2c, 0xc4, 0x65, 0x95, 0xdc,
+	0x87, 0xd7, 0x70, 0x59, 0x97, 0x19, 0xeb, 0x02, 0x99, 0x8b, 0xcb, 0xda, 0x7b, 0x59, 0x7d, 0x8e,
-	0x2f, 0xd1, 0xcf, 0x10, 0x1e, 0xeb, 0x7d, 0x97, 0x5e, 0x4b, 0x14, 0x54, 0x00, 0x55, 0x65, 0x48,
+	0xf0, 0x68, 0xef, 0x31, 0x7a, 0x25, 0x51, 0x50, 0x01, 0x54, 0xd5, 0x21, 0x05, 0x5c, 0xa4, 0x0f,
-	0x01, 0x17, 0xe9, 0x7d, 0x86, 0x54, 0x21, 0xef, 0x25, 0x46, 0x12, 0x0f, 0x07, 0xbe, 0x60, 0x1f,
+	0x18, 0x52, 0x95, 0xbc, 0x9f, 0x18, 0x49, 0x3c, 0x18, 0x78, 0xb6, 0x3e, 0x2c, 0x6f, 0x3d, 0x3e,
-	0xad, 0xef, 0x3c, 0x3a, 0xc9, 0xa3, 0xc7, 0x27, 0x79, 0xf4, 0xcb, 0x49, 0x1e, 0x7d, 0x79, 0x9a,
+	0x2e, 0xa0, 0x27, 0xc7, 0x05, 0xf4, 0xcb, 0x71, 0x01, 0x7d, 0x71, 0x52, 0x18, 0x79, 0x72, 0x52,
-	0x1f, 0x79, 0x7c, 0x9a, 0x1f, 0xf9, 0xf1, 0x34, 0x3f, 0xf2, 0xe1, 0xaa, 0xac, 0x98, 0xad, 0xee,
+	0x18, 0xf9, 0xf1, 0xa4, 0x30, 0xf2, 0xd1, 0xb2, 0xac, 0x98, 0xbb, 0xdd, 0x6d, 0xa1, 0xa9, 0xef,
-	0xae, 0xd0, 0xd0, 0xf7, 0x5d, 0xb1, 0x37, 0x03, 0xa7, 0x7a, 0xd8, 0x9b, 0xcc, 0x3c, 0x68, 0x53,
+	0xb9, 0x62, 0x6f, 0x05, 0x4e, 0xf5, 0xa8, 0x37, 0x99, 0xb9, 0xdf, 0xa6, 0xc6, 0xf6, 0x59, 0xf6,
-	0x63, 0xf7, 0x2c, 0xfb, 0x47, 0xc9, 0xd2, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6a, 0x1e, 0x0a,
+	0x5f, 0x22, 0x0b, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xe7, 0x74, 0x41, 0x52, 0x1a, 0x00,
-	0x3b, 0x68, 0x1a, 0x00, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1939,10 +1939,10 @@ func (m *QueryAllValidatorAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.AllowedAddress) > 0 {
+	if len(m.Allowlist) > 0 {
-		for iNdEx := len(m.AllowedAddress) - 1; iNdEx >= 0; iNdEx-- {
+		for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size, err := m.AllowedAddress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				size, err := m.Allowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 				if err != nil {
 					return 0, err
 				}
@@ -2030,10 +2030,10 @@ func (m *QueryValidatorAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (int
 		i--
 		dAtA[i] = 0x1a
 	}
-	if len(m.AllowedAddress) > 0 {
+	if len(m.Allowlist) > 0 {
-		for iNdEx := len(m.AllowedAddress) - 1; iNdEx >= 0; iNdEx-- {
+		for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size, err := m.AllowedAddress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				size, err := m.Allowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 				if err != nil {
 					return 0, err
 				}
@@ -2833,8 +2833,8 @@ func (m *QueryAllValidatorAllowlistResponse) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if len(m.AllowedAddress) > 0 {
+	if len(m.Allowlist) > 0 {
-		for _, e := range m.AllowedAddress {
+		for _, e := range m.Allowlist {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
@@ -2873,8 +2873,8 @@ func (m *QueryValidatorAllowlistResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	if len(m.AllowedAddress) > 0 {
+	if len(m.Allowlist) > 0 {
-		for _, e := range m.AllowedAddress {
+		for _, e := range m.Allowlist {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
@@ -3293,7 +3293,7 @@ func (m *QueryAllValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AllowedAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -3320,8 +3320,8 @@ func (m *QueryAllValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.AllowedAddress = append(m.AllowedAddress, &ValidatorAllowedAddress{})
+			m.Allowlist = append(m.Allowlist, &ValidatorAllowedAddress{})
-			if err := m.AllowedAddress[len(m.AllowedAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Allowlist[len(m.Allowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -3563,7 +3563,7 @@ func (m *QueryValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AllowedAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -3590,8 +3590,8 @@ func (m *QueryValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.AllowedAddress = append(m.AllowedAddress, &ValidatorAllowedAddress{})
+			m.Allowlist = append(m.Allowlist, &ValidatorAllowedAddress{})
-			if err := m.AllowedAddress[len(m.AllowedAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Allowlist[len(m.Allowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex

wormchain/x/wormhole/types/tx.pb.go

@@ -28,7 +28,7 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-type MsgCreateAllowlistRequest struct {
+type MsgCreateAllowlistEntryRequest struct {
 	// signer should be a guardian validator in a current set or future set.
 	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
 	// the address to allowlist
@@ -37,18 +37,18 @@ type MsgCreateAllowlistRequest struct {
 	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
 }
 
-func (m *MsgCreateAllowlistRequest) Reset()         { *m = MsgCreateAllowlistRequest{} }
+func (m *MsgCreateAllowlistEntryRequest) Reset()         { *m = MsgCreateAllowlistEntryRequest{} }
-func (m *MsgCreateAllowlistRequest) String() string { return proto.CompactTextString(m) }
+func (m *MsgCreateAllowlistEntryRequest) String() string { return proto.CompactTextString(m) }
-func (*MsgCreateAllowlistRequest) ProtoMessage()    {}
+func (*MsgCreateAllowlistEntryRequest) ProtoMessage()    {}
-func (*MsgCreateAllowlistRequest) Descriptor() ([]byte, []int) {
+func (*MsgCreateAllowlistEntryRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_55f7aa067b0c517b, []int{0}
 }
-func (m *MsgCreateAllowlistRequest) XXX_Unmarshal(b []byte) error {
+func (m *MsgCreateAllowlistEntryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgCreateAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgCreateAllowlistEntryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgCreateAllowlistRequest.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgCreateAllowlistEntryRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -58,58 +58,58 @@ func (m *MsgCreateAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
-func (m *MsgCreateAllowlistRequest) XXX_Merge(src proto.Message) {
+func (m *MsgCreateAllowlistEntryRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgCreateAllowlistRequest.Merge(m, src)
+	xxx_messageInfo_MsgCreateAllowlistEntryRequest.Merge(m, src)
 }
-func (m *MsgCreateAllowlistRequest) XXX_Size() int {
+func (m *MsgCreateAllowlistEntryRequest) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgCreateAllowlistRequest) XXX_DiscardUnknown() {
+func (m *MsgCreateAllowlistEntryRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgCreateAllowlistRequest.DiscardUnknown(m)
+	xxx_messageInfo_MsgCreateAllowlistEntryRequest.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgCreateAllowlistRequest proto.InternalMessageInfo
+var xxx_messageInfo_MsgCreateAllowlistEntryRequest proto.InternalMessageInfo
 
-func (m *MsgCreateAllowlistRequest) GetSigner() string {
+func (m *MsgCreateAllowlistEntryRequest) GetSigner() string {
 	if m != nil {
 		return m.Signer
 	}
 	return ""
 }
 
-func (m *MsgCreateAllowlistRequest) GetAddress() string {
+func (m *MsgCreateAllowlistEntryRequest) GetAddress() string {
 	if m != nil {
 		return m.Address
 	}
 	return ""
 }
 
-func (m *MsgCreateAllowlistRequest) GetName() string {
+func (m *MsgCreateAllowlistEntryRequest) GetName() string {
 	if m != nil {
 		return m.Name
 	}
 	return ""
 }
 
-type MsgDeleteAllowlistRequest struct {
+type MsgDeleteAllowlistEntryRequest struct {
 	// signer should be a guardian validator in a current set or future set.
 	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
 	// the address allowlist to remove
 	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
 }
 
-func (m *MsgDeleteAllowlistRequest) Reset()         { *m = MsgDeleteAllowlistRequest{} }
+func (m *MsgDeleteAllowlistEntryRequest) Reset()         { *m = MsgDeleteAllowlistEntryRequest{} }
-func (m *MsgDeleteAllowlistRequest) String() string { return proto.CompactTextString(m) }
+func (m *MsgDeleteAllowlistEntryRequest) String() string { return proto.CompactTextString(m) }
-func (*MsgDeleteAllowlistRequest) ProtoMessage()    {}
+func (*MsgDeleteAllowlistEntryRequest) ProtoMessage()    {}
-func (*MsgDeleteAllowlistRequest) Descriptor() ([]byte, []int) {
+func (*MsgDeleteAllowlistEntryRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_55f7aa067b0c517b, []int{1}
 }
-func (m *MsgDeleteAllowlistRequest) XXX_Unmarshal(b []byte) error {
+func (m *MsgDeleteAllowlistEntryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgDeleteAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgDeleteAllowlistEntryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgDeleteAllowlistRequest.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgDeleteAllowlistEntryRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -119,26 +119,26 @@ func (m *MsgDeleteAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
-func (m *MsgDeleteAllowlistRequest) XXX_Merge(src proto.Message) {
+func (m *MsgDeleteAllowlistEntryRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgDeleteAllowlistRequest.Merge(m, src)
+	xxx_messageInfo_MsgDeleteAllowlistEntryRequest.Merge(m, src)
 }
-func (m *MsgDeleteAllowlistRequest) XXX_Size() int {
+func (m *MsgDeleteAllowlistEntryRequest) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgDeleteAllowlistRequest) XXX_DiscardUnknown() {
+func (m *MsgDeleteAllowlistEntryRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgDeleteAllowlistRequest.DiscardUnknown(m)
+	xxx_messageInfo_MsgDeleteAllowlistEntryRequest.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgDeleteAllowlistRequest proto.InternalMessageInfo
+var xxx_messageInfo_MsgDeleteAllowlistEntryRequest proto.InternalMessageInfo
 
-func (m *MsgDeleteAllowlistRequest) GetSigner() string {
+func (m *MsgDeleteAllowlistEntryRequest) GetSigner() string {
 	if m != nil {
 		return m.Signer
 	}
 	return ""
 }
 
-func (m *MsgDeleteAllowlistRequest) GetAddress() string {
+func (m *MsgDeleteAllowlistEntryRequest) GetAddress() string {
 	if m != nil {
 		return m.Address
 	}
@@ -603,8 +603,8 @@ func (m *MsgInstantiateContractResponse) GetData() []byte {
 }
 
 func init() {
-	proto.RegisterType((*MsgCreateAllowlistRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgCreateAllowlistRequest")
+	proto.RegisterType((*MsgCreateAllowlistEntryRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgCreateAllowlistEntryRequest")
-	proto.RegisterType((*MsgDeleteAllowlistRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgDeleteAllowlistRequest")
+	proto.RegisterType((*MsgDeleteAllowlistEntryRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgDeleteAllowlistEntryRequest")
 	proto.RegisterType((*MsgAllowlistResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgAllowlistResponse")
 	proto.RegisterType((*MsgExecuteGovernanceVAA)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAA")
 	proto.RegisterType((*MsgExecuteGovernanceVAAResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAAResponse")
@@ -619,47 +619,48 @@ func init() {
 func init() { proto.RegisterFile("wormhole/tx.proto", fileDescriptor_55f7aa067b0c517b) }
 
 var fileDescriptor_55f7aa067b0c517b = []byte{
-	// 635 bytes of a gzipped FileDescriptorProto
+	// 642 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x41, 0x6b, 0xd4, 0x4e,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcf, 0x6e, 0xd3, 0x4e,
-	0x14, 0x6f, 0xba, 0xed, 0x96, 0x3e, 0xc2, 0xff, 0x5f, 0xe3, 0x52, 0xd3, 0xa5, 0xa4, 0x1a, 0xa5,
+	0x10, 0xae, 0x9b, 0x36, 0x55, 0x47, 0xd1, 0x4f, 0xfd, 0x99, 0xa8, 0x84, 0xa8, 0x72, 0xc1, 0xa0,
-	0x78, 0x71, 0x03, 0x2a, 0x82, 0x28, 0x4a, 0xb6, 0xd5, 0x52, 0x30, 0x1e, 0x52, 0x51, 0xf0, 0xb2,
+	0x8a, 0x0b, 0x89, 0x04, 0x08, 0x09, 0x81, 0x40, 0x49, 0xff, 0xa9, 0x12, 0xe6, 0xe0, 0x22, 0x90,
-	0xcc, 0x26, 0xe3, 0x34, 0x90, 0xcc, 0xac, 0x99, 0x49, 0xbb, 0x7b, 0xf2, 0x23, 0x28, 0xde, 0x05,
+	0xb8, 0x44, 0x1b, 0x7b, 0xba, 0xb5, 0x64, 0xef, 0x86, 0xdd, 0x75, 0xdb, 0x9c, 0x78, 0x04, 0x78,
-	0x2f, 0x9e, 0xfd, 0x1a, 0x1e, 0x7b, 0xf4, 0x54, 0x64, 0xf7, 0x8b, 0x48, 0x26, 0x26, 0xbb, 0x74,
+	0x00, 0x90, 0x78, 0x03, 0xce, 0xbc, 0x01, 0xc7, 0x1e, 0x39, 0x55, 0x28, 0x7d, 0x11, 0xe4, 0x35,
-	0x13, 0x31, 0x6c, 0x6f, 0xef, 0xbd, 0xc9, 0xfb, 0xfd, 0x7e, 0xef, 0xe5, 0xcd, 0x1b, 0xb8, 0x72,
+	0x76, 0x22, 0xd5, 0xae, 0xb0, 0xda, 0xdb, 0xcc, 0xac, 0xe7, 0xfb, 0xbe, 0x19, 0xcf, 0xce, 0xc2,
-	0xca, 0xe2, 0xe8, 0x98, 0x85, 0xd8, 0x12, 0xc3, 0xce, 0x20, 0x66, 0x82, 0x69, 0xbb, 0x79, 0xa8,
+	0xff, 0xc7, 0x5c, 0x44, 0x87, 0x3c, 0xc4, 0xae, 0x3a, 0xe9, 0x8c, 0x04, 0x57, 0xdc, 0xdc, 0xc8,
-	0xf7, 0x8e, 0x25, 0xd4, 0x47, 0x22, 0x60, 0xb4, 0x93, 0xc6, 0xbc, 0x63, 0x14, 0x64, 0x56, 0x7a,
+	0x42, 0x83, 0x03, 0x1e, 0x33, 0x9f, 0xa8, 0x80, 0xb3, 0x4e, 0x12, 0xf3, 0x0e, 0x49, 0x90, 0x5a,
-	0xda, 0x6e, 0x11, 0x46, 0x98, 0x4c, 0xb1, 0x52, 0x2b, 0xcb, 0x36, 0x11, 0x6c, 0x39, 0x9c, 0xec,
+	0xc9, 0x69, 0xbb, 0x49, 0x39, 0xe5, 0x3a, 0xa5, 0x9b, 0x58, 0x69, 0xb6, 0x7d, 0x00, 0x96, 0x23,
-	0xc5, 0x18, 0x09, 0x6c, 0x87, 0x21, 0x3b, 0x0d, 0x03, 0x2e, 0x5c, 0xfc, 0x3e, 0xc1, 0x5c, 0x68,
+	0xe9, 0xa6, 0x40, 0xa2, 0xb0, 0x17, 0x86, 0xfc, 0x38, 0x0c, 0xa4, 0xda, 0x66, 0x4a, 0x8c, 0x5d,
-	0x9b, 0xd0, 0xe4, 0x01, 0xa1, 0x38, 0xd6, 0x95, 0xeb, 0xca, 0xed, 0x75, 0xf7, 0x8f, 0xa7, 0xe9,
+	0xfc, 0x10, 0xa3, 0x54, 0xe6, 0x2a, 0xd4, 0x65, 0x40, 0x19, 0x8a, 0x96, 0x71, 0xdb, 0xb8, 0xbf,
-	0xb0, 0x86, 0x7c, 0x3f, 0xc6, 0x9c, 0xeb, 0xcb, 0xf2, 0x20, 0x77, 0x35, 0x0d, 0x56, 0x28, 0x8a,
+	0xec, 0xfe, 0xf5, 0xcc, 0x16, 0x2c, 0x11, 0xdf, 0x17, 0x28, 0x65, 0x6b, 0x5e, 0x1f, 0x64, 0xae,
-	0xb0, 0xde, 0x90, 0x61, 0x69, 0x9b, 0x8e, 0xa4, 0xd8, 0xc7, 0x21, 0xbe, 0x0c, 0x0a, 0x73, 0x13,
+	0x69, 0xc2, 0x02, 0x23, 0x11, 0xb6, 0x6a, 0x3a, 0xac, 0x6d, 0xdb, 0xd5, 0x3c, 0x5b, 0x18, 0xe2,
-	0x5a, 0x0e, 0x27, 0x33, 0x40, 0x7c, 0xc0, 0x28, 0xc7, 0xe6, 0x1e, 0x5c, 0x73, 0x38, 0x79, 0x36,
+	0xb5, 0xf1, 0xd8, 0xab, 0xd0, 0x74, 0x24, 0xcd, 0xd1, 0x5c, 0x94, 0x23, 0xce, 0x24, 0xda, 0x9b,
-	0xc4, 0x5e, 0x22, 0xf0, 0x01, 0x3b, 0xc1, 0x31, 0x45, 0xd4, 0xc3, 0xaf, 0x6d, 0x5b, 0xdb, 0x80,
+	0x70, 0xd3, 0x91, 0x74, 0xfb, 0x04, 0xbd, 0x58, 0xe1, 0x2e, 0x3f, 0x42, 0xc1, 0x08, 0xf3, 0xf0,
-	0xc6, 0x09, 0x42, 0x92, 0x41, 0x75, 0x53, 0x73, 0x86, 0x76, 0x79, 0x96, 0xd6, 0xbc, 0x01, 0x3b,
+	0x6d, 0xaf, 0x67, 0xae, 0x40, 0xed, 0x88, 0x10, 0xcd, 0xd0, 0x70, 0x13, 0x73, 0x86, 0x76, 0x7e,
-	0x15, 0x20, 0x05, 0xcf, 0x2b, 0xd8, 0x76, 0x38, 0x71, 0x31, 0x09, 0xb8, 0xc0, 0xb1, 0xed, 0x79,
+	0x96, 0xd6, 0xbe, 0x03, 0xeb, 0x25, 0x20, 0x39, 0xcf, 0x1b, 0x58, 0x73, 0x24, 0x75, 0x91, 0x06,
-	0x2c, 0xa1, 0xc2, 0xe6, 0x07, 0x09, 0x8a, 0xfd, 0x00, 0xd1, 0xca, 0x8a, 0xb6, 0x61, 0x3d, 0xb5,
+	0x52, 0xa1, 0xe8, 0x79, 0x1e, 0x8f, 0x99, 0xea, 0xc9, 0xdd, 0x98, 0x08, 0x3f, 0x20, 0xac, 0xb4,
-	0x90, 0x48, 0xe2, 0xac, 0x3f, 0xaa, 0x3b, 0x0d, 0x98, 0xbb, 0x70, 0xeb, 0x6f, 0xa8, 0x05, 0xfb,
+	0xa2, 0x35, 0x58, 0x4e, 0x2c, 0xa2, 0x62, 0x91, 0x36, 0xa9, 0xe1, 0x4e, 0x03, 0xf6, 0x06, 0xdc,
-	0x00, 0x54, 0x87, 0x93, 0x23, 0xc1, 0x62, 0xbc, 0xc7, 0x7c, 0x5c, 0xc9, 0xf6, 0x00, 0xfe, 0x3b,
+	0xbb, 0x0c, 0x35, 0x67, 0x1f, 0x41, 0xc3, 0x91, 0x74, 0x5f, 0x71, 0x81, 0x9b, 0xdc, 0xc7, 0x52,
-	0x45, 0x3c, 0xea, 0xf5, 0x47, 0x02, 0xf7, 0x3c, 0xe6, 0x63, 0x59, 0xa8, 0xda, 0xdd, 0x18, 0x9f,
+	0xb6, 0x27, 0xf0, 0xdf, 0x31, 0x91, 0xd1, 0x60, 0x38, 0x56, 0x38, 0xf0, 0xb8, 0x8f, 0xba, 0xd0,
-	0xef, 0xa8, 0x6f, 0xec, 0x23, 0xa7, 0x3b, 0x12, 0x12, 0xc1, 0x55, 0xd3, 0xef, 0x72, 0x2f, 0x6f,
+	0x46, 0x7f, 0x65, 0x72, 0xb6, 0xde, 0x78, 0xd7, 0xdb, 0x77, 0xfa, 0x63, 0xa5, 0x11, 0xdc, 0x46,
-	0x55, 0xa3, 0x68, 0x95, 0xf9, 0x48, 0xf6, 0xbb, 0x60, 0xcc, 0x95, 0x68, 0x37, 0x61, 0x2d, 0xc5,
+	0xf2, 0x5d, 0xe6, 0x65, 0xad, 0xaa, 0xe5, 0xad, 0xb2, 0x9f, 0xe9, 0x7e, 0xe7, 0x8c, 0x99, 0x12,
-	0xed, 0x05, 0xbe, 0xa4, 0x5e, 0xe9, 0xc2, 0xf8, 0x7c, 0xa7, 0x99, 0x7e, 0x72, 0xb8, 0xef, 0x36,
+	0xf3, 0x2e, 0x2c, 0x25, 0xb8, 0x83, 0xc0, 0xd7, 0xd4, 0x0b, 0x7d, 0x98, 0x9c, 0xad, 0xd7, 0x93,
-	0xd3, 0xa3, 0x43, 0xdf, 0xfc, 0xa8, 0xc0, 0xa6, 0xc3, 0xc9, 0x21, 0xe5, 0x02, 0x51, 0x11, 0xa0,
+	0x4f, 0xf6, 0xb6, 0xdc, 0x7a, 0x72, 0xb4, 0xe7, 0xdb, 0x9f, 0x0c, 0x58, 0x75, 0x24, 0xdd, 0x63,
-	0x94, 0x85, 0x8a, 0x18, 0x79, 0xd5, 0x7f, 0x7e, 0x06, 0xb7, 0x51, 0x85, 0xab, 0xb5, 0x60, 0x35,
+	0x52, 0x11, 0xa6, 0x02, 0x92, 0xb0, 0x30, 0x25, 0x88, 0x57, 0xfe, 0xe7, 0x67, 0x70, 0x6b, 0x65,
-	0x44, 0x7d, 0x1c, 0xea, 0x2b, 0x32, 0x37, 0x73, 0x52, 0xf1, 0x11, 0x27, 0xfa, 0x6a, 0x26, 0x3e,
+	0xb8, 0x66, 0x13, 0x16, 0x43, 0x32, 0xc4, 0xb0, 0xb5, 0xa0, 0x73, 0x53, 0x27, 0x11, 0x1f, 0x49,
-	0xe2, 0x24, 0x2f, 0xa7, 0x39, 0x2d, 0xe7, 0x25, 0x18, 0xe5, 0x82, 0x8a, 0xc2, 0x66, 0x46, 0x4f,
+	0xda, 0x5a, 0x4c, 0xc5, 0x47, 0x92, 0x66, 0xe5, 0xd4, 0xa7, 0xe5, 0xbc, 0xd6, 0x23, 0x59, 0x20,
-	0x99, 0x9b, 0x6e, 0x1f, 0x09, 0x94, 0xb5, 0xd2, 0x95, 0xf6, 0xdd, 0x6f, 0x6b, 0xd0, 0x70, 0x38,
+	0x28, 0x2f, 0x6c, 0x66, 0xf4, 0x8c, 0x0b, 0x23, 0xee, 0x13, 0x45, 0xd2, 0x56, 0xba, 0xda, 0x7e,
-	0xd1, 0xbe, 0x2a, 0xd0, 0x2a, 0x1d, 0xbe, 0xa7, 0x9d, 0x7f, 0xbb, 0xa0, 0x9d, 0x8a, 0xc1, 0x6b,
+	0xf8, 0x63, 0x09, 0x6a, 0x8e, 0xa4, 0xe6, 0x37, 0x03, 0x9a, 0x85, 0xc3, 0xf7, 0xb2, 0xf3, 0x6f,
-	0x1f, 0x2c, 0x08, 0x50, 0x14, 0xf6, 0x5d, 0x81, 0xad, 0xea, 0xb9, 0xdd, 0xaf, 0x41, 0x53, 0x89,
+	0x57, 0xb5, 0x53, 0x32, 0x78, 0xed, 0xdd, 0x2b, 0x02, 0xe4, 0x85, 0x7d, 0x37, 0xe0, 0x56, 0xf9,
-	0xd2, 0x7e, 0x71, 0x19, 0x28, 0x85, 0xe2, 0xcf, 0x0a, 0xfc, 0x7f, 0x61, 0x37, 0x69, 0x76, 0x0d,
+	0xdc, 0x6e, 0x55, 0xa0, 0x29, 0x45, 0x69, 0xbf, 0xba, 0x0e, 0x94, 0x5c, 0xf1, 0x17, 0x03, 0x9a,
-	0x86, 0xf2, 0xbd, 0xd6, 0x7e, 0x5c, 0x03, 0x62, 0x6e, 0xd1, 0x48, 0x51, 0x17, 0xb6, 0x59, 0x2d,
+	0x45, 0x5b, 0xca, 0xdc, 0xa9, 0x40, 0x73, 0xc9, 0x9a, 0x6b, 0x3f, 0xaf, 0x80, 0x73, 0x61, 0xe5,
-	0x51, 0xe5, 0x9b, 0x70, 0x41, 0x51, 0x1f, 0x60, 0x7d, 0xba, 0x14, 0xee, 0xd7, 0x80, 0x2a, 0xb2,
+	0x68, 0x79, 0x45, 0xcb, 0xad, 0x92, 0xbc, 0x4b, 0xb6, 0xe3, 0x15, 0xe5, 0x7d, 0x84, 0xe5, 0xe9,
-	0x6a, 0x09, 0x98, 0x5f, 0x07, 0x5f, 0x14, 0xb8, 0x5a, 0x76, 0xcd, 0x9f, 0xd4, 0x40, 0x2d, 0xc9,
+	0xa2, 0x78, 0x5c, 0x01, 0x2a, 0xcf, 0xaa, 0x24, 0xe0, 0xe2, 0x8a, 0xf8, 0x6a, 0xc0, 0x8d, 0xa2,
-	0x6f, 0x3f, 0x5f, 0x2c, 0x3f, 0xd7, 0xd7, 0x3d, 0xfa, 0x31, 0x36, 0x94, 0xb3, 0xb1, 0xa1, 0xfc,
+	0xab, 0xff, 0xa2, 0x02, 0x6a, 0x41, 0x7e, 0x7b, 0xe7, 0x6a, 0xf9, 0x99, 0xbe, 0xfe, 0xfe, 0xcf,
-	0x1a, 0x1b, 0xca, 0xa7, 0x89, 0xb1, 0x74, 0x36, 0x31, 0x96, 0x7e, 0x4e, 0x8c, 0xa5, 0xb7, 0x0f,
+	0x89, 0x65, 0x9c, 0x4e, 0x2c, 0xe3, 0xf7, 0xc4, 0x32, 0x3e, 0x9f, 0x5b, 0x73, 0xa7, 0xe7, 0xd6,
-	0x49, 0x20, 0x8e, 0x93, 0x7e, 0xc7, 0x63, 0x91, 0x95, 0xa3, 0xdd, 0x99, 0x72, 0x59, 0x05, 0x97,
+	0xdc, 0xaf, 0x73, 0x6b, 0xee, 0xfd, 0x53, 0x1a, 0xa8, 0xc3, 0x78, 0xd8, 0xf1, 0x78, 0xd4, 0xcd,
-	0x35, 0xb4, 0xa6, 0xcf, 0xef, 0x68, 0x80, 0x79, 0xbf, 0x29, 0x1f, 0xd1, 0x7b, 0xbf, 0x03, 0x00,
+	0xd0, 0x1e, 0x4c, 0xb9, 0xba, 0x39, 0x57, 0xf7, 0xa4, 0x3b, 0x7d, 0x9c, 0xc7, 0x23, 0x94, 0xc3,
-	0x00, 0xff, 0xff, 0x6a, 0x6d, 0xca, 0x8f, 0x97, 0x07, 0x00, 0x00,
+	0xba, 0x7e, 0x62, 0x1f, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0x86, 0x0b, 0xf1, 0x5c, 0xb5, 0x07,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -676,8 +677,8 @@ const _ = grpc.SupportPackageIsVersion4
 type MsgClient interface {
 	ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error)
 	RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error)
-	CreateAllowlist(ctx context.Context, in *MsgCreateAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
+	CreateAllowlistEntry(ctx context.Context, in *MsgCreateAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
-	DeleteAllowlist(ctx context.Context, in *MsgDeleteAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
+	DeleteAllowlistEntry(ctx context.Context, in *MsgDeleteAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
 	// StoreCode to submit Wasm code to the system
 	StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error)
 	//  Instantiate creates a new smart contract instance for the given code id.
@@ -710,18 +711,18 @@ func (c *msgClient) RegisterAccountAsGuardian(ctx context.Context, in *MsgRegist
 	return out, nil
 }
 
-func (c *msgClient) CreateAllowlist(ctx context.Context, in *MsgCreateAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
+func (c *msgClient) CreateAllowlistEntry(ctx context.Context, in *MsgCreateAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
 	out := new(MsgAllowlistResponse)
-	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlist", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlistEntry", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *msgClient) DeleteAllowlist(ctx context.Context, in *MsgDeleteAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
+func (c *msgClient) DeleteAllowlistEntry(ctx context.Context, in *MsgDeleteAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
 	out := new(MsgAllowlistResponse)
-	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlist", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlistEntry", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -750,8 +751,8 @@ func (c *msgClient) InstantiateContract(ctx context.Context, in *MsgInstantiateC
 type MsgServer interface {
 	ExecuteGovernanceVAA(context.Context, *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error)
 	RegisterAccountAsGuardian(context.Context, *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error)
-	CreateAllowlist(context.Context, *MsgCreateAllowlistRequest) (*MsgAllowlistResponse, error)
+	CreateAllowlistEntry(context.Context, *MsgCreateAllowlistEntryRequest) (*MsgAllowlistResponse, error)
-	DeleteAllowlist(context.Context, *MsgDeleteAllowlistRequest) (*MsgAllowlistResponse, error)
+	DeleteAllowlistEntry(context.Context, *MsgDeleteAllowlistEntryRequest) (*MsgAllowlistResponse, error)
 	// StoreCode to submit Wasm code to the system
 	StoreCode(context.Context, *MsgStoreCode) (*MsgStoreCodeResponse, error)
 	//  Instantiate creates a new smart contract instance for the given code id.
@@ -768,11 +769,11 @@ func (*UnimplementedMsgServer) ExecuteGovernanceVAA(ctx context.Context, req *Ms
 func (*UnimplementedMsgServer) RegisterAccountAsGuardian(ctx context.Context, req *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RegisterAccountAsGuardian not implemented")
 }
-func (*UnimplementedMsgServer) CreateAllowlist(ctx context.Context, req *MsgCreateAllowlistRequest) (*MsgAllowlistResponse, error) {
+func (*UnimplementedMsgServer) CreateAllowlistEntry(ctx context.Context, req *MsgCreateAllowlistEntryRequest) (*MsgAllowlistResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CreateAllowlist not implemented")
+	return nil, status.Errorf(codes.Unimplemented, "method CreateAllowlistEntry not implemented")
 }
-func (*UnimplementedMsgServer) DeleteAllowlist(ctx context.Context, req *MsgDeleteAllowlistRequest) (*MsgAllowlistResponse, error) {
+func (*UnimplementedMsgServer) DeleteAllowlistEntry(ctx context.Context, req *MsgDeleteAllowlistEntryRequest) (*MsgAllowlistResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllowlist not implemented")
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllowlistEntry not implemented")
 }
 func (*UnimplementedMsgServer) StoreCode(ctx context.Context, req *MsgStoreCode) (*MsgStoreCodeResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method StoreCode not implemented")
@@ -821,38 +822,38 @@ func _Msg_RegisterAccountAsGuardian_Handler(srv interface{}, ctx context.Context
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_CreateAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Msg_CreateAllowlistEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgCreateAllowlistRequest)
+	in := new(MsgCreateAllowlistEntryRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).CreateAllowlist(ctx, in)
+		return srv.(MsgServer).CreateAllowlistEntry(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlist",
+		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlistEntry",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).CreateAllowlist(ctx, req.(*MsgCreateAllowlistRequest))
+		return srv.(MsgServer).CreateAllowlistEntry(ctx, req.(*MsgCreateAllowlistEntryRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_DeleteAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Msg_DeleteAllowlistEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgDeleteAllowlistRequest)
+	in := new(MsgDeleteAllowlistEntryRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).DeleteAllowlist(ctx, in)
+		return srv.(MsgServer).DeleteAllowlistEntry(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlist",
+		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlistEntry",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).DeleteAllowlist(ctx, req.(*MsgDeleteAllowlistRequest))
+		return srv.(MsgServer).DeleteAllowlistEntry(ctx, req.(*MsgDeleteAllowlistEntryRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -906,12 +907,12 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Msg_RegisterAccountAsGuardian_Handler,
 		},
 		{
-			MethodName: "CreateAllowlist",
+			MethodName: "CreateAllowlistEntry",
-			Handler:    _Msg_CreateAllowlist_Handler,
+			Handler:    _Msg_CreateAllowlistEntry_Handler,
 		},
 		{
-			MethodName: "DeleteAllowlist",
+			MethodName: "DeleteAllowlistEntry",
-			Handler:    _Msg_DeleteAllowlist_Handler,
+			Handler:    _Msg_DeleteAllowlistEntry_Handler,
 		},
 		{
 			MethodName: "StoreCode",
@@ -926,7 +927,7 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 	Metadata: "wormhole/tx.proto",
 }
 
-func (m *MsgCreateAllowlistRequest) Marshal() (dAtA []byte, err error) {
+func (m *MsgCreateAllowlistEntryRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -936,12 +937,12 @@ func (m *MsgCreateAllowlistRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgCreateAllowlistRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgCreateAllowlistEntryRequest) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgCreateAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgCreateAllowlistEntryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -970,7 +971,7 @@ func (m *MsgCreateAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgDeleteAllowlistRequest) Marshal() (dAtA []byte, err error) {
+func (m *MsgDeleteAllowlistEntryRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -980,12 +981,12 @@ func (m *MsgDeleteAllowlistRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgDeleteAllowlistRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgDeleteAllowlistEntryRequest) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgDeleteAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgDeleteAllowlistEntryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1326,7 +1327,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
-func (m *MsgCreateAllowlistRequest) Size() (n int) {
+func (m *MsgCreateAllowlistEntryRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1347,7 +1348,7 @@ func (m *MsgCreateAllowlistRequest) Size() (n int) {
 	return n
 }
 
-func (m *MsgDeleteAllowlistRequest) Size() (n int) {
+func (m *MsgDeleteAllowlistEntryRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1509,7 +1510,7 @@ func sovTx(x uint64) (n int) {
 func sozTx(x uint64) (n int) {
 	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
-func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
+func (m *MsgCreateAllowlistEntryRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1532,10 +1533,10 @@ func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgCreateAllowlistRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgCreateAllowlistEntryRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgCreateAllowlistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgCreateAllowlistEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1655,7 +1656,7 @@ func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MsgDeleteAllowlistRequest) Unmarshal(dAtA []byte) error {
+func (m *MsgDeleteAllowlistEntryRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1678,10 +1679,10 @@ func (m *MsgDeleteAllowlistRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgDeleteAllowlistRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgDeleteAllowlistEntryRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgDeleteAllowlistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgDeleteAllowlistEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1: