Instantiate allowlist (#3181)

* sdk: add wormchain instantiate allowlist governance VAA

* wormchain: add wasm instantiate allowlist msg handler

* Add cli for instantiate allowlist (#3199)

* Add cli for instantiate allowlist and fix
vaa.BodyWormchainAllowlistInstantiateContract deserialization

* Lint fixes

* Add instantiate allowlist to codec and genesis

* Add MsgDeleteWasmInstantiateAllowlist, update naming to be consistent across all types

* Fix key prefix for GetAllWasmInstiateAllowedAddresses

* Update wasmd tag version

* Fix 5 bit encoding bug

* Add query cli and rpc handler

* Add query cli and rpc files

* use cosmos-sdk method for computing bech32

---------

Co-authored-by: Steve <1848680+misko9@users.noreply.github.com>

node/cmd/guardiand/admintemplate.go

@@ -45,6 +45,12 @@ var wormchainMigrateContractCodeId *string
 var wormchainMigrateContractContractAddress *string
 var wormchainMigrateContractInstantiationMsg *string
 
+var wormchainAddWasmInstantiateAllowlistCodeId *string
+var wormchainAddWasmInstantiateAllowlistContractAddress *string
+
+var wormchainDeleteWasmInstantiateAllowlistCodeId *string
+var wormchainDeleteWasmInstantiateAllowlistContractAddress *string
+
 var ibcReceiverUpdateChannelChainTargetChainId *string
 var ibcReceiverUpdateChannelChainChannelId *string
 var ibcReceiverUpdateChannelChainChainId *string
@@ -118,6 +124,18 @@ func init() {
 	AdminClientWormchainMigrateContractCmd.Flags().AddFlagSet(wormchainMigrateContractFlagSet)
 	TemplateCmd.AddCommand(AdminClientWormchainMigrateContractCmd)
 
+	wormchainAddWasmInstantiateAllowlistFlagSet := pflag.NewFlagSet("wormchain-add-wasm-instantiate-allowlist", pflag.ExitOnError)
+	wormchainAddWasmInstantiateAllowlistCodeId = wormchainAddWasmInstantiateAllowlistFlagSet.String("code-id", "", "code ID of the stored code to allowlist wasm instantiate for")
+	wormchainAddWasmInstantiateAllowlistContractAddress = wormchainAddWasmInstantiateAllowlistFlagSet.String("contract-address", "", "contract address to allowlist wasm instantiate for")
+	AdminClientWormchainAddWasmInstantiateAllowlistCmd.Flags().AddFlagSet(wormchainAddWasmInstantiateAllowlistFlagSet)
+	TemplateCmd.AddCommand(AdminClientWormchainAddWasmInstantiateAllowlistCmd)
+
+	wormchainDeleteWasmInstantiateAllowlistFlagSet := pflag.NewFlagSet("wormchain-delete-wasm-instantiate-allowlist", pflag.ExitOnError)
+	wormchainDeleteWasmInstantiateAllowlistCodeId = wormchainDeleteWasmInstantiateAllowlistFlagSet.String("code-id", "", "code ID of the stored code to delete allowlist wasm instantiate for")
+	wormchainDeleteWasmInstantiateAllowlistContractAddress = wormchainDeleteWasmInstantiateAllowlistFlagSet.String("contract-address", "", "contract address to delete allowlist wasm instantiate for")
+	AdminClientWormchainDeleteWasmInstantiateAllowlistCmd.Flags().AddFlagSet(wormchainDeleteWasmInstantiateAllowlistFlagSet)
+	TemplateCmd.AddCommand(AdminClientWormchainDeleteWasmInstantiateAllowlistCmd)
+
 	// flags for the ibc-receiver-update-channel-chain command
 	ibcReceiverUpdateChannelChainFlagSet := pflag.NewFlagSet("ibc-mapping", pflag.ExitOnError)
 	ibcReceiverUpdateChannelChainTargetChainId = ibcReceiverUpdateChannelChainFlagSet.String("target-chain-id", "", "Target Chain ID for the governance VAA")
@@ -192,6 +210,18 @@ var AdminClientWormchainMigrateContractCmd = &cobra.Command{
 	Run:   runWormchainMigrateContractTemplate,
 }
 
+var AdminClientWormchainAddWasmInstantiateAllowlistCmd = &cobra.Command{
+	Use:   "wormchain-add-wasm-instantiate-allowlist",
+	Short: "Generate an empty wormchain add wasm instantiate allowlist template at specified path",
+	Run:   runWormchainAddWasmInstantiateAllowlistTemplate,
+}
+
+var AdminClientWormchainDeleteWasmInstantiateAllowlistCmd = &cobra.Command{
+	Use:   "wormchain-delete-wasm-instantiate-allowlist",
+	Short: "Generate an empty wormchain delete wasm instantiate allowlist template at specified path",
+	Run:   runWormchainDeleteWasmInstantiateAllowlistTemplate,
+}
+
 var AdminClientIbcReceiverUpdateChannelChainCmd = &cobra.Command{
 	Use:   "ibc-receiver-update-channel-chain",
 	Short: "Generate an empty ibc receiver channelId to chainId mapping update template at specified path",
@@ -518,7 +548,7 @@ func runWormchainInstantiateContractTemplate(cmd *cobra.Command, args []string)
 		log.Fatal("--label must be specified.")
 	}
 	if *wormchainInstantiateContractInstantiationMsg == "" {
-		log.Fatal("--instantiate-msg must be specified.")
+		log.Fatal("--instantiation-msg must be specified.")
 	}
 
 	m := &nodev1.InjectGovernanceVAARequest{
@@ -584,6 +614,73 @@ func runWormchainMigrateContractTemplate(cmd *cobra.Command, args []string) {
 	fmt.Print(string(b))
 }
 
+func wormchainWasmInstantiateAllowlistValidation(rawCodeId *string, rawContractAddress *string) (uint64, string) {
+	if *rawCodeId == "" {
+		log.Fatal("--code-id must be specified")
+	}
+	codeId, err := strconv.ParseUint(*rawCodeId, 10, 64)
+	if err != nil {
+		log.Fatal("failed to parse code-id as utin64: ", err)
+	}
+	if *rawContractAddress == "" {
+		log.Fatal("--contract-address must be specified")
+	}
+
+	return codeId, *rawContractAddress
+}
+
+func runWormchainAddWasmInstantiateAllowlistTemplate(cmd *cobra.Command, args []string) {
+	codeId, contractAddr := wormchainWasmInstantiateAllowlistValidation(wormchainAddWasmInstantiateAllowlistCodeId, wormchainAddWasmInstantiateAllowlistContractAddress)
+
+	m := &nodev1.InjectGovernanceVAARequest{
+		CurrentSetIndex: uint32(*templateGuardianIndex),
+		Messages: []*nodev1.GovernanceMessage{
+			{
+				Sequence: rand.Uint64(),
+				Nonce:    rand.Uint32(),
+				Payload: &nodev1.GovernanceMessage_WormchainAddWasmInstantiateAllowlist{
+					WormchainAddWasmInstantiateAllowlist: &nodev1.WormchainAddWasmInstantiateAllowlist{
+						CodeId:   codeId,
+						Contract: contractAddr,
+					},
+				},
+			},
+		},
+	}
+
+	b, err := prototext.MarshalOptions{Multiline: true}.Marshal(m)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print(string(b))
+}
+
+func runWormchainDeleteWasmInstantiateAllowlistTemplate(cmd *cobra.Command, args []string) {
+	codeId, contractAddr := wormchainWasmInstantiateAllowlistValidation(wormchainDeleteWasmInstantiateAllowlistCodeId, wormchainDeleteWasmInstantiateAllowlistContractAddress)
+
+	m := &nodev1.InjectGovernanceVAARequest{
+		CurrentSetIndex: uint32(*templateGuardianIndex),
+		Messages: []*nodev1.GovernanceMessage{
+			{
+				Sequence: rand.Uint64(),
+				Nonce:    rand.Uint32(),
+				Payload: &nodev1.GovernanceMessage_WormchainDeleteWasmInstantiateAllowlist{
+					WormchainDeleteWasmInstantiateAllowlist: &nodev1.WormchainDeleteWasmInstantiateAllowlist{
+						CodeId:   codeId,
+						Contract: contractAddr,
+					},
+				},
+			},
+		},
+	}
+
+	b, err := prototext.MarshalOptions{Multiline: true}.Marshal(m)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print(string(b))
+}
+
 func runIbcReceiverUpdateChannelChainTemplate(cmd *cobra.Command, args []string) {
 	if *ibcReceiverUpdateChannelChainTargetChainId == "" {
 		log.Fatal("--target-chain-id must be specified")

node/go.mod

@@ -370,6 +370,6 @@ replace github.com/wormhole-foundation/wormhole/sdk => ../sdk
 
 replace github.com/wormhole-foundation/wormchain => ../wormchain
 
-replace github.com/CosmWasm/wasmd v0.30.0 => github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1
+replace github.com/CosmWasm/wasmd v0.30.0 => github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2
 
 replace github.com/cosmos/cosmos-sdk => github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole

node/go.sum

@@ -3083,8 +3083,8 @@ github.com/willf/bitset v1.1.11-0.20200630133818-d5bec3311243/go.mod h1:RjeCKbqT
 github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI=
 github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole h1:oWRuBpqReZoLX3pXeqz/sTgu3xPzqnxaFW2GWG5vgTs=
 github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole/go.mod h1:Z5M4TX7PsHNHlF/1XanI2DIpORQ+Q/st7oaeufEjnvU=
-github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1 h1:1+u753gKU44slOOLNdk7LiE5QtZU+3joVuQuU2xW1Bg=
-github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1/go.mod h1:BcwmiI8b2fR2MGioz3HeVvON5QjSDfrnUbGu0gKRk5U=
+github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2 h1:T5lnEObp6nfp83K1GJSvgaRQ8VQjhokupAsEPWBph4A=
+github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2/go.mod h1:BcwmiI8b2fR2MGioz3HeVvON5QjSDfrnUbGu0gKRk5U=
 github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees=
 github.com/xanzy/go-gitlab v0.31.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=
 github.com/xanzy/go-gitlab v0.32.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=

node/pkg/adminrpc/adminserver.go

@@ -31,6 +31,8 @@ import (
 	"github.com/certusone/wormhole/node/pkg/common"
 	nodev1 "github.com/certusone/wormhole/node/pkg/proto/node/v1"
 	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+
+	sdktypes "github.com/cosmos/cosmos-sdk/types"
 )
 
 type nodePrivilegedService struct {
@@ -304,6 +306,37 @@ func wormchainMigrateContract(req *nodev1.WormchainMigrateContract, timestamp ti
 	return v, nil
 }
 
+func wormchainAddWasmInstantiateAllowlist(req *nodev1.WormchainAddWasmInstantiateAllowlist, timestamp time.Time, guardianSetIndex uint32, nonce uint32, sequence uint64) (*vaa.VAA, error) { //nolint:unparam // error is always nil but kept to mirror function signature of other functions
+	return wormchainWasmInstantiateAllowlist(vaa.ActionAddWasmInstantiateAllowlist, req.CodeId, req.Contract, timestamp, guardianSetIndex, nonce, sequence)
+}
+
+func wormchainDeleteWasmInstantiateAllowlist(req *nodev1.WormchainDeleteWasmInstantiateAllowlist, timestamp time.Time, guardianSetIndex uint32, nonce uint32, sequence uint64) (*vaa.VAA, error) { //nolint:unparam // error is always nil but kept to mirror function signature of other functions
+	return wormchainWasmInstantiateAllowlist(vaa.ActionDeleteWasmInstantiateAllowlist, req.CodeId, req.Contract, timestamp, guardianSetIndex, nonce, sequence)
+}
+
+func wormchainWasmInstantiateAllowlist(action vaa.GovernanceAction, codeId uint64, contract string, timestamp time.Time, guardianSetIndex uint32, nonce uint32, sequence uint64) (*vaa.VAA, error) {
+	// parse contract address into 32 bytes
+	// bech32 decode the string into bytes
+	decoded, err := sdktypes.GetFromBech32(contract, "wormhole")
+	if err != nil {
+		return nil, fmt.Errorf("invalid bech32 contract address %w", err)
+	}
+
+	if len(decoded) != 32 {
+		return nil, fmt.Errorf("contract address is not 32 bytes: %s", contract)
+	}
+
+	var decodedArr [32]byte
+	copy(decodedArr[:], decoded)
+
+	v := vaa.CreateGovernanceVAA(timestamp, nonce, sequence, guardianSetIndex, vaa.BodyWormchainWasmAllowlistInstantiate{
+		ContractAddr: decodedArr,
+		CodeId:       codeId,
+	}.Serialize(action))
+
+	return v, nil
+}
+
 // circleIntegrationUpdateWormholeFinality converts a nodev1.CircleIntegrationUpdateWormholeFinality to its canonical VAA representation
 // Returns an error if the data is invalid
 func circleIntegrationUpdateWormholeFinality(req *nodev1.CircleIntegrationUpdateWormholeFinality, timestamp time.Time, guardianSetIndex uint32, nonce uint32, sequence uint64) (*vaa.VAA, error) {
@@ -464,6 +497,10 @@ func GovMsgToVaa(message *nodev1.GovernanceMessage, currentSetIndex uint32, time
 		v, err = wormchainInstantiateContract(payload.WormchainInstantiateContract, timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_WormchainMigrateContract:
 		v, err = wormchainMigrateContract(payload.WormchainMigrateContract, timestamp, currentSetIndex, message.Nonce, message.Sequence)
+	case *nodev1.GovernanceMessage_WormchainAddWasmInstantiateAllowlist:
+		v, err = wormchainAddWasmInstantiateAllowlist(payload.WormchainAddWasmInstantiateAllowlist, timestamp, currentSetIndex, message.Nonce, message.Sequence)
+	case *nodev1.GovernanceMessage_WormchainDeleteWasmInstantiateAllowlist:
+		v, err = wormchainDeleteWasmInstantiateAllowlist(payload.WormchainDeleteWasmInstantiateAllowlist, timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_CircleIntegrationUpdateWormholeFinality:
 		v, err = circleIntegrationUpdateWormholeFinality(payload.CircleIntegrationUpdateWormholeFinality, timestamp, currentSetIndex, message.Nonce, message.Sequence)
 	case *nodev1.GovernanceMessage_CircleIntegrationRegisterEmitterAndDomain:

proto/node/v1/node.proto

@@ -92,6 +92,8 @@ message GovernanceMessage {
     WormchainStoreCode wormchain_store_code = 14;
     WormchainInstantiateContract wormchain_instantiate_contract = 15;
     WormchainMigrateContract wormchain_migrate_contract = 16;
+    WormchainAddWasmInstantiateAllowlist wormchain_add_wasm_instantiate_allowlist = 23;
+    WormchainDeleteWasmInstantiateAllowlist wormchain_delete_wasm_instantiate_allowlist = 24;
 
     // Global Accountant
     AccountantModifyBalance accountant_modify_balance = 17;
@@ -213,6 +215,22 @@ message WormchainInstantiateContract {
   string instantiation_msg = 3;
 }
 
+message WormchainAddWasmInstantiateAllowlist {
+  // CodeID is the reference to the stored WASM code.
+  uint64 code_id = 1;
+
+  // The address of the contract that is allowlisted to call wasm instantiate without a VAA.
+  string contract = 2;
+}
+
+message WormchainDeleteWasmInstantiateAllowlist {
+  // CodeID is the reference to the stored WASM code.
+  uint64 code_id = 1;
+
+  // The address of the contract that is allowlisted to call wasm instantiate without a VAA.
+  string contract = 2;
+}
+
 message WormchainMigrateContract {
   // CodeID is the reference to the stored WASM code that the contract should migrate to.
   uint64 code_id = 1;

sdk/vaa/payloads.go

@@ -52,9 +52,11 @@ var (
 	ActionCoreRecoverChainId GovernanceAction = 5
 
 	// Wormchain cosmwasm governance actions
-	ActionStoreCode           GovernanceAction = 1
-	ActionInstantiateContract GovernanceAction = 2
-	ActionMigrateContract     GovernanceAction = 3
+	ActionStoreCode                      GovernanceAction = 1
+	ActionInstantiateContract            GovernanceAction = 2
+	ActionMigrateContract                GovernanceAction = 3
+	ActionAddWasmInstantiateAllowlist    GovernanceAction = 4
+	ActionDeleteWasmInstantiateAllowlist GovernanceAction = 5
 
 	// Accountant goverance actions
 	ActionModifyBalance GovernanceAction = 1
@@ -131,6 +133,12 @@ type (
 		MigrationParamsHash [32]byte
 	}
 
+	// BodyWormchainAllowlistInstantiateContract is a governance message to allowlist a specific contract address to instantiate a specific wasm code id.
+	BodyWormchainWasmAllowlistInstantiate struct {
+		ContractAddr [32]byte
+		CodeId       uint64
+	}
+
 	// BodyCircleIntegrationUpdateWormholeFinality is a governance message to update the wormhole finality for Circle Integration.
 	BodyCircleIntegrationUpdateWormholeFinality struct {
 		TargetChainID ChainID
@@ -250,6 +258,27 @@ func (r BodyWormchainMigrateContract) Serialize() []byte {
 	return serializeBridgeGovernanceVaa(WasmdModuleStr, ActionMigrateContract, ChainIDWormchain, r.MigrationParamsHash[:])
 }
 
+func (r BodyWormchainWasmAllowlistInstantiate) Serialize(action GovernanceAction) []byte {
+	payload := &bytes.Buffer{}
+	payload.Write(r.ContractAddr[:])
+	MustWrite(payload, binary.BigEndian, r.CodeId)
+	return serializeBridgeGovernanceVaa(WasmdModuleStr, action, ChainIDWormchain, payload.Bytes())
+}
+
+func (r *BodyWormchainWasmAllowlistInstantiate) Deserialize(bz []byte) {
+	if len(bz) != 40 {
+		panic("incorrect payload length")
+	}
+
+	var contractAddr [32]byte
+	copy(contractAddr[:], bz[0:32])
+
+	codeId := binary.BigEndian.Uint64(bz[32:40])
+
+	r.ContractAddr = contractAddr
+	r.CodeId = codeId
+}
+
 func (r BodyCircleIntegrationUpdateWormholeFinality) Serialize() []byte {
 	return serializeBridgeGovernanceVaa(CircleIntegrationModuleStr, CircleIntegrationActionUpdateWormholeFinality, r.TargetChainID, []byte{r.Finality})
 }

wormchain/app/app.go

@@ -433,6 +433,7 @@ func New(
 		&app.IBCKeeper.PortKeeper,
 		scopedWasmKeeper,
 		app.TransferKeeper,
+		app.WormholeKeeper,
 		app.MsgServiceRouter(),
 		app.GRPCQueryRouter(),
 		wasmDir,

wormchain/go.mod

@@ -136,7 +136,7 @@ require (
 
 replace (
 	github.com/99designs/keyring => github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76
-	github.com/CosmWasm/wasmd v0.30.0 => github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1
+	github.com/CosmWasm/wasmd v0.30.0 => github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2
 	github.com/cosmos/cosmos-sdk => github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole-2
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	github.com/wormhole-foundation/wormhole/sdk => ../sdk

wormchain/go.sum

@@ -2079,8 +2079,8 @@ github.com/willf/bitset v1.1.11-0.20200630133818-d5bec3311243/go.mod h1:RjeCKbqT
 github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI=
 github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole-2 h1:ZHvVEU+03UbmUOLfSiXuZjsjirKDV32EToYpjlcknug=
 github.com/wormhole-foundation/cosmos-sdk v0.45.9-wormhole-2/go.mod h1:Z5M4TX7PsHNHlF/1XanI2DIpORQ+Q/st7oaeufEjnvU=
-github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1 h1:1+u753gKU44slOOLNdk7LiE5QtZU+3joVuQuU2xW1Bg=
-github.com/wormhole-foundation/wasmd v0.30.0-wormchain-1/go.mod h1:BcwmiI8b2fR2MGioz3HeVvON5QjSDfrnUbGu0gKRk5U=
+github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2 h1:T5lnEObp6nfp83K1GJSvgaRQ8VQjhokupAsEPWBph4A=
+github.com/wormhole-foundation/wasmd v0.30.0-wormchain-2/go.mod h1:BcwmiI8b2fR2MGioz3HeVvON5QjSDfrnUbGu0gKRk5U=
 github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees=
 github.com/xanzy/go-gitlab v0.31.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=
 github.com/xanzy/go-gitlab v0.32.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=

wormchain/proto/wormhole/genesis.proto

@@ -20,5 +20,6 @@ message GenesisState {
   ConsensusGuardianSetIndex consensusGuardianSetIndex = 5;
   repeated GuardianValidator guardianValidatorList = 6 [(gogoproto.nullable) = false];
   repeated ValidatorAllowedAddress allowedAddresses = 7 [(gogoproto.nullable) = false];
+  repeated WasmInstantiateAllowedContractCodeId wasmInstantiateAllowlist = 8 [(gogoproto.nullable) = false];
   // this line is used by starport scaffolding # genesis/proto/state
 }

wormchain/proto/wormhole/guardian.proto

@@ -29,3 +29,10 @@ message ValidatorAllowedAddress {
   // human readable name
   string name = 3;
 }
+
+message WasmInstantiateAllowedContractCodeId {
+  // bech32 address of the contract that can call wasm instantiate without a VAA
+  string contract_address = 1;
+  // reference to the stored WASM code that can be instantiated
+  uint64 code_id = 2;
+}

wormchain/proto/wormhole/query.proto

@@ -76,6 +76,10 @@ service Query {
 		option (google.api.http).get = "/wormhole_foundation/wormchain/wormhole/allowlist/{validator_address}";
 	}
 
+	rpc WasmInstantiateAllowlistAll(QueryAllWasmInstantiateAllowlist) returns (QueryAllWasmInstantiateAllowlistResponse) {
+		option (google.api.http).get = "/wormhole_foundation/wormchain/wormhole/wasm_instantiate_allowlist";
+	}
+
 // this line is used by starport scaffolding # 2
 }
 
@@ -189,4 +193,14 @@ message QueryLatestGuardianSetIndexResponse {
   uint32 latestGuardianSetIndex = 1;
 }
 
+message QueryAllWasmInstantiateAllowlist {
+	cosmos.base.query.v1beta1.PageRequest pagination = 1;
+}
+
+// all allowlisted entries by all validators
+message QueryAllWasmInstantiateAllowlistResponse {
+	repeated WasmInstantiateAllowedContractCodeId allowlist = 1 [(gogoproto.nullable) = false];
+	cosmos.base.query.v1beta1.PageResponse pagination = 2;
+}
+
 // this line is used by starport scaffolding # 3

wormchain/proto/wormhole/tx.proto

@@ -19,6 +19,9 @@ service Msg {
   //  Instantiate creates a new smart contract instance for the given code id.
   rpc InstantiateContract(MsgInstantiateContract)
       returns (MsgInstantiateContractResponse);
+    
+  rpc AddWasmInstantiateAllowlist(MsgAddWasmInstantiateAllowlist) returns (MsgWasmInstantiateAllowlistResponse);
+  rpc DeleteWasmInstantiateAllowlist(MsgDeleteWasmInstantiateAllowlist) returns (MsgWasmInstantiateAllowlistResponse);
 
   rpc MigrateContract(MsgMigrateContract)
     returns (MsgMigrateContractResponse);
@@ -98,6 +101,29 @@ message MsgInstantiateContractResponse {
   bytes data = 2;
 }
 
+message MsgAddWasmInstantiateAllowlist {
+  // Signer is the actor that signed the messages
+  string signer = 1;
+  // Address is the bech32 address of the contract that can call wasm instantiate without a VAA
+  string address = 2;
+  // CodeID is the reference to the stored WASM code that can be instantiated
+  uint64 code_id = 3;
+  // vaa is the WormchainAddWasmInstantiateAllowlist governance message
+  bytes vaa = 4;
+}
+
+message MsgDeleteWasmInstantiateAllowlist {
+    // signer should be a guardian validator in a current set or future set.
+    string signer = 1;
+    // the <contract, code_id> pair to remove
+    string address = 2;
+    uint64 code_id = 3;
+    // vaa is the WormchainDeleteWasmInstantiateAllowlist governance message
+    bytes vaa = 4;
+}
+
+message MsgWasmInstantiateAllowlistResponse {}
+
 // MsgMigrateContract runs a code upgrade/ downgrade for a smart contract
 message MsgMigrateContract {
   // Sender is the actor that signs the messages

wormchain/testutil/keeper/wormhole.go

@@ -113,6 +113,7 @@ func WormholeKeeperAndWasmd(t testing.TB) (*keeper.Keeper, wasmkeeper.Keeper, *w
 		&wasm_handlers.PortKeeperHandler{},
 		scopedWasmKeeper,
 		&wasm_handlers.ICS20TransferPortSourceHandler{},
+		appapp.WormholeKeeper,
 		appapp.MsgServiceRouter(),
 		appapp.GRPCQueryRouter(),
 		wasmDir,

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

@@ -37,6 +37,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
 	cmd.AddCommand(CmdLatestGuardianSetIndex())
 	cmd.AddCommand(CmdListAllowlists())
 	cmd.AddCommand(CmdShowAllowlist())
+	cmd.AddCommand(CmdListWasmInstantiateAllowlist())
 
 	// this line is used by starport scaffolding # 1
 

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

@@ -0,0 +1,43 @@
+package cli
+
+import (
+	"context"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/spf13/cobra"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+)
+
+func CmdListWasmInstantiateAllowlist() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list-wasm-instantiate-allowlist",
+		Short: "list all allowed contract address and code IDs pairs for wasm instantiate",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx := client.GetClientContextFromCmd(cmd)
+
+			pageReq, err := client.ReadPageRequest(cmd.Flags())
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+
+			params := &types.QueryAllWasmInstantiateAllowlist{
+				Pagination: pageReq,
+			}
+
+			res, err := queryClient.WasmInstantiateAllowlistAll(context.Background(), params)
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddPaginationFlagsToCmd(cmd, cmd.Use)
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

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

@@ -27,6 +27,8 @@ func GetTxCmd() *cobra.Command {
 	cmd.AddCommand(CmdMigrateContract())
 	cmd.AddCommand(CmdCreateAllowedAddress())
 	cmd.AddCommand(CmdDeleteAllowedAddress())
+	cmd.AddCommand(CmdAddWasmInstantiateAllowlist())
+	cmd.AddCommand(CmdDeleteWasmInstantiateAllowlist())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

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

@@ -0,0 +1,96 @@
+package cli
+
+import (
+	"encoding/hex"
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/spf13/cast"
+	"github.com/spf13/cobra"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+)
+
+var _ = strconv.Itoa(0)
+
+// StoreCodeCmd will upload code to be reused.
+func CmdAddWasmInstantiateAllowlist() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "add-wasm-instantiate-allowlist [bech32 contract addr] [codeId] [vaa-hex]",
+		Short: "Allowlist a contract address to be able to instantiate a specific code ID",
+		Args:  cobra.ExactArgs(3),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			address := args[0]
+
+			codeId, err := cast.ToUint64E(args[1])
+			if err != nil {
+				return err
+			}
+
+			vaaBz, err := hex.DecodeString(args[2])
+			if err != nil {
+				return err
+			}
+
+			msg := types.MsgAddWasmInstantiateAllowlist{
+				Signer:  clientCtx.GetFromAddress().String(),
+				Address: address,
+				CodeId:  codeId,
+				Vaa:     vaaBz,
+			}
+
+			if err = msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}
+
+func CmdDeleteWasmInstantiateAllowlist() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delete-wasm-instantiate-allowlist [bech32 contract addr] [codeId] [vaa-hex]",
+		Short: "Delete a contract address and code ID pair from the wasm instantiate allowlist",
+		Args:  cobra.ExactArgs(3),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			address := args[0]
+
+			codeId, err := cast.ToUint64E(args[1])
+			if err != nil {
+				return err
+			}
+
+			vaaBz, err := hex.DecodeString(args[2])
+			if err != nil {
+				return err
+			}
+
+			msg := types.MsgDeleteWasmInstantiateAllowlist{
+				Signer:  clientCtx.GetFromAddress().String(),
+				Address: address,
+				CodeId:  codeId,
+				Vaa:     vaaBz,
+			}
+
+			if err = msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}

wormchain/x/wormhole/genesis.go

@@ -39,6 +39,10 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState)
 	for _, elem := range genState.AllowedAddresses {
 		k.SetValidatorAllowedAddress(ctx, elem)
 	}
+	// Set all the contract/code_id pairs for the wasm instantiate allowlist
+	for _, elem := range genState.WasmInstantiateAllowlist {
+		k.SetWasmInstantiateAllowlist(ctx, elem)
+	}
 	// this line is used by starport scaffolding # genesis/module/init
 }
 
@@ -62,6 +66,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
 	}
 	genesis.GuardianValidatorList = k.GetAllGuardianValidator(ctx)
 	genesis.AllowedAddresses = k.GetAllAllowedAddresses(ctx)
+	genesis.WasmInstantiateAllowlist = k.GetAllWasmInstiateAllowedAddresses(ctx)
 	// this line is used by starport scaffolding # genesis/module/export
 
 	return genesis

wormchain/x/wormhole/handler.go

@@ -29,6 +29,12 @@ 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.MsgAddWasmInstantiateAllowlist:
+			res, err := msgServer.AddWasmInstantiateAllowlist(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgDeleteWasmInstantiateAllowlist:
+			res, err := msgServer.DeleteWasmInstantiateAllowlist(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 		case *types.MsgMigrateContract:
 			res, err := msgServer.MigrateContract(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)

wormchain/x/wormhole/keeper/grpc_query_wasm_instantiate_allowlist.go

@@ -0,0 +1,41 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (k Keeper) WasmInstantiateAllowlistAll(c context.Context, req *types.QueryAllWasmInstantiateAllowlist) (*types.QueryAllWasmInstantiateAllowlistResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	store := ctx.KVStore(k.storeKey)
+	wasmInstantiateAllowlistStore := prefix.NewStore(store, types.KeyPrefix(types.WasmInstantiateAllowlistKey))
+
+	var allowlist []types.WasmInstantiateAllowedContractCodeId
+
+	pageRes, err := query.Paginate(wasmInstantiateAllowlistStore, req.Pagination, func(key []byte, value []byte) error {
+		var allowedContractCodeId types.WasmInstantiateAllowedContractCodeId
+		if err := k.cdc.Unmarshal(value, &allowedContractCodeId); err != nil {
+			return err
+		}
+
+		allowlist = append(allowlist, allowedContractCodeId)
+		return nil
+	})
+
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	return &types.QueryAllWasmInstantiateAllowlistResponse{Allowlist: allowlist, Pagination: pageRes}, nil
+}

wormchain/x/wormhole/keeper/msg_server_wasm_instantiate_allowlist.go

@@ -0,0 +1,83 @@
+package keeper
+
+import (
+	"bytes"
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+)
+
+func (k msgServer) AddWasmInstantiateAllowlist(goCtx context.Context, msg *types.MsgAddWasmInstantiateAllowlist) (*types.MsgWasmInstantiateAllowlistResponse, error) {
+	return k.ExecuteWasmInstantiateAllowlistAction(goCtx, msg.Vaa, msg.Signer, msg.CodeId, msg.Address, vaa.ActionAddWasmInstantiateAllowlist)
+}
+
+func (k msgServer) DeleteWasmInstantiateAllowlist(goCtx context.Context, msg *types.MsgDeleteWasmInstantiateAllowlist) (*types.MsgWasmInstantiateAllowlistResponse, error) {
+	return k.ExecuteWasmInstantiateAllowlistAction(goCtx, msg.Vaa, msg.Signer, msg.CodeId, msg.Address, vaa.ActionDeleteWasmInstantiateAllowlist)
+}
+
+func (k msgServer) ExecuteWasmInstantiateAllowlistAction(goCtx context.Context, vaaBytes []byte, signer string, codeId uint64, contractAddress string, expectedAction vaa.GovernanceAction) (*types.MsgWasmInstantiateAllowlistResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// Parse VAA
+	v, err := ParseVAA(vaaBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify VAA
+	action, payload, err := k.VerifyGovernanceVAA(ctx, v, vaa.WasmdModule)
+	if err != nil {
+		return nil, err
+	}
+
+	// Ensure the governance action is correct
+	if vaa.GovernanceAction(action) != expectedAction {
+		return nil, types.ErrUnknownGovernanceAction
+	}
+
+	// Validate signer
+	_, err = sdk.AccAddressFromBech32(signer)
+	if err != nil {
+		return nil, sdkerrors.Wrap(err, "signer")
+	}
+	ctx.EventManager().EmitEvent(sdk.NewEvent(
+		sdk.EventTypeMessage,
+		sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
+		sdk.NewAttribute(sdk.AttributeKeySender, signer),
+	))
+
+	// verify the cosmos address is correct
+	addrBytes, err := sdk.AccAddressFromBech32(contractAddress)
+	if err != nil {
+		return nil, sdkerrors.Wrap(err, "contract")
+	}
+
+	// validate the <contractAddress, codeId> in the VAA payload match the ones in the message
+	var payloadBody vaa.BodyWormchainWasmAllowlistInstantiate
+	payloadBody.Deserialize(payload)
+	if !bytes.Equal(payloadBody.ContractAddr[:], addrBytes) {
+		return nil, types.ErrInvalidAllowlistContractAddr
+	}
+
+	if payloadBody.CodeId != codeId {
+		return nil, types.ErrInvalidAllowlistCodeId
+	}
+
+	// add or delete the <contractAddress, codeId> pair
+	allowlistEntry := types.WasmInstantiateAllowedContractCodeId{
+		ContractAddress: contractAddress,
+		CodeId:          codeId,
+	}
+	if expectedAction == vaa.ActionAddWasmInstantiateAllowlist {
+		k.SetWasmInstantiateAllowlist(ctx, allowlistEntry)
+	} else if expectedAction == vaa.ActionDeleteWasmInstantiateAllowlist {
+		k.KeeperDeleteWasmInstantiateAllowlist(ctx, allowlistEntry)
+	} else {
+		return nil, types.ErrUnknownGovernanceAction
+	}
+
+	return &types.MsgWasmInstantiateAllowlistResponse{}, nil
+}

wormchain/x/wormhole/keeper/wasm_instantiate_allowlist.go

@@ -0,0 +1,43 @@
+package keeper
+
+import (
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/wormhole-foundation/wormchain/x/wormhole/types"
+)
+
+func (k Keeper) SetWasmInstantiateAllowlist(ctx sdk.Context, entry types.WasmInstantiateAllowedContractCodeId) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.WasmInstantiateAllowlistKey))
+	b := k.cdc.MustMarshal(&entry)
+	codeIdStr := strconv.FormatUint(entry.CodeId, 10)
+	store.Set([]byte(entry.ContractAddress+codeIdStr), b)
+}
+
+func (k Keeper) HasWasmInstantiateAllowlist(ctx sdk.Context, contract string, codeId uint64) bool {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.WasmInstantiateAllowlistKey))
+	codeIdStr := strconv.FormatUint(codeId, 10)
+	return store.Has([]byte(contract + codeIdStr))
+}
+
+func (k Keeper) GetAllWasmInstiateAllowedAddresses(ctx sdk.Context) (list []types.WasmInstantiateAllowedContractCodeId) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.WasmInstantiateAllowlistKey))
+	iterator := sdk.KVStorePrefixIterator(store, []byte{})
+
+	defer iterator.Close()
+
+	for ; iterator.Valid(); iterator.Next() {
+		var val types.WasmInstantiateAllowedContractCodeId
+		k.cdc.MustUnmarshal(iterator.Value(), &val)
+		list = append(list, val)
+	}
+
+	return
+}
+
+func (k Keeper) KeeperDeleteWasmInstantiateAllowlist(ctx sdk.Context, entry types.WasmInstantiateAllowedContractCodeId) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.WasmInstantiateAllowlistKey))
+	codeIdStr := strconv.FormatUint(entry.CodeId, 10)
+	store.Delete([]byte(entry.ContractAddress + codeIdStr))
+}

wormchain/x/wormhole/types/codec.go

@@ -16,6 +16,8 @@ func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgMigrateContract{}, "wormhole/MigrateContract", nil)
 	cdc.RegisterConcrete(&MsgCreateAllowlistEntryRequest{}, "wormhole/CreateAllowlistEntryRequest", nil)
 	cdc.RegisterConcrete(&MsgDeleteAllowlistEntryRequest{}, "wormhole/DeleteAllowlistEntryRequest", nil)
+	cdc.RegisterConcrete(&MsgAddWasmInstantiateAllowlist{}, "wormhole/AddWasmInstantiateAllowlist", nil)
+	cdc.RegisterConcrete(&MsgDeleteWasmInstantiateAllowlist{}, "wormhole/DeleteWasmInstantiateAllowlist", nil)
 	// this line is used by starport scaffolding # 2
 }
 

wormchain/x/wormhole/types/errors.go

@@ -31,4 +31,6 @@ var (
 	ErrConsensusSetNotUpdatable       = sdkerrors.Register(ModuleName, 1122, "cannot make changes to active consensus guardian set")
 	ErrInvalidHash                    = sdkerrors.Register(ModuleName, 1123, "could not verify the hash in governance action")
 	ErrGuardianIndexOutOfBounds       = sdkerrors.Register(ModuleName, 1124, "guardian index out of bounds for the guardian set")
+	ErrInvalidAllowlistContractAddr   = sdkerrors.Register(ModuleName, 1125, "contract addresses in the wasm allowlist msg and vaa do not match")
+	ErrInvalidAllowlistCodeId         = sdkerrors.Register(ModuleName, 1126, "code ids in the wasm allowlist msg and vaa do not match")
 )

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

@@ -25,13 +25,14 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 // GenesisState defines the wormhole module's genesis state.
 type GenesisState struct {
-	GuardianSetList           []GuardianSet              `protobuf:"bytes,1,rep,name=guardianSetList,proto3" json:"guardianSetList"`
-	Config                    *Config                    `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
-	ReplayProtectionList      []ReplayProtection         `protobuf:"bytes,3,rep,name=replayProtectionList,proto3" json:"replayProtectionList"`
-	SequenceCounterList       []SequenceCounter          `protobuf:"bytes,4,rep,name=sequenceCounterList,proto3" json:"sequenceCounterList"`
-	ConsensusGuardianSetIndex *ConsensusGuardianSetIndex `protobuf:"bytes,5,opt,name=consensusGuardianSetIndex,proto3" json:"consensusGuardianSetIndex,omitempty"`
-	GuardianValidatorList     []GuardianValidator        `protobuf:"bytes,6,rep,name=guardianValidatorList,proto3" json:"guardianValidatorList"`
-	AllowedAddresses          []ValidatorAllowedAddress  `protobuf:"bytes,7,rep,name=allowedAddresses,proto3" json:"allowedAddresses"`
+	GuardianSetList           []GuardianSet                          `protobuf:"bytes,1,rep,name=guardianSetList,proto3" json:"guardianSetList"`
+	Config                    *Config                                `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
+	ReplayProtectionList      []ReplayProtection                     `protobuf:"bytes,3,rep,name=replayProtectionList,proto3" json:"replayProtectionList"`
+	SequenceCounterList       []SequenceCounter                      `protobuf:"bytes,4,rep,name=sequenceCounterList,proto3" json:"sequenceCounterList"`
+	ConsensusGuardianSetIndex *ConsensusGuardianSetIndex             `protobuf:"bytes,5,opt,name=consensusGuardianSetIndex,proto3" json:"consensusGuardianSetIndex,omitempty"`
+	GuardianValidatorList     []GuardianValidator                    `protobuf:"bytes,6,rep,name=guardianValidatorList,proto3" json:"guardianValidatorList"`
+	AllowedAddresses          []ValidatorAllowedAddress              `protobuf:"bytes,7,rep,name=allowedAddresses,proto3" json:"allowedAddresses"`
+	WasmInstantiateAllowlist  []WasmInstantiateAllowedContractCodeId `protobuf:"bytes,8,rep,name=wasmInstantiateAllowlist,proto3" json:"wasmInstantiateAllowlist"`
 }
 
 func (m *GenesisState) Reset()         { *m = GenesisState{} }
@@ -116,6 +117,13 @@ func (m *GenesisState) GetAllowedAddresses() []ValidatorAllowedAddress {
 	return nil
 }
 
+func (m *GenesisState) GetWasmInstantiateAllowlist() []WasmInstantiateAllowedContractCodeId {
+	if m != nil {
+		return m.WasmInstantiateAllowlist
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*GenesisState)(nil), "wormhole_foundation.wormchain.wormhole.GenesisState")
 }
@@ -123,35 +131,38 @@ func init() {
 func init() { proto.RegisterFile("wormhole/genesis.proto", fileDescriptor_9a7ced3fe0304831) }
 
 var fileDescriptor_9a7ced3fe0304831 = []byte{
-	// 447 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x4f, 0x6b, 0xd4, 0x40,
-	0x18, 0xc6, 0x13, 0x5b, 0x23, 0x4c, 0x05, 0x65, 0x6c, 0x35, 0xf6, 0x90, 0x2e, 0x1e, 0xa4, 0x20,
-	0x26, 0xd0, 0x1e, 0xb4, 0x27, 0xd9, 0x16, 0x2c, 0x82, 0x07, 0x49, 0xc0, 0x83, 0x97, 0x30, 0x4d,
-	0xde, 0x66, 0x07, 0xd2, 0x99, 0x6d, 0x66, 0x42, 0xbb, 0x27, 0x3f, 0x80, 0x17, 0x3f, 0xd6, 0x1e,
-	0xf7, 0xe8, 0x49, 0x64, 0xf7, 0x8b, 0x48, 0x66, 0x26, 0xb3, 0x7f, 0x8c, 0x90, 0xbd, 0x0d, 0xcf,
-	0xbc, 0xef, 0xef, 0x99, 0xf7, 0x79, 0x13, 0xf4, 0xfc, 0x8e, 0x57, 0x37, 0x23, 0x5e, 0x42, 0x54,
-	0x00, 0x03, 0x41, 0x45, 0x38, 0xae, 0xb8, 0xe4, 0xf8, 0x75, 0xab, 0xa7, 0xd7, 0xbc, 0x66, 0x39,
-	0x91, 0x94, 0xb3, 0xb0, 0xd1, 0xb2, 0x11, 0xa1, 0xfa, 0xd4, 0xdc, 0x1e, 0xbe, 0x58, 0xf6, 0xd7,
-	0xa4, 0xca, 0x29, 0x61, 0x1a, 0x70, 0x78, 0x60, 0x2f, 0x32, 0xce, 0xae, 0x69, 0x61, 0xe4, 0x81,
-	0x95, 0x2b, 0x18, 0x97, 0x64, 0x92, 0x36, 0x32, 0x64, 0x0a, 0xaf, 0x2b, 0x8e, 0x6c, 0x85, 0x80,
-	0xdb, 0x1a, 0x58, 0x06, 0x69, 0xc6, 0x6b, 0x26, 0xa1, 0x32, 0x05, 0x6f, 0x56, 0xc9, 0x02, 0x98,
-	0xa8, 0x45, 0xda, 0x9a, 0xa7, 0x02, 0x64, 0x4a, 0x59, 0x0e, 0xf7, 0xa6, 0x78, 0xbf, 0xe0, 0x05,
-	0x57, 0xc7, 0xa8, 0x39, 0x69, 0xf5, 0xd5, 0x0f, 0x0f, 0x3d, 0xbe, 0xd4, 0xf3, 0x26, 0x92, 0x48,
-	0xc0, 0x19, 0x7a, 0xd2, 0x22, 0x12, 0x90, 0x9f, 0xa9, 0x90, 0xbe, 0x3b, 0xd8, 0x39, 0xde, 0x3b,
-	0x39, 0x0d, 0xfb, 0x05, 0x11, 0x5e, 0x2e, 0xdb, 0xcf, 0x77, 0xa7, 0xbf, 0x8f, 0x9c, 0x78, 0x93,
-	0x88, 0x3f, 0x22, 0x4f, 0x67, 0xe1, 0x3f, 0x18, 0xb8, 0xc7, 0x7b, 0x27, 0x61, 0x5f, 0xf6, 0x85,
-	0xea, 0x8a, 0x4d, 0x37, 0xae, 0xd0, 0xbe, 0x0e, 0xef, 0x8b, 0xcd, 0x4e, 0xbd, 0x78, 0x47, 0xbd,
-	0xf8, 0x7d, 0x5f, 0x6a, 0xbc, 0xc1, 0x30, 0xcf, 0xee, 0x64, 0x63, 0x8e, 0x9e, 0xb5, 0xeb, 0xb8,
-	0xd0, 0xdb, 0x50, 0x96, 0xbb, 0xca, 0xf2, 0x5d, 0x5f, 0xcb, 0x64, 0x1d, 0x61, 0x1c, 0xbb, 0xc8,
-	0xf8, 0x3b, 0x7a, 0x69, 0xd7, 0xbb, 0x92, 0xed, 0xa7, 0x66, 0xb7, 0xfe, 0x43, 0x95, 0xdf, 0x70,
-	0x8b, 0xfc, 0xba, 0x41, 0xf1, 0xff, 0x3d, 0x70, 0x8d, 0x0e, 0xda, 0x05, 0x7e, 0x25, 0x25, 0xcd,
-	0x89, 0xe4, 0x7a, 0x66, 0x4f, 0xcd, 0x7c, 0xb6, 0xed, 0x87, 0x61, 0x21, 0x66, 0xea, 0x6e, 0x3a,
-	0xbe, 0x45, 0x4f, 0x49, 0x59, 0xf2, 0x3b, 0xc8, 0x87, 0x79, 0x5e, 0x81, 0x10, 0x20, 0xfc, 0x47,
-	0xca, 0xf1, 0x43, 0x5f, 0x47, 0x0b, 0x1c, 0xae, 0x81, 0x8c, 0xef, 0x3f, 0xf8, 0xf3, 0x64, 0x3a,
-	0x0f, 0xdc, 0xd9, 0x3c, 0x70, 0xff, 0xcc, 0x03, 0xf7, 0xe7, 0x22, 0x70, 0x66, 0x8b, 0xc0, 0xf9,
-	0xb5, 0x08, 0x9c, 0x6f, 0x67, 0x05, 0x95, 0xa3, 0xfa, 0x2a, 0xcc, 0xf8, 0x4d, 0xd4, 0xe2, 0xdf,
-	0x2e, 0xcd, 0x23, 0x6b, 0x1e, 0xdd, 0xdb, 0xfb, 0x48, 0x4e, 0xc6, 0x20, 0xae, 0x3c, 0xf5, 0xa7,
-	0x9d, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x77, 0xb5, 0xdb, 0x2c, 0x61, 0x04, 0x00, 0x00,
+	// 492 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x4d, 0x6b, 0xd4, 0x40,
+	0x18, 0xc7, 0x37, 0xb6, 0x6e, 0x65, 0x2a, 0x28, 0x63, 0xab, 0xb1, 0x87, 0x74, 0xf1, 0x20, 0x05,
+	0x31, 0x81, 0xf6, 0xa0, 0x3d, 0xc9, 0x76, 0xc1, 0xb2, 0xd0, 0x83, 0x6c, 0x40, 0xc1, 0x4b, 0x98,
+	0x66, 0x9e, 0x66, 0x07, 0xb2, 0x33, 0xdb, 0xcc, 0x84, 0x6d, 0x4f, 0x7e, 0x03, 0xf1, 0x03, 0xf8,
+	0x81, 0x7a, 0xec, 0xd1, 0x93, 0xc8, 0xee, 0x17, 0x91, 0xcc, 0x4c, 0x66, 0xfb, 0x92, 0x42, 0xf6,
+	0x36, 0x3c, 0x2f, 0xbf, 0xff, 0xf3, 0xfc, 0x9f, 0x04, 0xbd, 0x9c, 0x89, 0x62, 0x32, 0x16, 0x39,
+	0x44, 0x19, 0x70, 0x90, 0x4c, 0x86, 0xd3, 0x42, 0x28, 0x81, 0xdf, 0xd6, 0xf1, 0xe4, 0x4c, 0x94,
+	0x9c, 0x12, 0xc5, 0x04, 0x0f, 0xab, 0x58, 0x3a, 0x26, 0xcc, 0xbc, 0xaa, 0xec, 0xce, 0xab, 0x65,
+	0x7f, 0x49, 0x0a, 0xca, 0x08, 0x37, 0x80, 0x9d, 0x6d, 0x97, 0x48, 0x05, 0x3f, 0x63, 0x99, 0x0d,
+	0xf7, 0x5c, 0xb8, 0x80, 0x69, 0x4e, 0x2e, 0x93, 0x2a, 0x0c, 0xa9, 0xc6, 0x9b, 0x8a, 0x5d, 0x57,
+	0x21, 0xe1, 0xbc, 0x04, 0x9e, 0x42, 0x92, 0x8a, 0x92, 0x2b, 0x28, 0x6c, 0xc1, 0xbb, 0x9b, 0x64,
+	0x09, 0x5c, 0x96, 0x32, 0xa9, 0xc5, 0x13, 0x09, 0x2a, 0x61, 0x9c, 0xc2, 0x85, 0x2d, 0xde, 0xca,
+	0x44, 0x26, 0xf4, 0x33, 0xaa, 0x5e, 0x26, 0xfa, 0xe6, 0xf7, 0x06, 0x7a, 0x7a, 0x6c, 0xf6, 0x8d,
+	0x15, 0x51, 0x80, 0x53, 0xf4, 0xac, 0x46, 0xc4, 0xa0, 0x4e, 0x98, 0x54, 0xbe, 0xd7, 0x5b, 0xdb,
+	0xdb, 0xdc, 0x3f, 0x08, 0xdb, 0x19, 0x11, 0x1e, 0x2f, 0xdb, 0x8f, 0xd6, 0xaf, 0xfe, 0xee, 0x76,
+	0x46, 0x77, 0x89, 0xf8, 0x33, 0xea, 0x1a, 0x2f, 0xfc, 0x47, 0x3d, 0x6f, 0x6f, 0x73, 0x3f, 0x6c,
+	0xcb, 0x1e, 0xe8, 0xae, 0x91, 0xed, 0xc6, 0x05, 0xda, 0x32, 0xe6, 0x7d, 0x71, 0xde, 0xe9, 0x89,
+	0xd7, 0xf4, 0xc4, 0x1f, 0xdb, 0x52, 0x47, 0x77, 0x18, 0x76, 0xec, 0x46, 0x36, 0x16, 0xe8, 0x45,
+	0x7d, 0x8e, 0x81, 0xb9, 0x86, 0x96, 0x5c, 0xd7, 0x92, 0x1f, 0xda, 0x4a, 0xc6, 0xb7, 0x11, 0x56,
+	0xb1, 0x89, 0x8c, 0x7f, 0xa0, 0xd7, 0xee, 0xbc, 0x37, 0xbc, 0x1d, 0x56, 0xb7, 0xf5, 0x1f, 0x6b,
+	0xff, 0xfa, 0x2b, 0xf8, 0xd7, 0x0c, 0x1a, 0x3d, 0xac, 0x81, 0x4b, 0xb4, 0x5d, 0x1f, 0xf0, 0x2b,
+	0xc9, 0x19, 0x25, 0x4a, 0x98, 0x9d, 0xbb, 0x7a, 0xe7, 0xc3, 0x55, 0x3f, 0x0c, 0x07, 0xb1, 0x5b,
+	0x37, 0xd3, 0xf1, 0x39, 0x7a, 0x4e, 0xf2, 0x5c, 0xcc, 0x80, 0xf6, 0x29, 0x2d, 0x40, 0x4a, 0x90,
+	0xfe, 0x86, 0x56, 0xfc, 0xd4, 0x56, 0xd1, 0x01, 0xfb, 0xb7, 0x40, 0x56, 0xf7, 0x1e, 0x1e, 0xff,
+	0xf4, 0x90, 0x3f, 0x23, 0x72, 0x32, 0xe4, 0x52, 0x11, 0xae, 0x18, 0x51, 0xa0, 0x3b, 0xf3, 0x6a,
+	0xdb, 0x27, 0x5a, 0xfb, 0xa4, 0xad, 0xf6, 0xb7, 0x06, 0x0e, 0xd0, 0x81, 0xe0, 0xaa, 0x20, 0xa9,
+	0x1a, 0x08, 0x0a, 0x43, 0x6a, 0x07, 0x79, 0x50, 0xf3, 0x28, 0xbe, 0x9a, 0x07, 0xde, 0xf5, 0x3c,
+	0xf0, 0xfe, 0xcd, 0x03, 0xef, 0xd7, 0x22, 0xe8, 0x5c, 0x2f, 0x82, 0xce, 0x9f, 0x45, 0xd0, 0xf9,
+	0x7e, 0x98, 0x31, 0x35, 0x2e, 0x4f, 0xc3, 0x54, 0x4c, 0xa2, 0x5a, 0xf3, 0xfd, 0x72, 0xa2, 0xc8,
+	0x4d, 0x14, 0x5d, 0xb8, 0x7c, 0xa4, 0x2e, 0xa7, 0x20, 0x4f, 0xbb, 0xfa, 0xd7, 0x3f, 0xf8, 0x1f,
+	0x00, 0x00, 0xff, 0xff, 0x95, 0x1f, 0x20, 0xcf, 0xf2, 0x04, 0x00, 0x00,
 }
 
 func (m *GenesisState) Marshal() (dAtA []byte, err error) {
@@ -174,6 +185,20 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.WasmInstantiateAllowlist) > 0 {
+		for iNdEx := len(m.WasmInstantiateAllowlist) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.WasmInstantiateAllowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintGenesis(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x42
+		}
+	}
 	if len(m.AllowedAddresses) > 0 {
 		for iNdEx := len(m.AllowedAddresses) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -326,6 +351,12 @@ func (m *GenesisState) Size() (n int) {
 			n += 1 + l + sovGenesis(uint64(l))
 		}
 	}
+	if len(m.WasmInstantiateAllowlist) > 0 {
+		for _, e := range m.WasmInstantiateAllowlist {
+			l = e.Size()
+			n += 1 + l + sovGenesis(uint64(l))
+		}
+	}
 	return n
 }
 
@@ -606,6 +637,40 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WasmInstantiateAllowlist", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenesis
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenesis
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.WasmInstantiateAllowlist = append(m.WasmInstantiateAllowlist, WasmInstantiateAllowedContractCodeId{})
+			if err := m.WasmInstantiateAllowlist[len(m.WasmInstantiateAllowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenesis(dAtA[iNdEx:])

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

@@ -243,39 +243,98 @@ func (m *ValidatorAllowedAddress) GetName() string {
 	return ""
 }
 
+type WasmInstantiateAllowedContractCodeId struct {
+	// bech32 address of the contract that can call wasm instantiate without a VAA
+	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
+	// reference to the stored WASM code that can be instantiated
+	CodeId uint64 `protobuf:"varint,2,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+}
+
+func (m *WasmInstantiateAllowedContractCodeId) Reset()         { *m = WasmInstantiateAllowedContractCodeId{} }
+func (m *WasmInstantiateAllowedContractCodeId) String() string { return proto.CompactTextString(m) }
+func (*WasmInstantiateAllowedContractCodeId) ProtoMessage()    {}
+func (*WasmInstantiateAllowedContractCodeId) Descriptor() ([]byte, []int) {
+	return fileDescriptor_95afcf26fc23dcb3, []int{4}
+}
+func (m *WasmInstantiateAllowedContractCodeId) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *WasmInstantiateAllowedContractCodeId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_WasmInstantiateAllowedContractCodeId.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *WasmInstantiateAllowedContractCodeId) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WasmInstantiateAllowedContractCodeId.Merge(m, src)
+}
+func (m *WasmInstantiateAllowedContractCodeId) XXX_Size() int {
+	return m.Size()
+}
+func (m *WasmInstantiateAllowedContractCodeId) XXX_DiscardUnknown() {
+	xxx_messageInfo_WasmInstantiateAllowedContractCodeId.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WasmInstantiateAllowedContractCodeId proto.InternalMessageInfo
+
+func (m *WasmInstantiateAllowedContractCodeId) GetContractAddress() string {
+	if m != nil {
+		return m.ContractAddress
+	}
+	return ""
+}
+
+func (m *WasmInstantiateAllowedContractCodeId) GetCodeId() uint64 {
+	if m != nil {
+		return m.CodeId
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*GuardianKey)(nil), "wormhole_foundation.wormchain.wormhole.GuardianKey")
 	proto.RegisterType((*GuardianValidator)(nil), "wormhole_foundation.wormchain.wormhole.GuardianValidator")
 	proto.RegisterType((*GuardianSet)(nil), "wormhole_foundation.wormchain.wormhole.GuardianSet")
 	proto.RegisterType((*ValidatorAllowedAddress)(nil), "wormhole_foundation.wormchain.wormhole.ValidatorAllowedAddress")
+	proto.RegisterType((*WasmInstantiateAllowedContractCodeId)(nil), "wormhole_foundation.wormchain.wormhole.WasmInstantiateAllowedContractCodeId")
 }
 
 func init() { proto.RegisterFile("wormhole/guardian.proto", fileDescriptor_95afcf26fc23dcb3) }
 
 var fileDescriptor_95afcf26fc23dcb3 = []byte{
-	// 350 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x51, 0x3f, 0x4f, 0xc2, 0x40,
-	0x1c, 0xe5, 0xa0, 0x9a, 0xf0, 0xe3, 0x8f, 0x70, 0x21, 0xa1, 0x71, 0x28, 0x4d, 0x63, 0x90, 0xc4,
-	0x48, 0x07, 0x27, 0xdd, 0x70, 0x71, 0x70, 0x2b, 0xc6, 0x41, 0x07, 0x72, 0x70, 0x67, 0xb9, 0x50,
-	0x7a, 0xa4, 0x2d, 0x42, 0x67, 0xbf, 0x80, 0x1f, 0xc1, 0x8f, 0xe3, 0xc8, 0xe8, 0x68, 0x60, 0xf1,
-	0x63, 0x98, 0xbb, 0xd2, 0x62, 0xdd, 0xde, 0xbd, 0xdf, 0x7b, 0xbf, 0xdf, 0xbb, 0x3c, 0x68, 0xaf,
-	0x44, 0x30, 0x9f, 0x0a, 0x8f, 0xd9, 0xee, 0x92, 0x04, 0x94, 0x13, 0xbf, 0xbf, 0x08, 0x44, 0x24,
-	0x70, 0x37, 0x1d, 0x8c, 0x5e, 0xc4, 0xd2, 0xa7, 0x24, 0xe2, 0xc2, 0xef, 0x4b, 0x6e, 0x32, 0x25,
-	0x3c, 0x41, 0x72, 0x7a, 0xda, 0x72, 0x85, 0x2b, 0x94, 0xc5, 0x96, 0x28, 0x71, 0x5b, 0x1d, 0xa8,
-	0xdc, 0xed, 0xf7, 0xdd, 0xb3, 0x18, 0x37, 0xa0, 0x34, 0x63, 0xb1, 0x8e, 0x4c, 0xd4, 0xab, 0x3a,
-	0x12, 0x5a, 0xcf, 0xd0, 0x4c, 0x05, 0x8f, 0xc4, 0xe3, 0x94, 0x44, 0x22, 0xc0, 0x26, 0x54, 0xdc,
-	0x83, 0x6b, 0x2f, 0xff, 0x4b, 0xe1, 0x33, 0xa8, 0xbd, 0xa6, 0xf2, 0x01, 0xa5, 0x81, 0x5e, 0x54,
-	0x9a, 0x3c, 0x69, 0xb1, 0xc3, 0xf5, 0x21, 0x8b, 0x70, 0x0b, 0x8e, 0xb8, 0x4f, 0xd9, 0x5a, 0x2d,
-	0xac, 0x39, 0xc9, 0x03, 0x63, 0xd0, 0x66, 0x2c, 0x0e, 0xf5, 0xa2, 0x59, 0xea, 0x55, 0x1d, 0x85,
-	0x71, 0x17, 0xea, 0x6c, 0xbd, 0xe0, 0x81, 0xfa, 0xed, 0x03, 0x9f, 0x33, 0xbd, 0x64, 0xa2, 0x9e,
-	0xe6, 0xfc, 0x63, 0x6f, 0xb4, 0x9f, 0x8f, 0x0e, 0xb2, 0xde, 0x10, 0xb4, 0xb3, 0xf0, 0x03, 0xcf,
-	0x13, 0x2b, 0x46, 0xe5, 0x7d, 0x16, 0x86, 0xf8, 0x02, 0x9a, 0x59, 0xa6, 0x11, 0x49, 0x48, 0x75,
-	0xbf, 0xec, 0x34, 0x72, 0x61, 0xa5, 0xf8, 0x1c, 0x4e, 0x48, 0x62, 0xcf, 0xa4, 0x45, 0x25, 0xad,
-	0x93, 0xfc, 0x56, 0x0c, 0x9a, 0x4f, 0xf6, 0xa9, 0xca, 0x8e, 0xc2, 0xb7, 0xc3, 0xcf, 0xad, 0x81,
-	0x36, 0x5b, 0x03, 0x7d, 0x6f, 0x0d, 0xf4, 0xbe, 0x33, 0x0a, 0x9b, 0x9d, 0x51, 0xf8, 0xda, 0x19,
-	0x85, 0xa7, 0x6b, 0x97, 0x47, 0xd3, 0xe5, 0xb8, 0x3f, 0x11, 0x73, 0x3b, 0xed, 0xeb, 0xf2, 0xd0,
-	0xa6, 0x9d, 0xb5, 0x69, 0xaf, 0xb3, 0xb9, 0x1d, 0xc5, 0x0b, 0x16, 0x8e, 0x8f, 0x55, 0x8d, 0x57,
-	0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x64, 0xbe, 0x7b, 0x3d, 0x1f, 0x02, 0x00, 0x00,
+	// 407 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x52, 0xcd, 0xae, 0xd2, 0x40,
+	0x18, 0x65, 0xa0, 0x5e, 0x73, 0xbf, 0x7b, 0x2f, 0x3f, 0x13, 0x12, 0x1a, 0x17, 0xa5, 0x69, 0x08,
+	0x62, 0x8c, 0x74, 0xe1, 0x4a, 0x77, 0xc8, 0xc2, 0x10, 0x77, 0xc5, 0x68, 0xa2, 0x0b, 0x32, 0x74,
+	0xc6, 0x32, 0xd2, 0xce, 0x90, 0x76, 0x10, 0xba, 0xf6, 0x05, 0x7c, 0x04, 0x1f, 0xc7, 0x25, 0x4b,
+	0x97, 0x06, 0x36, 0x3e, 0x86, 0xe9, 0xf4, 0x07, 0x61, 0x77, 0xe6, 0x7c, 0xe7, 0xfb, 0xce, 0x99,
+	0xe4, 0x40, 0x6f, 0x27, 0xe3, 0x68, 0x25, 0x43, 0xe6, 0x06, 0x5b, 0x12, 0x53, 0x4e, 0xc4, 0x78,
+	0x13, 0x4b, 0x25, 0xf1, 0xb0, 0x1c, 0x2c, 0xbe, 0xc8, 0xad, 0xa0, 0x44, 0x71, 0x29, 0xc6, 0x19,
+	0xe7, 0xaf, 0x08, 0xcf, 0x51, 0x36, 0x7d, 0xd2, 0x0d, 0x64, 0x20, 0xf5, 0x8a, 0x9b, 0xa1, 0x7c,
+	0xdb, 0xe9, 0xc3, 0xdd, 0xdb, 0xe2, 0xde, 0x3b, 0x96, 0xe2, 0x36, 0x34, 0xd6, 0x2c, 0x35, 0x91,
+	0x8d, 0x46, 0xf7, 0x5e, 0x06, 0x9d, 0xcf, 0xd0, 0x29, 0x05, 0x1f, 0x48, 0xc8, 0x29, 0x51, 0x32,
+	0xc6, 0x36, 0xdc, 0x05, 0xe7, 0xad, 0x42, 0xfe, 0x3f, 0x85, 0x07, 0xf0, 0xf0, 0xad, 0x94, 0x4f,
+	0x28, 0x8d, 0xcd, 0xba, 0xd6, 0x5c, 0x92, 0x0e, 0x3b, 0xbb, 0xcf, 0x99, 0xc2, 0x5d, 0x78, 0xc4,
+	0x05, 0x65, 0x7b, 0x7d, 0xf0, 0xc1, 0xcb, 0x1f, 0x18, 0x83, 0xb1, 0x66, 0x69, 0x62, 0xd6, 0xed,
+	0xc6, 0xe8, 0xde, 0xd3, 0x18, 0x0f, 0xa1, 0xc9, 0xf6, 0x1b, 0x1e, 0xeb, 0xdf, 0xbe, 0xe7, 0x11,
+	0x33, 0x1b, 0x36, 0x1a, 0x19, 0xde, 0x15, 0xfb, 0xda, 0xf8, 0xfb, 0xb3, 0x8f, 0x9c, 0xef, 0x08,
+	0x7a, 0x55, 0xf8, 0x49, 0x18, 0xca, 0x1d, 0xa3, 0x99, 0x3f, 0x4b, 0x12, 0xfc, 0x1c, 0x3a, 0x55,
+	0xa6, 0x05, 0xc9, 0x49, 0xed, 0x7f, 0xeb, 0xb5, 0x2f, 0xc2, 0x66, 0xe2, 0xa7, 0xd0, 0x22, 0xf9,
+	0x7a, 0x25, 0xad, 0x6b, 0x69, 0x93, 0x5c, 0x5e, 0xc5, 0x60, 0x08, 0x52, 0xa4, 0xba, 0xf5, 0x34,
+	0x76, 0xbe, 0xc2, 0xe0, 0x23, 0x49, 0xa2, 0x99, 0x48, 0x14, 0x11, 0x8a, 0x13, 0xc5, 0x8a, 0x28,
+	0x53, 0x29, 0x54, 0x4c, 0x7c, 0x35, 0x95, 0x94, 0xcd, 0x28, 0x7e, 0x06, 0x6d, 0xbf, 0x60, 0xae,
+	0x02, 0xb5, 0x4a, 0xbe, 0xb4, 0xe9, 0xc1, 0x63, 0x5f, 0x52, 0xb6, 0xe0, 0x54, 0xe7, 0x30, 0xbc,
+	0x1b, 0x5f, 0xdf, 0x78, 0x33, 0xff, 0x75, 0xb4, 0xd0, 0xe1, 0x68, 0xa1, 0x3f, 0x47, 0x0b, 0xfd,
+	0x38, 0x59, 0xb5, 0xc3, 0xc9, 0xaa, 0xfd, 0x3e, 0x59, 0xb5, 0x4f, 0xaf, 0x02, 0xae, 0x56, 0xdb,
+	0xe5, 0xd8, 0x97, 0x91, 0x5b, 0x76, 0xe3, 0xc5, 0xb9, 0x39, 0x6e, 0xd5, 0x1c, 0x77, 0x5f, 0xcd,
+	0x5d, 0x95, 0x6e, 0x58, 0xb2, 0xbc, 0xd1, 0x95, 0x79, 0xf9, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xd2,
+	0xc4, 0x55, 0x34, 0x8b, 0x02, 0x00, 0x00,
 }
 
 func (this *GuardianSet) Equal(that interface{}) bool {
@@ -466,6 +525,41 @@ func (m *ValidatorAllowedAddress) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *WasmInstantiateAllowedContractCodeId) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *WasmInstantiateAllowedContractCodeId) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WasmInstantiateAllowedContractCodeId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.CodeId != 0 {
+		i = encodeVarintGuardian(dAtA, i, uint64(m.CodeId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.ContractAddress) > 0 {
+		i -= len(m.ContractAddress)
+		copy(dAtA[i:], m.ContractAddress)
+		i = encodeVarintGuardian(dAtA, i, uint64(len(m.ContractAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintGuardian(dAtA []byte, offset int, v uint64) int {
 	offset -= sovGuardian(v)
 	base := offset
@@ -549,6 +643,22 @@ func (m *ValidatorAllowedAddress) Size() (n int) {
 	return n
 }
 
+func (m *WasmInstantiateAllowedContractCodeId) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ContractAddress)
+	if l > 0 {
+		n += 1 + l + sovGuardian(uint64(l))
+	}
+	if m.CodeId != 0 {
+		n += 1 + sovGuardian(uint64(m.CodeId))
+	}
+	return n
+}
+
 func sovGuardian(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1023,6 +1133,107 @@ func (m *ValidatorAllowedAddress) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *WasmInstantiateAllowedContractCodeId) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGuardian
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: WasmInstantiateAllowedContractCodeId: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: WasmInstantiateAllowedContractCodeId: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuardian
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGuardian
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGuardian
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ContractAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+			}
+			m.CodeId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuardian
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CodeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGuardian(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGuardian
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipGuardian(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

wormchain/x/wormhole/types/keys.go

@@ -35,5 +35,6 @@ const (
 )
 
 const (
-	ValidatorAllowlistKey = "VAK"
+	ValidatorAllowlistKey       = "VAK"
+	WasmInstantiateAllowlistKey = "WasmInstiantiateAllowlist"
 )

wormchain/x/wormhole/types/message_wasm_instantiate_allowlist.go

@@ -0,0 +1,79 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var _ sdk.Msg = &MsgAddWasmInstantiateAllowlist{}
+var _ sdk.Msg = &MsgDeleteWasmInstantiateAllowlist{}
+
+func (msg *MsgAddWasmInstantiateAllowlist) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgAddWasmInstantiateAllowlist) Type() string {
+	return "AddWasmInstantiateAllowlist"
+}
+
+func (msg *MsgAddWasmInstantiateAllowlist) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{signer}
+}
+
+func (msg *MsgAddWasmInstantiateAllowlist) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgAddWasmInstantiateAllowlist) 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
+}
+
+func (msg *MsgDeleteWasmInstantiateAllowlist) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgDeleteWasmInstantiateAllowlist) Type() string {
+	return "DeleteWasmInstantiateAllowlist"
+}
+
+func (msg *MsgDeleteWasmInstantiateAllowlist) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{signer}
+}
+
+func (msg *MsgDeleteWasmInstantiateAllowlist) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgDeleteWasmInstantiateAllowlist) 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

@@ -1222,6 +1222,105 @@ func (m *QueryLatestGuardianSetIndexResponse) GetLatestGuardianSetIndex() uint32
 	return 0
 }
 
+type QueryAllWasmInstantiateAllowlist struct {
+	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (m *QueryAllWasmInstantiateAllowlist) Reset()         { *m = QueryAllWasmInstantiateAllowlist{} }
+func (m *QueryAllWasmInstantiateAllowlist) String() string { return proto.CompactTextString(m) }
+func (*QueryAllWasmInstantiateAllowlist) ProtoMessage()    {}
+func (*QueryAllWasmInstantiateAllowlist) Descriptor() ([]byte, []int) {
+	return fileDescriptor_273185ecc792fa38, []int{26}
+}
+func (m *QueryAllWasmInstantiateAllowlist) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryAllWasmInstantiateAllowlist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryAllWasmInstantiateAllowlist.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryAllWasmInstantiateAllowlist) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryAllWasmInstantiateAllowlist.Merge(m, src)
+}
+func (m *QueryAllWasmInstantiateAllowlist) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryAllWasmInstantiateAllowlist) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryAllWasmInstantiateAllowlist.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryAllWasmInstantiateAllowlist proto.InternalMessageInfo
+
+func (m *QueryAllWasmInstantiateAllowlist) GetPagination() *query.PageRequest {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
+// all allowlisted entries by all validators
+type QueryAllWasmInstantiateAllowlistResponse struct {
+	Allowlist  []WasmInstantiateAllowedContractCodeId `protobuf:"bytes,1,rep,name=allowlist,proto3" json:"allowlist"`
+	Pagination *query.PageResponse                    `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) Reset() {
+	*m = QueryAllWasmInstantiateAllowlistResponse{}
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryAllWasmInstantiateAllowlistResponse) ProtoMessage()    {}
+func (*QueryAllWasmInstantiateAllowlistResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_273185ecc792fa38, []int{27}
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryAllWasmInstantiateAllowlistResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryAllWasmInstantiateAllowlistResponse.Merge(m, src)
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryAllWasmInstantiateAllowlistResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryAllWasmInstantiateAllowlistResponse proto.InternalMessageInfo
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) GetAllowlist() []WasmInstantiateAllowedContractCodeId {
+	if m != nil {
+		return m.Allowlist
+	}
+	return nil
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) GetPagination() *query.PageResponse {
+	if m != nil {
+		return m.Pagination
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*QueryAllValidatorAllowlist)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllValidatorAllowlist")
 	proto.RegisterType((*QueryAllValidatorAllowlistResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllValidatorAllowlistResponse")
@@ -1249,93 +1348,100 @@ func init() {
 	proto.RegisterType((*QueryAllGuardianValidatorResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllGuardianValidatorResponse")
 	proto.RegisterType((*QueryLatestGuardianSetIndexRequest)(nil), "wormhole_foundation.wormchain.wormhole.QueryLatestGuardianSetIndexRequest")
 	proto.RegisterType((*QueryLatestGuardianSetIndexResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryLatestGuardianSetIndexResponse")
+	proto.RegisterType((*QueryAllWasmInstantiateAllowlist)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllWasmInstantiateAllowlist")
+	proto.RegisterType((*QueryAllWasmInstantiateAllowlistResponse)(nil), "wormhole_foundation.wormchain.wormhole.QueryAllWasmInstantiateAllowlistResponse")
 }
 
 func init() { proto.RegisterFile("wormhole/query.proto", fileDescriptor_273185ecc792fa38) }
 
 var fileDescriptor_273185ecc792fa38 = []byte{
-	// 1281 bytes of a gzipped FileDescriptorProto
+	// 1371 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x99, 0x4f, 0x6f, 0xdc, 0xc4,
-	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, 0xbb, 0x25, 0xbb, 0x49, 0x83,
-	0x94, 0x6e, 0x24, 0x0e, 0xa0, 0x6a, 0xe5, 0xec, 0x4e, 0x1c, 0x57, 0x8e, 0xbd, 0x5d, 0x7b, 0xdb,
-	0x86, 0x28, 0x17, 0x24, 0x2e, 0x1c, 0x22, 0x04, 0x2f, 0x85, 0x17, 0xc0, 0x81, 0x4b, 0x0f, 0x1c,
-	0x2a, 0x55, 0xe2, 0x8f, 0x2a, 0x21, 0x94, 0x54, 0x1c, 0xe0, 0xc0, 0x0d, 0x21, 0xc4, 0x01, 0x79,
-	0xfc, 0xd8, 0xeb, 0xf5, 0xda, 0xc6, 0xf6, 0x3a, 0xb7, 0xed, 0xcc, 0xf8, 0x3b, 0xcf, 0xe7, 0x99,
-	0x67, 0x66, 0xbe, 0x99, 0xe2, 0xc9, 0x87, 0x7a, 0x67, 0x6f, 0x57, 0x57, 0xa9, 0x78, 0xbf, 0x4b,
-	0x3b, 0xfb, 0x42, 0xbb, 0xa3, 0x9b, 0x3a, 0xb9, 0xe4, 0xb4, 0x36, 0x76, 0xf4, 0xae, 0xd6, 0x92,
-	0x4c, 0x45, 0xd7, 0x04, 0xab, 0xad, 0xb9, 0x2b, 0x29, 0xf6, 0x2f, 0xab, 0x97, 0x7b, 0x45, 0xd6,
-	0x75, 0x59, 0xa5, 0xa2, 0xd4, 0x56, 0x44, 0x49, 0xd3, 0x74, 0x93, 0x8d, 0x34, 0x6c, 0x15, 0xee,
-	0x72, 0x53, 0x37, 0xf6, 0x74, 0x43, 0xdc, 0x96, 0x0c, 0x90, 0x17, 0x1f, 0xcc, 0x6d, 0x53, 0x53,
-	0x9a, 0x13, 0xdb, 0x92, 0xac, 0x68, 0xb6, 0xac, 0x3d, 0x76, 0xda, 0x8d, 0x43, 0xee, 0x4a, 0x9d,
-	0x96, 0x22, 0x39, 0x1d, 0x17, 0xdc, 0x8e, 0xa6, 0xae, 0xed, 0x28, 0x32, 0x34, 0x17, 0xdd, 0xe6,
-	0x0e, 0x6d, 0xab, 0xd2, 0x7e, 0xc3, 0x6a, 0xa6, 0x4d, 0x8f, 0xe2, 0x8c, 0x3b, 0xc2, 0xa0, 0xf7,
-	0xbb, 0x54, 0x6b, 0xd2, 0x46, 0x53, 0xef, 0x6a, 0x26, 0xed, 0xc0, 0x80, 0x2b, 0x5e, 0x65, 0x83,
-	0x6a, 0x46, 0xd7, 0x68, 0x38, 0x93, 0x37, 0x0c, 0x6a, 0x36, 0x14, 0xad, 0x45, 0x1f, 0xc1, 0xe0,
-	0x49, 0x59, 0x97, 0x75, 0xf6, 0x53, 0xb4, 0x7e, 0xd9, 0xad, 0x7c, 0x0b, 0x73, 0x77, 0x2c, 0xae,
-	0x92, 0xaa, 0x7e, 0x28, 0xa9, 0x4a, 0x4b, 0x32, 0xf5, 0x4e, 0x49, 0x55, 0xf5, 0x87, 0xaa, 0x62,
-	0x98, 0x64, 0x15, 0xe3, 0x1e, 0xe7, 0x45, 0x54, 0x44, 0xb3, 0x63, 0xf3, 0x97, 0x04, 0x3b, 0x29,
-	0x82, 0x95, 0x14, 0xc1, 0xce, 0x39, 0x24, 0x45, 0xd8, 0x94, 0x64, 0x5a, 0xb7, 0x62, 0x35, 0xcc,
-	0xba, 0xe7, 0x4b, 0xfe, 0x3b, 0x84, 0xf9, 0xf0, 0x69, 0xea, 0xd4, 0x68, 0x5b, 0xf1, 0x93, 0xbb,
-	0x78, 0x54, 0x72, 0x1a, 0x2f, 0xa2, 0x62, 0x7e, 0x76, 0x6c, 0x7e, 0x45, 0x88, 0xb7, 0x90, 0x42,
-	0xbf, 0x2c, 0x6d, 0x95, 0x5a, 0xad, 0x0e, 0x35, 0x8c, 0x7a, 0x4f, 0x91, 0x54, 0xfb, 0x68, 0x72,
-	0x8c, 0xe6, 0x8d, 0xff, 0xa4, 0xb1, 0x63, 0xeb, 0xc3, 0x39, 0x42, 0x78, 0x9a, 0xe1, 0x04, 0xa4,
-	0xec, 0x0a, 0x9e, 0x78, 0xe0, 0xb4, 0x36, 0x24, 0x3b, 0x08, 0x96, 0xb9, 0xd1, 0xfa, 0xb8, 0xdb,
-	0x01, 0xc1, 0xf9, 0xf2, 0x9b, 0x4b, 0x9d, 0xdf, 0x3f, 0x11, 0x9e, 0x09, 0x09, 0xc8, 0x4d, 0x6e,
-	0xa2, 0xc0, 0xfa, 0x56, 0x22, 0x77, 0xca, 0x2b, 0x91, 0x4f, 0xbf, 0x12, 0xf3, 0x50, 0xbe, 0x55,
-	0x6a, 0x56, 0xa1, 0xf0, 0xb7, 0xa8, 0x09, 0x29, 0x22, 0x93, 0xf8, 0x0c, 0xdb, 0x01, 0x0c, 0xf3,
-	0xff, 0x75, 0xfb, 0x1f, 0xfc, 0x27, 0xf8, 0xe5, 0xc0, 0x6f, 0x20, 0x4f, 0x1f, 0xe3, 0x31, 0x4f,
-	0x33, 0x14, 0xfd, 0x42, 0x5c, 0x78, 0xcf, 0xa7, 0xe5, 0xff, 0x3d, 0xfe, 0x79, 0x66, 0xa4, 0xee,
-	0x55, 0xf3, 0x6e, 0xb7, 0x80, 0x78, 0xb3, 0xda, 0x6e, 0xdf, 0x22, 0x40, 0xf4, 0x4f, 0x13, 0x86,
-	0x98, 0xcf, 0x0e, 0x31, 0xbb, 0x5d, 0x36, 0x8d, 0x2f, 0x38, 0xeb, 0x54, 0x61, 0x07, 0x27, 0xa0,
-	0xf2, 0x3b, 0x78, 0xca, 0xdf, 0x01, 0x60, 0x1b, 0xf8, 0xac, 0xdd, 0x02, 0xc9, 0x13, 0xe2, 0x32,
-	0xd9, 0x5f, 0x01, 0x0e, 0x68, 0xf0, 0x4b, 0xb0, 0xa9, 0xaa, 0x56, 0xea, 0xac, 0x23, 0x7a, 0xd3,
-	0x3d, 0xa1, 0x03, 0x2b, 0x6c, 0xd4, 0xa9, 0xb0, 0x23, 0x84, 0x8b, 0xe1, 0x5f, 0x42, 0xac, 0xf7,
-	0xf0, 0x78, 0xc7, 0xd7, 0x07, 0x51, 0x5f, 0x8d, 0x1b, 0xb5, 0x5f, 0x1b, 0xe2, 0x1f, 0xd0, 0xe5,
-	0x15, 0x20, 0x29, 0xa9, 0x6a, 0x18, 0x49, 0x56, 0xb5, 0xf7, 0x83, 0xc3, 0x1e, 0x38, 0x57, 0x24,
-	0x7b, 0xfe, 0x34, 0xd8, 0xb3, 0xab, 0xc7, 0x45, 0x5c, 0x70, 0x16, 0x75, 0x0b, 0xee, 0xe3, 0x8a,
-	0x7d, 0x1d, 0x47, 0x57, 0xc3, 0xe7, 0xa8, 0x57, 0x47, 0x03, 0x1f, 0x42, 0x42, 0x64, 0x7c, 0xde,
-	0xe8, 0xef, 0x82, 0x25, 0x58, 0x8a, 0x9b, 0x0f, 0x9f, 0x32, 0xa4, 0xc3, 0xaf, 0xca, 0xef, 0x02,
-	0x44, 0x49, 0x55, 0x43, 0x20, 0xb2, 0x2a, 0x84, 0xa7, 0xa8, 0x57, 0x74, 0x89, 0xb0, 0xf3, 0xd9,
-	0x63, 0x67, 0x57, 0x04, 0x97, 0xf1, 0xac, 0xe7, 0xec, 0xb1, 0x3d, 0x97, 0xe7, 0xf4, 0x5b, 0xb3,
-	0x56, 0xdc, 0x39, 0xa7, 0xbe, 0x46, 0xf8, 0xcd, 0x18, 0x83, 0x21, 0x17, 0x9f, 0x21, 0xfc, 0x52,
-	0xe8, 0x28, 0x58, 0x87, 0x52, 0x82, 0xf3, 0x2c, 0x58, 0x08, 0x12, 0x14, 0x3e, 0x13, 0x7f, 0xab,
-	0x77, 0x76, 0x39, 0x7d, 0xee, 0x8d, 0xee, 0xd4, 0x48, 0x11, 0x8f, 0x39, 0x3e, 0xf3, 0x36, 0xdd,
-	0x67, 0xc1, 0x9d, 0xab, 0x7b, 0x9b, 0xf8, 0x2f, 0x11, 0x7e, 0x35, 0x42, 0x06, 0x98, 0xf7, 0xf0,
-	0x84, 0xec, 0xef, 0x04, 0xd4, 0xe5, 0xa4, 0xd7, 0x91, 0x2b, 0x00, 0x88, 0x83, 0xca, 0xfc, 0xbd,
-	0xde, 0xd1, 0x14, 0x8a, 0x96, 0x55, 0xf9, 0x3f, 0x73, 0x12, 0x10, 0x3c, 0x59, 0x74, 0x02, 0xf2,
-	0xa7, 0x93, 0x80, 0xec, 0xb6, 0xc1, 0xeb, 0xe0, 0xe7, 0x37, 0x24, 0x93, 0x1a, 0x66, 0xd8, 0x06,
-	0xb8, 0x8b, 0x5f, 0x8b, 0x1c, 0x05, 0x49, 0x58, 0xc4, 0x53, 0x6a, 0xe0, 0x08, 0xf0, 0x6d, 0x21,
-	0xbd, 0xf3, 0x7f, 0x4d, 0xe3, 0x33, 0x4c, 0x9f, 0x3c, 0x43, 0x7d, 0x8e, 0x86, 0x94, 0xe3, 0xe6,
-	0x2e, 0xdc, 0x3c, 0x72, 0x95, 0xa1, 0x34, 0x6c, 0x34, 0xbe, 0xf2, 0xe9, 0xd3, 0xe7, 0x5f, 0xe5,
-	0x6e, 0x90, 0xeb, 0x62, 0x80, 0x98, 0xe8, 0x8a, 0x89, 0x03, 0x7f, 0x3b, 0x6e, 0x51, 0x53, 0x3c,
-	0x60, 0xf7, 0xc7, 0x21, 0xf9, 0x1e, 0xe1, 0x17, 0x3c, 0xe2, 0x25, 0x55, 0x4d, 0x08, 0x18, 0xe8,
-	0x36, 0x13, 0x02, 0x06, 0x5b, 0x49, 0xfe, 0x3a, 0x03, 0x7c, 0x87, 0x2c, 0xa4, 0x00, 0x24, 0xdf,
-	0x20, 0xc7, 0xaf, 0x91, 0x1b, 0x49, 0xb3, 0xdd, 0x67, 0x09, 0xb9, 0xf7, 0xd2, 0x7e, 0x0e, 0x18,
-	0x8b, 0x0c, 0xe3, 0x6d, 0x22, 0xc4, 0xc5, 0xb0, 0xff, 0x94, 0x27, 0x7f, 0x20, 0x3c, 0x5e, 0x1f,
-	0x70, 0x1c, 0x49, 0x83, 0x09, 0xf1, 0x64, 0x5c, 0x6d, 0x78, 0x21, 0xe0, 0xab, 0x31, 0xbe, 0x32,
-	0xb9, 0x19, 0x97, 0xcf, 0x6f, 0xa3, 0xdc, 0x62, 0xfc, 0x0d, 0xe1, 0x17, 0xfd, 0xd3, 0x58, 0x15,
-	0x59, 0x4d, 0x5a, 0x4d, 0xd9, 0x40, 0x47, 0xb8, 0x4c, 0xfe, 0x26, 0x83, 0xbe, 0x46, 0xae, 0xa6,
-	0x85, 0x26, 0xbf, 0x23, 0x7c, 0xde, 0xe7, 0x30, 0xc8, 0x6a, 0xd2, 0x45, 0x09, 0xf6, 0x59, 0x5c,
-	0x75, 0x68, 0x1d, 0xc0, 0xac, 0x32, 0xcc, 0x12, 0x59, 0x89, 0x8b, 0xe9, 0x33, 0x47, 0xee, 0xd2,
-	0xfe, 0x8a, 0x30, 0xf1, 0x4d, 0x62, 0xad, 0xec, 0x6a, 0xd2, 0x05, 0xc9, 0x04, 0x38, 0xdc, 0x35,
-	0xf2, 0x2b, 0x0c, 0x78, 0x99, 0x2c, 0xa5, 0x04, 0x26, 0x47, 0xb9, 0x08, 0xab, 0x45, 0x36, 0x53,
-	0x9c, 0x25, 0x91, 0x46, 0x90, 0xbb, 0x93, 0xa1, 0x22, 0xe4, 0x60, 0x83, 0xe5, 0x60, 0x95, 0xdc,
-	0x4a, 0x70, 0x60, 0x85, 0xbe, 0x10, 0x92, 0xbf, 0x11, 0x9e, 0x18, 0xb0, 0x11, 0xa4, 0x96, 0xf6,
-	0x06, 0xf4, 0x9b, 0x2a, 0x6e, 0x2d, 0x03, 0x25, 0x00, 0xdf, 0x64, 0xe0, 0xeb, 0xa4, 0x96, 0xf4,
-	0xc2, 0x69, 0xb8, 0x8f, 0x5c, 0xe2, 0x81, 0xc7, 0xa9, 0x1e, 0x5a, 0x67, 0xf8, 0xe4, 0xc0, 0x7c,
-	0x56, 0xe1, 0xd7, 0xd2, 0x5e, 0x90, 0x43, 0xf2, 0x47, 0x39, 0x46, 0xbe, 0xcc, 0xf8, 0xdf, 0x25,
-	0xd7, 0xd2, 0xf3, 0x93, 0x7f, 0x10, 0x9e, 0x0a, 0xf6, 0x64, 0x64, 0x3d, 0x51, 0xa4, 0x91, 0xf6,
-	0x8f, 0xbb, 0x9d, 0x89, 0x16, 0x70, 0xaf, 0x31, 0xee, 0x0a, 0x29, 0xc5, 0xe5, 0xb6, 0x4d, 0x63,
-	0x50, 0xb5, 0xff, 0x84, 0xf0, 0x39, 0xf7, 0x7d, 0x34, 0x95, 0x9b, 0x1a, 0x7c, 0x66, 0xe5, 0xd6,
-	0x87, 0xd7, 0x70, 0x59, 0x97, 0x19, 0xeb, 0x02, 0x99, 0x8b, 0xcb, 0xda, 0x7b, 0x59, 0x7d, 0x8e,
-	0xf0, 0x68, 0xef, 0x31, 0x7a, 0x25, 0x51, 0x50, 0x01, 0x54, 0xd5, 0x21, 0x05, 0x5c, 0xa4, 0x0f,
-	0x18, 0x52, 0x95, 0xbc, 0x9f, 0x18, 0x49, 0x3c, 0x18, 0x78, 0xb6, 0x3e, 0x2c, 0x6f, 0x3d, 0x3e,
-	0x2e, 0xa0, 0x27, 0xc7, 0x05, 0xf4, 0xcb, 0x71, 0x01, 0x7d, 0x71, 0x52, 0x18, 0x79, 0x72, 0x52,
-	0x18, 0xf9, 0xf1, 0xa4, 0x30, 0xf2, 0xd1, 0xb2, 0xac, 0x98, 0xbb, 0xdd, 0x6d, 0xa1, 0xa9, 0xef,
-	0xb9, 0x62, 0x6f, 0x05, 0x4e, 0xf5, 0xa8, 0x37, 0x99, 0xb9, 0xdf, 0xa6, 0xc6, 0xf6, 0x59, 0xf6,
-	0x5f, 0x22, 0x0b, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xe7, 0x74, 0x41, 0x52, 0x1a, 0x00,
-	0x00,
+	0x1b, 0xc7, 0x33, 0xbb, 0xbf, 0x56, 0xca, 0xa4, 0x3f, 0xda, 0x0e, 0x69, 0x52, 0x5c, 0xb4, 0x09,
+	0x06, 0x95, 0xd0, 0x8a, 0x35, 0x49, 0x44, 0xd2, 0xb4, 0x94, 0x74, 0x77, 0x43, 0x36, 0x49, 0x83,
+	0x94, 0x6e, 0x24, 0x90, 0x40, 0xd5, 0xca, 0x59, 0x4f, 0x1c, 0x57, 0x5e, 0x7b, 0xbb, 0xf6, 0x36,
+	0x0d, 0x51, 0x24, 0x84, 0xd4, 0x0b, 0x87, 0x08, 0xc1, 0x4b, 0xe1, 0x05, 0x70, 0xe0, 0xd2, 0x03,
+	0x87, 0x4a, 0x95, 0xf8, 0xa3, 0x4a, 0x08, 0x25, 0x85, 0x03, 0x1c, 0xb8, 0x71, 0x40, 0x1c, 0x90,
+	0xc7, 0x8f, 0xbd, 0x5e, 0xaf, 0x6d, 0x6c, 0xaf, 0x73, 0xdb, 0xcc, 0x8c, 0xbf, 0xf3, 0x7c, 0x9e,
+	0x79, 0x66, 0xe6, 0x6b, 0x07, 0x8f, 0xee, 0xea, 0xed, 0xe6, 0x8e, 0xae, 0x52, 0xe1, 0x7e, 0x87,
+	0xb6, 0xf7, 0x8a, 0xad, 0xb6, 0x6e, 0xea, 0xe4, 0xb2, 0xd3, 0x5a, 0xdf, 0xd6, 0x3b, 0x9a, 0x24,
+	0x9a, 0x8a, 0xae, 0x15, 0xad, 0xb6, 0xc6, 0x8e, 0xa8, 0xd8, 0xbf, 0xac, 0x5e, 0xee, 0x65, 0x59,
+	0xd7, 0x65, 0x95, 0x0a, 0x62, 0x4b, 0x11, 0x44, 0x4d, 0xd3, 0x4d, 0x36, 0xd2, 0xb0, 0x55, 0xb8,
+	0x2b, 0x0d, 0xdd, 0x68, 0xea, 0x86, 0xb0, 0x25, 0x1a, 0x20, 0x2f, 0x3c, 0x98, 0xde, 0xa2, 0xa6,
+	0x38, 0x2d, 0xb4, 0x44, 0x59, 0xd1, 0x6c, 0x59, 0x7b, 0xec, 0xb8, 0x1b, 0x87, 0xdc, 0x11, 0xdb,
+	0x92, 0x22, 0x3a, 0x1d, 0x17, 0xdc, 0x8e, 0x86, 0xae, 0x6d, 0x2b, 0x32, 0x34, 0x4f, 0xba, 0xcd,
+	0x6d, 0xda, 0x52, 0xc5, 0xbd, 0xba, 0xd5, 0x4c, 0x1b, 0x1e, 0xc5, 0x09, 0x77, 0x84, 0x41, 0xef,
+	0x77, 0xa8, 0xd6, 0xa0, 0xf5, 0x86, 0xde, 0xd1, 0x4c, 0xda, 0x86, 0x01, 0x57, 0xbd, 0xca, 0x06,
+	0xd5, 0x8c, 0x8e, 0x51, 0x77, 0x26, 0xaf, 0x1b, 0xd4, 0xac, 0x2b, 0x9a, 0x44, 0x1f, 0xc2, 0xe0,
+	0x51, 0x59, 0x97, 0x75, 0xf6, 0x53, 0xb0, 0x7e, 0xd9, 0xad, 0xbc, 0x84, 0xb9, 0x3b, 0x16, 0x57,
+	0x49, 0x55, 0x3f, 0x10, 0x55, 0x45, 0x12, 0x4d, 0xbd, 0x5d, 0x52, 0x55, 0x7d, 0x57, 0x55, 0x0c,
+	0x93, 0x2c, 0x63, 0xdc, 0xe5, 0xbc, 0x88, 0x26, 0xd1, 0xd4, 0xc8, 0xcc, 0xe5, 0xa2, 0x9d, 0x94,
+	0xa2, 0x95, 0x94, 0xa2, 0x9d, 0x73, 0x48, 0x4a, 0x71, 0x43, 0x94, 0x69, 0xcd, 0x8a, 0xd5, 0x30,
+	0x6b, 0x9e, 0x27, 0xf9, 0xef, 0x10, 0xe6, 0xc3, 0xa7, 0xa9, 0x51, 0xa3, 0x65, 0xc5, 0x4f, 0xee,
+	0xe2, 0x61, 0xd1, 0x69, 0xbc, 0x88, 0x26, 0xf3, 0x53, 0x23, 0x33, 0x8b, 0xc5, 0x78, 0x0b, 0x59,
+	0xec, 0x95, 0xa5, 0x52, 0x49, 0x92, 0xda, 0xd4, 0x30, 0x6a, 0x5d, 0x45, 0x52, 0xed, 0xa1, 0xc9,
+	0x31, 0x9a, 0xd7, 0xff, 0x93, 0xc6, 0x8e, 0xad, 0x07, 0xe7, 0x10, 0xe1, 0x71, 0x86, 0x13, 0x90,
+	0xb2, 0xab, 0xf8, 0xfc, 0x03, 0xa7, 0xb5, 0x2e, 0xda, 0x41, 0xb0, 0xcc, 0x0d, 0xd7, 0xce, 0xb9,
+	0x1d, 0x10, 0x9c, 0x2f, 0xbf, 0xb9, 0xd4, 0xf9, 0xfd, 0x0b, 0xe1, 0x89, 0x90, 0x80, 0xdc, 0xe4,
+	0x26, 0x0a, 0xac, 0x67, 0x25, 0x72, 0x27, 0xbc, 0x12, 0xf9, 0xf4, 0x2b, 0x31, 0x03, 0xe5, 0x5b,
+	0xa5, 0x66, 0x15, 0x0a, 0x7f, 0x93, 0x9a, 0x90, 0x22, 0x32, 0x8a, 0x4f, 0xb1, 0x1d, 0xc0, 0x30,
+	0xff, 0x5f, 0xb3, 0xff, 0xe0, 0x3f, 0xc1, 0x97, 0x02, 0x9f, 0x81, 0x3c, 0x7d, 0x8c, 0x47, 0x3c,
+	0xcd, 0x50, 0xf4, 0xb3, 0x71, 0xe1, 0x3d, 0x8f, 0x96, 0xff, 0xf7, 0xf8, 0xe7, 0x89, 0xa1, 0x9a,
+	0x57, 0xcd, 0xbb, 0xdd, 0x02, 0xe2, 0xcd, 0x6a, 0xbb, 0x7d, 0x8b, 0x00, 0xd1, 0x3f, 0x4d, 0x18,
+	0x62, 0x3e, 0x3b, 0xc4, 0xec, 0x76, 0xd9, 0x38, 0xbe, 0xe0, 0xac, 0x53, 0x85, 0x1d, 0x9c, 0x80,
+	0xca, 0x6f, 0xe3, 0x31, 0x7f, 0x07, 0x80, 0xad, 0xe3, 0xd3, 0x76, 0x0b, 0x24, 0xaf, 0x18, 0x97,
+	0xc9, 0x7e, 0x0a, 0x70, 0x40, 0x83, 0x9f, 0x87, 0x4d, 0x55, 0xb5, 0x52, 0x67, 0x1d, 0xd1, 0x1b,
+	0xee, 0x09, 0x1d, 0x58, 0x61, 0xc3, 0x4e, 0x85, 0x1d, 0x22, 0x3c, 0x19, 0xfe, 0x24, 0xc4, 0x7a,
+	0x0f, 0x9f, 0x6b, 0xfb, 0xfa, 0x20, 0xea, 0x6b, 0x71, 0xa3, 0xf6, 0x6b, 0x43, 0xfc, 0x7d, 0xba,
+	0xbc, 0x02, 0x24, 0x25, 0x55, 0x0d, 0x23, 0xc9, 0xaa, 0xf6, 0x7e, 0x70, 0xd8, 0x03, 0xe7, 0x8a,
+	0x64, 0xcf, 0x9f, 0x04, 0x7b, 0x76, 0xf5, 0x38, 0x87, 0x0b, 0xce, 0xa2, 0x6e, 0xc2, 0x7d, 0x5c,
+	0xb1, 0xaf, 0xe3, 0xe8, 0x6a, 0xf8, 0x1c, 0x75, 0xeb, 0xa8, 0xef, 0x41, 0x48, 0x88, 0x8c, 0xcf,
+	0x1a, 0xbd, 0x5d, 0xb0, 0x04, 0xf3, 0x71, 0xf3, 0xe1, 0x53, 0x86, 0x74, 0xf8, 0x55, 0xf9, 0x1d,
+	0x80, 0x28, 0xa9, 0x6a, 0x08, 0x44, 0x56, 0x85, 0xf0, 0x14, 0x75, 0x8b, 0x2e, 0x11, 0x76, 0x3e,
+	0x7b, 0xec, 0xec, 0x8a, 0xe0, 0x0a, 0x9e, 0xf2, 0x9c, 0x3d, 0xb6, 0xe7, 0xf2, 0x9c, 0x7e, 0xab,
+	0xd6, 0x8a, 0x3b, 0xe7, 0xd4, 0xd7, 0x08, 0xbf, 0x11, 0x63, 0x30, 0xe4, 0xe2, 0x11, 0xc2, 0x2f,
+	0x85, 0x8e, 0x82, 0x75, 0x28, 0x25, 0x38, 0xcf, 0x82, 0x85, 0x20, 0x41, 0xe1, 0x33, 0xf1, 0x4b,
+	0xdd, 0xb3, 0xcb, 0xe9, 0x73, 0x6f, 0x74, 0xa7, 0x46, 0x26, 0xf1, 0x88, 0xe3, 0x33, 0x6f, 0xd3,
+	0x3d, 0x16, 0xdc, 0x99, 0x9a, 0xb7, 0x89, 0xff, 0x12, 0xe1, 0x57, 0x22, 0x64, 0x80, 0xb9, 0x89,
+	0xcf, 0xcb, 0xfe, 0x4e, 0x40, 0x5d, 0x48, 0x7a, 0x1d, 0xb9, 0x02, 0x80, 0xd8, 0xaf, 0xcc, 0xdf,
+	0xeb, 0x1e, 0x4d, 0xa1, 0x68, 0x59, 0x95, 0xff, 0x33, 0x27, 0x01, 0xc1, 0x93, 0x45, 0x27, 0x20,
+	0x7f, 0x32, 0x09, 0xc8, 0x6e, 0x1b, 0xbc, 0x06, 0x7e, 0x7e, 0x5d, 0x34, 0xa9, 0x61, 0x86, 0x6d,
+	0x80, 0xbb, 0xf8, 0xd5, 0xc8, 0x51, 0x90, 0x84, 0x39, 0x3c, 0xa6, 0x06, 0x8e, 0x00, 0xdf, 0x16,
+	0xd2, 0xeb, 0x5d, 0xce, 0x0f, 0x45, 0xa3, 0xb9, 0xaa, 0x19, 0xa6, 0xa8, 0x99, 0x8a, 0x68, 0xd2,
+	0xec, 0xdf, 0x60, 0x7e, 0x45, 0xb0, 0xf1, 0x23, 0x26, 0x73, 0x81, 0x5a, 0xfd, 0xef, 0x31, 0xeb,
+	0x71, 0x57, 0x33, 0x48, 0x9c, 0x4a, 0x15, 0x5d, 0x33, 0xdb, 0x62, 0xc3, 0xac, 0xe8, 0x12, 0x5d,
+	0x95, 0x60, 0x81, 0x4f, 0xe0, 0xd5, 0x66, 0xe6, 0x53, 0x0e, 0x9f, 0x62, 0x9c, 0xe4, 0x19, 0xea,
+	0x71, 0x89, 0xa4, 0x1c, 0x97, 0x20, 0xdc, 0x90, 0x73, 0x95, 0x81, 0x34, 0xec, 0x70, 0xf9, 0xca,
+	0x67, 0x4f, 0x9f, 0x7f, 0x95, 0xbb, 0x49, 0x6e, 0x08, 0x01, 0x62, 0x82, 0x2b, 0x26, 0xf4, 0xbd,
+	0x8f, 0x6f, 0x52, 0x53, 0xd8, 0x67, 0x77, 0xf2, 0x01, 0xf9, 0x1e, 0xe1, 0x17, 0x3c, 0xe2, 0x25,
+	0x55, 0x4d, 0x08, 0x18, 0xe8, 0xe0, 0x13, 0x02, 0x06, 0xdb, 0x73, 0xfe, 0x06, 0x03, 0x7c, 0x9b,
+	0xcc, 0xa6, 0x00, 0x24, 0xdf, 0x20, 0xc7, 0x03, 0x93, 0x9b, 0x49, 0xb3, 0xdd, 0x63, 0xb3, 0xb9,
+	0x77, 0xd3, 0x3e, 0x0e, 0x18, 0x73, 0x0c, 0xe3, 0x2d, 0x52, 0x8c, 0x8b, 0x61, 0x7f, 0x1e, 0x21,
+	0x7f, 0x22, 0x7c, 0xae, 0xd6, 0xe7, 0xe2, 0x92, 0x06, 0x13, 0xe2, 0x73, 0xb9, 0x95, 0xc1, 0x85,
+	0x80, 0x6f, 0x85, 0xf1, 0x95, 0xc9, 0xad, 0xb8, 0x7c, 0x7e, 0x6b, 0xea, 0x16, 0xe3, 0xef, 0x08,
+	0xbf, 0xe8, 0x9f, 0xc6, 0xaa, 0xc8, 0x6a, 0xd2, 0x6a, 0xca, 0x06, 0x3a, 0xc2, 0xb9, 0xf3, 0xb7,
+	0x18, 0xf4, 0x75, 0x72, 0x2d, 0x2d, 0x34, 0xf9, 0x03, 0xe1, 0xb3, 0x3e, 0xd7, 0x46, 0x96, 0x93,
+	0x2e, 0x4a, 0xb0, 0x77, 0xe5, 0xaa, 0x03, 0xeb, 0x00, 0x66, 0x95, 0x61, 0x96, 0xc8, 0x62, 0x5c,
+	0x4c, 0x9f, 0xe1, 0x74, 0x97, 0xf6, 0x37, 0x84, 0x89, 0x6f, 0x12, 0x6b, 0x65, 0x97, 0x93, 0x2e,
+	0x48, 0x26, 0xc0, 0xe1, 0x4e, 0x9c, 0x5f, 0x64, 0xc0, 0x0b, 0x64, 0x3e, 0x25, 0x30, 0x39, 0xcc,
+	0x45, 0xd8, 0x57, 0xb2, 0x91, 0xe2, 0x2c, 0x89, 0x34, 0xd7, 0xdc, 0x9d, 0x0c, 0x15, 0x21, 0x07,
+	0xeb, 0x2c, 0x07, 0xcb, 0x64, 0x29, 0xc1, 0x81, 0x15, 0xfa, 0xd5, 0x95, 0xfc, 0x8d, 0xf0, 0xf9,
+	0x3e, 0x6b, 0x46, 0x56, 0xd2, 0xde, 0x80, 0x7e, 0xa3, 0xca, 0xad, 0x66, 0xa0, 0x04, 0xe0, 0x1b,
+	0x0c, 0x7c, 0x8d, 0xac, 0x24, 0xbd, 0x70, 0xea, 0xee, 0x87, 0x43, 0x61, 0xdf, 0xe3, 0xfe, 0x0f,
+	0xac, 0x33, 0x7c, 0xb4, 0x6f, 0x3e, 0xab, 0xf0, 0x57, 0xd2, 0x5e, 0x90, 0x03, 0xf2, 0x47, 0xb9,
+	0x70, 0xbe, 0xcc, 0xf8, 0xdf, 0x21, 0xd7, 0xd3, 0xf3, 0x93, 0x7f, 0x10, 0x1e, 0x0b, 0xf6, 0xb9,
+	0x64, 0x2d, 0x51, 0xa4, 0x91, 0x96, 0x9a, 0xbb, 0x9d, 0x89, 0x16, 0x70, 0xaf, 0x32, 0xee, 0x0a,
+	0x29, 0xc5, 0xe5, 0xb6, 0x8d, 0x78, 0x50, 0xb5, 0xff, 0x84, 0xf0, 0x19, 0xd7, 0x08, 0xa7, 0x72,
+	0x53, 0xfd, 0x9f, 0xae, 0xb9, 0xb5, 0xc1, 0x35, 0x5c, 0xd6, 0x05, 0xc6, 0x3a, 0x4b, 0xa6, 0xe3,
+	0xb2, 0x76, 0xcd, 0xf5, 0x73, 0x84, 0x87, 0xbb, 0x6f, 0x14, 0x8b, 0x89, 0x82, 0x0a, 0xa0, 0xaa,
+	0x0e, 0x28, 0xe0, 0x22, 0xbd, 0xcf, 0x90, 0xaa, 0xe4, 0xbd, 0xc4, 0x48, 0xc2, 0x7e, 0xdf, 0xbf,
+	0x02, 0x0e, 0xc8, 0xa3, 0x1c, 0xbe, 0x14, 0xf6, 0x6a, 0x93, 0x6a, 0xeb, 0x86, 0x89, 0x71, 0x1b,
+	0x59, 0x29, 0xb9, 0xa9, 0x58, 0x63, 0xa9, 0x58, 0x22, 0xe5, 0xb8, 0xa9, 0xd8, 0x15, 0x8d, 0x66,
+	0x5d, 0xe9, 0x4a, 0xd6, 0xdd, 0xdc, 0x94, 0x37, 0x1f, 0x1f, 0x15, 0xd0, 0x93, 0xa3, 0x02, 0xfa,
+	0xe5, 0xa8, 0x80, 0xbe, 0x38, 0x2e, 0x0c, 0x3d, 0x39, 0x2e, 0x0c, 0xfd, 0x78, 0x5c, 0x18, 0xfa,
+	0x68, 0x41, 0x56, 0xcc, 0x9d, 0xce, 0x56, 0xb1, 0xa1, 0x37, 0x5d, 0xa5, 0x37, 0x03, 0xe7, 0x79,
+	0xd8, 0x9d, 0xc9, 0xdc, 0x6b, 0x51, 0x63, 0xeb, 0x34, 0xfb, 0x77, 0xdb, 0xec, 0xbf, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0xaa, 0x28, 0x21, 0x10, 0xae, 0x1c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1374,6 +1480,7 @@ type QueryClient interface {
 	LatestGuardianSetIndex(ctx context.Context, in *QueryLatestGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryLatestGuardianSetIndexResponse, error)
 	AllowlistAll(ctx context.Context, in *QueryAllValidatorAllowlist, opts ...grpc.CallOption) (*QueryAllValidatorAllowlistResponse, error)
 	Allowlist(ctx context.Context, in *QueryValidatorAllowlist, opts ...grpc.CallOption) (*QueryValidatorAllowlistResponse, error)
+	WasmInstantiateAllowlistAll(ctx context.Context, in *QueryAllWasmInstantiateAllowlist, opts ...grpc.CallOption) (*QueryAllWasmInstantiateAllowlistResponse, error)
 }
 
 type queryClient struct {
@@ -1501,6 +1608,15 @@ func (c *queryClient) Allowlist(ctx context.Context, in *QueryValidatorAllowlist
 	return out, nil
 }
 
+func (c *queryClient) WasmInstantiateAllowlistAll(ctx context.Context, in *QueryAllWasmInstantiateAllowlist, opts ...grpc.CallOption) (*QueryAllWasmInstantiateAllowlistResponse, error) {
+	out := new(QueryAllWasmInstantiateAllowlistResponse)
+	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Query/WasmInstantiateAllowlistAll", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// Queries a guardianSet by index.
@@ -1527,6 +1643,7 @@ type QueryServer interface {
 	LatestGuardianSetIndex(context.Context, *QueryLatestGuardianSetIndexRequest) (*QueryLatestGuardianSetIndexResponse, error)
 	AllowlistAll(context.Context, *QueryAllValidatorAllowlist) (*QueryAllValidatorAllowlistResponse, error)
 	Allowlist(context.Context, *QueryValidatorAllowlist) (*QueryValidatorAllowlistResponse, error)
+	WasmInstantiateAllowlistAll(context.Context, *QueryAllWasmInstantiateAllowlist) (*QueryAllWasmInstantiateAllowlistResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -1572,6 +1689,9 @@ func (*UnimplementedQueryServer) AllowlistAll(ctx context.Context, req *QueryAll
 func (*UnimplementedQueryServer) Allowlist(ctx context.Context, req *QueryValidatorAllowlist) (*QueryValidatorAllowlistResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Allowlist not implemented")
 }
+func (*UnimplementedQueryServer) WasmInstantiateAllowlistAll(ctx context.Context, req *QueryAllWasmInstantiateAllowlist) (*QueryAllWasmInstantiateAllowlistResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method WasmInstantiateAllowlistAll not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -1811,6 +1931,24 @@ func _Query_Allowlist_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_WasmInstantiateAllowlistAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryAllWasmInstantiateAllowlist)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).WasmInstantiateAllowlistAll(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/wormhole_foundation.wormchain.wormhole.Query/WasmInstantiateAllowlistAll",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).WasmInstantiateAllowlistAll(ctx, req.(*QueryAllWasmInstantiateAllowlist))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "wormhole_foundation.wormchain.wormhole.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -1867,6 +2005,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Allowlist",
 			Handler:    _Query_Allowlist_Handler,
 		},
+		{
+			MethodName: "WasmInstantiateAllowlistAll",
+			Handler:    _Query_WasmInstantiateAllowlistAll_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "wormhole/query.proto",
@@ -2803,6 +2945,90 @@ func (m *QueryLatestGuardianSetIndexResponse) MarshalToSizedBuffer(dAtA []byte)
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryAllWasmInstantiateAllowlist) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryAllWasmInstantiateAllowlist) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryAllWasmInstantiateAllowlist) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		{
+			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Allowlist) > 0 {
+		for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Allowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQuery(v)
 	base := offset
@@ -3170,6 +3396,38 @@ func (m *QueryLatestGuardianSetIndexResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryAllWasmInstantiateAllowlist) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryAllWasmInstantiateAllowlistResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Allowlist) > 0 {
+		for _, e := range m.Allowlist {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
 func sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -5510,6 +5768,212 @@ func (m *QueryLatestGuardianSetIndexResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryAllWasmInstantiateAllowlist) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryAllWasmInstantiateAllowlist: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllWasmInstantiateAllowlist: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryAllWasmInstantiateAllowlistResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryAllWasmInstantiateAllowlistResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllWasmInstantiateAllowlistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Allowlist = append(m.Allowlist, WasmInstantiateAllowedContractCodeId{})
+			if err := m.Allowlist[len(m.Allowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipQuery(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

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

@@ -555,6 +555,42 @@ func local_request_Query_Allowlist_0(ctx context.Context, marshaler runtime.Mars
 
 }
 
+var (
+	filter_Query_WasmInstantiateAllowlistAll_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Query_WasmInstantiateAllowlistAll_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryAllWasmInstantiateAllowlist
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_WasmInstantiateAllowlistAll_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.WasmInstantiateAllowlistAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_WasmInstantiateAllowlistAll_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryAllWasmInstantiateAllowlist
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_WasmInstantiateAllowlistAll_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.WasmInstantiateAllowlistAll(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
 // UnaryRPC     :call QueryServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -860,6 +896,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_WasmInstantiateAllowlistAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_WasmInstantiateAllowlistAll_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_WasmInstantiateAllowlistAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -1161,6 +1220,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_WasmInstantiateAllowlistAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_WasmInstantiateAllowlistAll_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_WasmInstantiateAllowlistAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -1190,6 +1269,8 @@ var (
 	pattern_Query_AllowlistAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormchain", "wormhole", "allowlist"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_Allowlist_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormchain", "wormhole", "allowlist", "validator_address"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_WasmInstantiateAllowlistAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormchain", "wormhole", "wasm_instantiate_allowlist"}, "", runtime.AssumeColonVerbOpt(true)))
 )
 
 var (
@@ -1218,4 +1299,6 @@ var (
 	forward_Query_AllowlistAll_0 = runtime.ForwardResponseMessage
 
 	forward_Query_Allowlist_0 = runtime.ForwardResponseMessage
+
+	forward_Query_WasmInstantiateAllowlistAll_0 = runtime.ForwardResponseMessage
 )

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

@@ -611,6 +611,185 @@ func (m *MsgInstantiateContractResponse) GetData() []byte {
 	return nil
 }
 
+type MsgAddWasmInstantiateAllowlist struct {
+	// Signer is the actor that signed the messages
+	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
+	// Address is the bech32 address of the contract that can call wasm instantiate without a VAA
+	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+	// CodeID is the reference to the stored WASM code that can be instantiated
+	CodeId uint64 `protobuf:"varint,3,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+	// vaa is the WormchainAddWasmInstantiateAllowlist governance message
+	Vaa []byte `protobuf:"bytes,4,opt,name=vaa,proto3" json:"vaa,omitempty"`
+}
+
+func (m *MsgAddWasmInstantiateAllowlist) Reset()         { *m = MsgAddWasmInstantiateAllowlist{} }
+func (m *MsgAddWasmInstantiateAllowlist) String() string { return proto.CompactTextString(m) }
+func (*MsgAddWasmInstantiateAllowlist) ProtoMessage()    {}
+func (*MsgAddWasmInstantiateAllowlist) Descriptor() ([]byte, []int) {
+	return fileDescriptor_55f7aa067b0c517b, []int{11}
+}
+func (m *MsgAddWasmInstantiateAllowlist) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgAddWasmInstantiateAllowlist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgAddWasmInstantiateAllowlist.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgAddWasmInstantiateAllowlist) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgAddWasmInstantiateAllowlist.Merge(m, src)
+}
+func (m *MsgAddWasmInstantiateAllowlist) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgAddWasmInstantiateAllowlist) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgAddWasmInstantiateAllowlist.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgAddWasmInstantiateAllowlist proto.InternalMessageInfo
+
+func (m *MsgAddWasmInstantiateAllowlist) GetSigner() string {
+	if m != nil {
+		return m.Signer
+	}
+	return ""
+}
+
+func (m *MsgAddWasmInstantiateAllowlist) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
+func (m *MsgAddWasmInstantiateAllowlist) GetCodeId() uint64 {
+	if m != nil {
+		return m.CodeId
+	}
+	return 0
+}
+
+func (m *MsgAddWasmInstantiateAllowlist) GetVaa() []byte {
+	if m != nil {
+		return m.Vaa
+	}
+	return nil
+}
+
+type MsgDeleteWasmInstantiateAllowlist 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 <contract, code_id> pair to remove
+	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+	CodeId  uint64 `protobuf:"varint,3,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+	// vaa is the WormchainDeleteWasmInstantiateAllowlist governance message
+	Vaa []byte `protobuf:"bytes,4,opt,name=vaa,proto3" json:"vaa,omitempty"`
+}
+
+func (m *MsgDeleteWasmInstantiateAllowlist) Reset()         { *m = MsgDeleteWasmInstantiateAllowlist{} }
+func (m *MsgDeleteWasmInstantiateAllowlist) String() string { return proto.CompactTextString(m) }
+func (*MsgDeleteWasmInstantiateAllowlist) ProtoMessage()    {}
+func (*MsgDeleteWasmInstantiateAllowlist) Descriptor() ([]byte, []int) {
+	return fileDescriptor_55f7aa067b0c517b, []int{12}
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgDeleteWasmInstantiateAllowlist.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgDeleteWasmInstantiateAllowlist.Merge(m, src)
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgDeleteWasmInstantiateAllowlist.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgDeleteWasmInstantiateAllowlist proto.InternalMessageInfo
+
+func (m *MsgDeleteWasmInstantiateAllowlist) GetSigner() string {
+	if m != nil {
+		return m.Signer
+	}
+	return ""
+}
+
+func (m *MsgDeleteWasmInstantiateAllowlist) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
+func (m *MsgDeleteWasmInstantiateAllowlist) GetCodeId() uint64 {
+	if m != nil {
+		return m.CodeId
+	}
+	return 0
+}
+
+func (m *MsgDeleteWasmInstantiateAllowlist) GetVaa() []byte {
+	if m != nil {
+		return m.Vaa
+	}
+	return nil
+}
+
+type MsgWasmInstantiateAllowlistResponse struct {
+}
+
+func (m *MsgWasmInstantiateAllowlistResponse) Reset()         { *m = MsgWasmInstantiateAllowlistResponse{} }
+func (m *MsgWasmInstantiateAllowlistResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgWasmInstantiateAllowlistResponse) ProtoMessage()    {}
+func (*MsgWasmInstantiateAllowlistResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_55f7aa067b0c517b, []int{13}
+}
+func (m *MsgWasmInstantiateAllowlistResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgWasmInstantiateAllowlistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgWasmInstantiateAllowlistResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgWasmInstantiateAllowlistResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgWasmInstantiateAllowlistResponse.Merge(m, src)
+}
+func (m *MsgWasmInstantiateAllowlistResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgWasmInstantiateAllowlistResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgWasmInstantiateAllowlistResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgWasmInstantiateAllowlistResponse proto.InternalMessageInfo
+
 // MsgMigrateContract runs a code upgrade/ downgrade for a smart contract
 type MsgMigrateContract struct {
 	// Sender is the actor that signs the messages
@@ -629,7 +808,7 @@ func (m *MsgMigrateContract) Reset()         { *m = MsgMigrateContract{} }
 func (m *MsgMigrateContract) String() string { return proto.CompactTextString(m) }
 func (*MsgMigrateContract) ProtoMessage()    {}
 func (*MsgMigrateContract) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{11}
+	return fileDescriptor_55f7aa067b0c517b, []int{14}
 }
 func (m *MsgMigrateContract) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -704,7 +883,7 @@ func (m *MsgMigrateContractResponse) Reset()         { *m = MsgMigrateContractRe
 func (m *MsgMigrateContractResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgMigrateContractResponse) ProtoMessage()    {}
 func (*MsgMigrateContractResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{12}
+	return fileDescriptor_55f7aa067b0c517b, []int{15}
 }
 func (m *MsgMigrateContractResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -752,6 +931,9 @@ func init() {
 	proto.RegisterType((*MsgStoreCodeResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgStoreCodeResponse")
 	proto.RegisterType((*MsgInstantiateContract)(nil), "wormhole_foundation.wormchain.wormhole.MsgInstantiateContract")
 	proto.RegisterType((*MsgInstantiateContractResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgInstantiateContractResponse")
+	proto.RegisterType((*MsgAddWasmInstantiateAllowlist)(nil), "wormhole_foundation.wormchain.wormhole.MsgAddWasmInstantiateAllowlist")
+	proto.RegisterType((*MsgDeleteWasmInstantiateAllowlist)(nil), "wormhole_foundation.wormchain.wormhole.MsgDeleteWasmInstantiateAllowlist")
+	proto.RegisterType((*MsgWasmInstantiateAllowlistResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgWasmInstantiateAllowlistResponse")
 	proto.RegisterType((*MsgMigrateContract)(nil), "wormhole_foundation.wormchain.wormhole.MsgMigrateContract")
 	proto.RegisterType((*MsgMigrateContractResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgMigrateContractResponse")
 }
@@ -759,52 +941,57 @@ func init() {
 func init() { proto.RegisterFile("wormhole/tx.proto", fileDescriptor_55f7aa067b0c517b) }
 
 var fileDescriptor_55f7aa067b0c517b = []byte{
-	// 709 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x6a, 0x13, 0x41,
-	0x18, 0xef, 0x34, 0x69, 0xda, 0x7e, 0x04, 0xad, 0x6b, 0xa8, 0x71, 0x29, 0xa9, 0xae, 0x52, 0xbc,
-	0x98, 0x88, 0x8a, 0xa0, 0x88, 0x92, 0xf4, 0x1f, 0x05, 0xd7, 0xc3, 0x56, 0x2c, 0x78, 0x09, 0x93,
-	0xdd, 0xe9, 0x64, 0x71, 0x77, 0x27, 0xee, 0xcc, 0xb6, 0xcd, 0xc9, 0x47, 0xd0, 0xde, 0x15, 0x7c,
-	0x03, 0x5f, 0xc3, 0x8b, 0xd0, 0xa3, 0xa7, 0x22, 0xe9, 0x8b, 0xc8, 0x4e, 0xb2, 0x93, 0xd0, 0x64,
-	0x43, 0xd7, 0xf6, 0xf6, 0x7d, 0xb3, 0xf3, 0xfd, 0xfe, 0x0c, 0x33, 0x3f, 0x16, 0x6e, 0x1c, 0xb2,
-	0xd0, 0x6f, 0x33, 0x8f, 0xd4, 0xc4, 0x51, 0xb5, 0x13, 0x32, 0xc1, 0xb4, 0xb5, 0x64, 0xa9, 0xb9,
-	0xcf, 0xa2, 0xc0, 0xc1, 0xc2, 0x65, 0x41, 0x35, 0x5e, 0xb3, 0xdb, 0xd8, 0xed, 0x57, 0xf1, 0x57,
-	0xbd, 0x44, 0x19, 0x65, 0x72, 0xa4, 0x16, 0x57, 0xfd, 0x69, 0x63, 0x1f, 0x2a, 0x26, 0xa7, 0xeb,
-	0x21, 0xc1, 0x82, 0xd4, 0x3d, 0x8f, 0x1d, 0x7a, 0x2e, 0x17, 0x9b, 0x81, 0x08, 0xbb, 0x16, 0xf9,
-	0x14, 0x11, 0x2e, 0xb4, 0x65, 0x28, 0x70, 0x97, 0x06, 0x24, 0x2c, 0xa3, 0x3b, 0xe8, 0xc1, 0xa2,
-	0x35, 0xe8, 0xb4, 0x32, 0xcc, 0x63, 0xc7, 0x09, 0x09, 0xe7, 0xe5, 0x59, 0xf9, 0x21, 0x69, 0x35,
-	0x0d, 0xf2, 0x01, 0xf6, 0x49, 0x39, 0x27, 0x97, 0x65, 0x6d, 0x58, 0x92, 0x67, 0x83, 0x78, 0xe4,
-	0xca, 0x78, 0x8c, 0x65, 0x28, 0x99, 0x9c, 0x2a, 0x34, 0x8b, 0xf0, 0x0e, 0x0b, 0x38, 0x31, 0xd6,
-	0xe1, 0x96, 0xc9, 0xe9, 0xe6, 0x11, 0xb1, 0x23, 0x41, 0xb6, 0xd9, 0x01, 0x09, 0x03, 0x1c, 0xd8,
-	0xe4, 0x7d, 0xbd, 0xae, 0x2d, 0x41, 0xee, 0x00, 0x63, 0xc9, 0x50, 0xb4, 0xe2, 0x72, 0x84, 0x76,
-	0x76, 0x94, 0xd6, 0xb8, 0x0b, 0xab, 0x29, 0x20, 0x8a, 0xe7, 0x1d, 0xac, 0x98, 0x9c, 0x5a, 0x84,
-	0xba, 0x5c, 0x90, 0xb0, 0x6e, 0xdb, 0x2c, 0x0a, 0x44, 0x9d, 0x6f, 0x47, 0x38, 0x74, 0x5c, 0x1c,
-	0xa4, 0x3a, 0x5a, 0x81, 0xc5, 0xb8, 0xc2, 0x22, 0x0a, 0xfb, 0x87, 0x54, 0xb4, 0x86, 0x0b, 0xc6,
-	0x1a, 0xdc, 0x9f, 0x86, 0xaa, 0xd8, 0x3b, 0x50, 0x34, 0x39, 0xdd, 0x15, 0x2c, 0x24, 0xeb, 0xcc,
-	0x21, 0xa9, 0x6c, 0xcf, 0xe0, 0xda, 0x21, 0xe6, 0x7e, 0xb3, 0xd5, 0x15, 0xa4, 0x69, 0x33, 0x87,
-	0x48, 0xa3, 0xc5, 0xc6, 0x52, 0xef, 0x74, 0xb5, 0xb8, 0x57, 0xdf, 0x35, 0x1b, 0x5d, 0x21, 0x11,
-	0xac, 0x62, 0xbc, 0x2f, 0xe9, 0x92, 0xa3, 0xca, 0xa9, 0xa3, 0x32, 0xf6, 0xe4, 0x79, 0x2b, 0xc6,
-	0x44, 0x89, 0x76, 0x0f, 0xe6, 0x63, 0xdc, 0xa6, 0xeb, 0x48, 0xea, 0x7c, 0x03, 0x7a, 0xa7, 0xab,
-	0x85, 0x78, 0xcb, 0xce, 0x86, 0x55, 0x88, 0x3f, 0xed, 0x38, 0x9a, 0x0e, 0x0b, 0x76, 0x9b, 0xd8,
-	0x1f, 0x79, 0xe4, 0xf7, 0x05, 0x58, 0xaa, 0x37, 0xbe, 0x20, 0x58, 0x36, 0x39, 0xdd, 0x09, 0xb8,
-	0xc0, 0x81, 0x70, 0x71, 0xac, 0x20, 0x10, 0x21, 0xb6, 0xd3, 0x6f, 0xc5, 0x08, 0x67, 0x2e, 0x95,
-	0xb3, 0x04, 0x73, 0x1e, 0x6e, 0x11, 0xaf, 0x9c, 0x97, 0xb3, 0xfd, 0x26, 0x36, 0xe6, 0x73, 0x5a,
-	0x9e, 0xeb, 0x1b, 0xf3, 0x39, 0x4d, 0xac, 0x16, 0x86, 0x56, 0xdf, 0xca, 0xeb, 0x3a, 0x41, 0x90,
-	0x32, 0x3d, 0x72, 0x2d, 0xd1, 0xd8, 0xf5, 0x77, 0xb0, 0xc0, 0x03, 0x97, 0xb2, 0x36, 0x8e, 0x11,
-	0x68, 0x26, 0xa7, 0xa6, 0x4b, 0xc3, 0x8b, 0xb8, 0x8b, 0x0f, 0x6b, 0xb0, 0x67, 0x70, 0x2d, 0x55,
-	0x7f, 0x31, 0xe7, 0x03, 0x8f, 0xf9, 0x69, 0x1e, 0x1f, 0x81, 0x3e, 0x2e, 0x49, 0xf9, 0x4b, 0x5c,
-	0xa0, 0xa1, 0x8b, 0xc7, 0xbf, 0x17, 0x20, 0x67, 0x72, 0xaa, 0xfd, 0x40, 0x50, 0x9a, 0xf8, 0xbc,
-	0x5e, 0x57, 0x2f, 0x16, 0x46, 0xd5, 0x94, 0xa7, 0xa5, 0x6f, 0x5f, 0x12, 0x40, 0xc9, 0xff, 0x89,
-	0xe0, 0x76, 0xfa, 0xcb, 0xdc, 0xc8, 0x40, 0x93, 0x8a, 0xa2, 0xbf, 0xb9, 0x0a, 0x14, 0xa5, 0xf8,
-	0x1b, 0x82, 0xd2, 0xa4, 0x1c, 0xd6, 0xb6, 0x32, 0xd0, 0x4c, 0x09, 0x72, 0xfd, 0x65, 0x06, 0x9c,
-	0xb1, 0x50, 0x95, 0xf2, 0x26, 0xc5, 0x77, 0x26, 0x79, 0x53, 0xf2, 0xff, 0x92, 0xf2, 0x3e, 0xc3,
-	0xe2, 0x30, 0x0a, 0x9f, 0x66, 0x80, 0x52, 0x53, 0x99, 0x04, 0x8c, 0x87, 0xe0, 0x77, 0x04, 0x37,
-	0x27, 0x05, 0xd8, 0xab, 0x0c, 0xa8, 0x13, 0xe6, 0xf5, 0xad, 0xcb, 0xcd, 0x2b, 0x7d, 0xc7, 0x08,
-	0xae, 0x9f, 0x8f, 0x9f, 0x17, 0x19, 0xb0, 0xcf, 0xcd, 0xea, 0x8d, 0xff, 0x9f, 0x4d, 0x34, 0x35,
-	0x76, 0x7f, 0xf5, 0x2a, 0xe8, 0xa4, 0x57, 0x41, 0x7f, 0x7b, 0x15, 0xf4, 0xf5, 0xac, 0x32, 0x73,
-	0x72, 0x56, 0x99, 0xf9, 0x73, 0x56, 0x99, 0xf9, 0xf0, 0x9c, 0xba, 0xa2, 0x1d, 0xb5, 0xaa, 0x36,
-	0xf3, 0x6b, 0x09, 0xd2, 0xc3, 0x21, 0x4f, 0x4d, 0xf1, 0xd4, 0x8e, 0x6a, 0xc3, 0x5f, 0xa2, 0x6e,
-	0x87, 0xf0, 0x56, 0x41, 0xfe, 0xd8, 0x3c, 0xf9, 0x17, 0x00, 0x00, 0xff, 0xff, 0x39, 0xb3, 0x42,
-	0x88, 0x2b, 0x09, 0x00, 0x00,
+	// 799 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcf, 0x6f, 0xe3, 0x44,
+	0x14, 0xee, 0x34, 0x69, 0x4a, 0x1f, 0x11, 0x14, 0x13, 0xb5, 0xc1, 0x54, 0x2e, 0x75, 0xa1, 0xe2,
+	0x42, 0x82, 0x00, 0x21, 0x81, 0x10, 0x28, 0xe9, 0x2f, 0x45, 0x60, 0x0e, 0x2e, 0xa2, 0x12, 0x97,
+	0x68, 0x62, 0x4f, 0x27, 0x16, 0xb1, 0x27, 0x78, 0xc6, 0x6d, 0x73, 0x40, 0xf0, 0x1f, 0xec, 0xf6,
+	0xbe, 0x2b, 0xed, 0x7f, 0xb0, 0xd2, 0x9e, 0xf6, 0xb2, 0xf7, 0x3d, 0xf6, 0xb8, 0xa7, 0x6a, 0x95,
+	0xfe, 0x23, 0x2b, 0x4f, 0xe2, 0x49, 0xd4, 0xc4, 0x69, 0xdd, 0x56, 0xbb, 0xb7, 0x79, 0xe3, 0x79,
+	0xdf, 0xf7, 0xbd, 0xf1, 0xe7, 0xf7, 0x0c, 0x1f, 0x9d, 0xb0, 0xd0, 0x6f, 0xb3, 0x0e, 0xa9, 0x8a,
+	0xd3, 0x4a, 0x37, 0x64, 0x82, 0x69, 0x5b, 0xc9, 0x56, 0xf3, 0x88, 0x45, 0x81, 0x8b, 0x85, 0xc7,
+	0x82, 0x4a, 0xbc, 0xe7, 0xb4, 0xb1, 0x37, 0x58, 0xc5, 0x4f, 0xf5, 0x12, 0x65, 0x94, 0xc9, 0x94,
+	0x6a, 0xbc, 0x1a, 0x64, 0x9b, 0x47, 0x60, 0x58, 0x9c, 0x6e, 0x87, 0x04, 0x0b, 0x52, 0xeb, 0x74,
+	0xd8, 0x49, 0xc7, 0xe3, 0x62, 0x37, 0x10, 0x61, 0xcf, 0x26, 0xff, 0x44, 0x84, 0x0b, 0x6d, 0x05,
+	0x0a, 0xdc, 0xa3, 0x01, 0x09, 0xcb, 0xe8, 0x33, 0xf4, 0xe5, 0x92, 0x3d, 0x8c, 0xb4, 0x32, 0x2c,
+	0x62, 0xd7, 0x0d, 0x09, 0xe7, 0xe5, 0x79, 0xf9, 0x20, 0x09, 0x35, 0x0d, 0xf2, 0x01, 0xf6, 0x49,
+	0x39, 0x27, 0xb7, 0xe5, 0xda, 0xb4, 0x25, 0xcf, 0x0e, 0xe9, 0x90, 0x7b, 0xe3, 0x31, 0x57, 0xa0,
+	0x64, 0x71, 0xaa, 0xd0, 0x6c, 0xc2, 0xbb, 0x2c, 0xe0, 0xc4, 0xdc, 0x86, 0x55, 0x8b, 0xd3, 0xdd,
+	0x53, 0xe2, 0x44, 0x82, 0xec, 0xb3, 0x63, 0x12, 0x06, 0x38, 0x70, 0xc8, 0x9f, 0xb5, 0x9a, 0xb6,
+	0x0c, 0xb9, 0x63, 0x8c, 0x25, 0x43, 0xd1, 0x8e, 0x97, 0x63, 0xb4, 0xf3, 0xe3, 0xb4, 0xe6, 0x06,
+	0xac, 0xa7, 0x80, 0x28, 0x9e, 0x3f, 0x60, 0xcd, 0xe2, 0xd4, 0x26, 0xd4, 0xe3, 0x82, 0x84, 0x35,
+	0xc7, 0x61, 0x51, 0x20, 0x6a, 0x7c, 0x3f, 0xc2, 0xa1, 0xeb, 0xe1, 0x20, 0xb5, 0xa2, 0x35, 0x58,
+	0x8a, 0x57, 0x58, 0x44, 0xe1, 0xe0, 0x92, 0x8a, 0xf6, 0x68, 0xc3, 0xdc, 0x82, 0xcf, 0x67, 0xa1,
+	0x2a, 0xf6, 0x2e, 0x14, 0x2d, 0x4e, 0x0f, 0x04, 0x0b, 0xc9, 0x36, 0x73, 0x49, 0x2a, 0xdb, 0xf7,
+	0xf0, 0xc1, 0x09, 0xe6, 0x7e, 0xb3, 0xd5, 0x13, 0xa4, 0xe9, 0x30, 0x97, 0xc8, 0x42, 0x8b, 0xf5,
+	0xe5, 0xfe, 0xc5, 0x7a, 0xf1, 0xb0, 0x76, 0x60, 0xd5, 0x7b, 0x42, 0x22, 0xd8, 0xc5, 0xf8, 0x5c,
+	0x12, 0x25, 0x57, 0x95, 0x53, 0x57, 0x65, 0x1e, 0xca, 0xfb, 0x56, 0x8c, 0x89, 0x12, 0x6d, 0x13,
+	0x16, 0x63, 0xdc, 0xa6, 0xe7, 0x4a, 0xea, 0x7c, 0x1d, 0xfa, 0x17, 0xeb, 0x85, 0xf8, 0x48, 0x63,
+	0xc7, 0x2e, 0xc4, 0x8f, 0x1a, 0xae, 0xa6, 0xc3, 0x7b, 0x4e, 0x9b, 0x38, 0x7f, 0xf3, 0xc8, 0x1f,
+	0x08, 0xb0, 0x55, 0x6c, 0x3e, 0x40, 0xb0, 0x62, 0x71, 0xda, 0x08, 0xb8, 0xc0, 0x81, 0xf0, 0x70,
+	0xac, 0x20, 0x10, 0x21, 0x76, 0xd2, 0x5d, 0x31, 0xc6, 0x99, 0x4b, 0xe5, 0x2c, 0xc1, 0x42, 0x07,
+	0xb7, 0x48, 0xa7, 0x9c, 0x97, 0xb9, 0x83, 0x20, 0x2e, 0xcc, 0xe7, 0xb4, 0xbc, 0x30, 0x28, 0xcc,
+	0xe7, 0x34, 0x29, 0xb5, 0x30, 0x2a, 0xf5, 0x77, 0x69, 0xd7, 0x29, 0x82, 0x54, 0xd1, 0x63, 0xb6,
+	0x44, 0x13, 0xf6, 0x77, 0xb1, 0xc0, 0xc3, 0x2a, 0xe5, 0xda, 0xfc, 0x57, 0xe2, 0xd5, 0x5c, 0xf7,
+	0x10, 0x73, 0x7f, 0x0c, 0x56, 0x99, 0xf7, 0x16, 0x9f, 0xd9, 0xea, 0x95, 0x2b, 0x50, 0x65, 0x0f,
+	0xcb, 0xc9, 0x8f, 0xca, 0xf9, 0x1f, 0xc1, 0x86, 0xfa, 0xfc, 0xde, 0x8d, 0x84, 0x2f, 0x60, 0xd3,
+	0xe2, 0x34, 0x8d, 0x5b, 0xb9, 0xfa, 0x0c, 0x81, 0x66, 0x71, 0x6a, 0x79, 0x34, 0xbc, 0x89, 0x0d,
+	0x62, 0x57, 0x0d, 0xcf, 0x0c, 0xb5, 0xa9, 0xf8, 0x66, 0x16, 0x19, 0x9a, 0x21, 0x3f, 0xcb, 0x0c,
+	0x5f, 0x83, 0x3e, 0x29, 0x49, 0x19, 0x21, 0x79, 0xdd, 0x68, 0xf4, 0xba, 0xbf, 0x79, 0xf1, 0x3e,
+	0xe4, 0x2c, 0x4e, 0xb5, 0x27, 0x08, 0x4a, 0x53, 0xfb, 0xd0, 0x2f, 0x95, 0x9b, 0x75, 0xed, 0x4a,
+	0x4a, 0x0f, 0xd2, 0xf7, 0xef, 0x08, 0xa0, 0xe4, 0x3f, 0x45, 0xf0, 0x49, 0x7a, 0x0b, 0xdb, 0xc9,
+	0x40, 0x93, 0x8a, 0xa2, 0xff, 0x76, 0x1f, 0x28, 0x4a, 0xf1, 0x23, 0x04, 0xa5, 0x69, 0x03, 0x4b,
+	0xdb, 0xcb, 0x40, 0x33, 0x63, 0xe2, 0xe9, 0x3f, 0x65, 0xc0, 0x99, 0x70, 0xb0, 0x94, 0x37, 0x6d,
+	0xce, 0x65, 0x92, 0x37, 0x63, 0x50, 0xde, 0x51, 0xde, 0x7f, 0xb0, 0x34, 0x9a, 0x19, 0xdf, 0x65,
+	0x80, 0x52, 0x59, 0x99, 0x04, 0x4c, 0x4e, 0x8b, 0xc7, 0x08, 0x3e, 0x9e, 0xd6, 0xe9, 0x7f, 0xce,
+	0x80, 0x3a, 0x25, 0x5f, 0xdf, 0xbb, 0x5b, 0xbe, 0xd2, 0xf7, 0x0c, 0xc1, 0xa7, 0xb3, 0x1a, 0x75,
+	0x16, 0x9e, 0x19, 0x38, 0xfa, 0xaf, 0x19, 0x70, 0xae, 0x6b, 0x9b, 0xda, 0x73, 0x04, 0xc6, 0x35,
+	0xdd, 0xbd, 0x91, 0xd9, 0x7e, 0x6f, 0x47, 0xfa, 0x19, 0x82, 0x0f, 0xaf, 0xb6, 0xfb, 0x1f, 0x33,
+	0x10, 0x5c, 0xc9, 0xd5, 0xeb, 0xb7, 0xcf, 0x4d, 0x34, 0xd5, 0x0f, 0x5e, 0xf6, 0x0d, 0x74, 0xde,
+	0x37, 0xd0, 0xeb, 0xbe, 0x81, 0x1e, 0x5e, 0x1a, 0x73, 0xe7, 0x97, 0xc6, 0xdc, 0xab, 0x4b, 0x63,
+	0xee, 0xaf, 0x1f, 0xa8, 0x27, 0xda, 0x51, 0xab, 0xe2, 0x30, 0xbf, 0x9a, 0x20, 0x7d, 0x35, 0xe2,
+	0xa9, 0x2a, 0x9e, 0xea, 0x69, 0x75, 0xf4, 0xaf, 0xde, 0xeb, 0x12, 0xde, 0x2a, 0xc8, 0x3f, 0xee,
+	0x6f, 0xdf, 0x04, 0x00, 0x00, 0xff, 0xff, 0x1c, 0x67, 0x86, 0x18, 0xc4, 0x0b, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -827,6 +1014,8 @@ type MsgClient interface {
 	StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error)
 	//  Instantiate creates a new smart contract instance for the given code id.
 	InstantiateContract(ctx context.Context, in *MsgInstantiateContract, opts ...grpc.CallOption) (*MsgInstantiateContractResponse, error)
+	AddWasmInstantiateAllowlist(ctx context.Context, in *MsgAddWasmInstantiateAllowlist, opts ...grpc.CallOption) (*MsgWasmInstantiateAllowlistResponse, error)
+	DeleteWasmInstantiateAllowlist(ctx context.Context, in *MsgDeleteWasmInstantiateAllowlist, opts ...grpc.CallOption) (*MsgWasmInstantiateAllowlistResponse, error)
 	MigrateContract(ctx context.Context, in *MsgMigrateContract, opts ...grpc.CallOption) (*MsgMigrateContractResponse, error)
 }
 
@@ -892,6 +1081,24 @@ func (c *msgClient) InstantiateContract(ctx context.Context, in *MsgInstantiateC
 	return out, nil
 }
 
+func (c *msgClient) AddWasmInstantiateAllowlist(ctx context.Context, in *MsgAddWasmInstantiateAllowlist, opts ...grpc.CallOption) (*MsgWasmInstantiateAllowlistResponse, error) {
+	out := new(MsgWasmInstantiateAllowlistResponse)
+	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/AddWasmInstantiateAllowlist", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) DeleteWasmInstantiateAllowlist(ctx context.Context, in *MsgDeleteWasmInstantiateAllowlist, opts ...grpc.CallOption) (*MsgWasmInstantiateAllowlistResponse, error) {
+	out := new(MsgWasmInstantiateAllowlistResponse)
+	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/DeleteWasmInstantiateAllowlist", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) MigrateContract(ctx context.Context, in *MsgMigrateContract, opts ...grpc.CallOption) (*MsgMigrateContractResponse, error) {
 	out := new(MsgMigrateContractResponse)
 	err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/MigrateContract", in, out, opts...)
@@ -911,6 +1118,8 @@ type MsgServer interface {
 	StoreCode(context.Context, *MsgStoreCode) (*MsgStoreCodeResponse, error)
 	//  Instantiate creates a new smart contract instance for the given code id.
 	InstantiateContract(context.Context, *MsgInstantiateContract) (*MsgInstantiateContractResponse, error)
+	AddWasmInstantiateAllowlist(context.Context, *MsgAddWasmInstantiateAllowlist) (*MsgWasmInstantiateAllowlistResponse, error)
+	DeleteWasmInstantiateAllowlist(context.Context, *MsgDeleteWasmInstantiateAllowlist) (*MsgWasmInstantiateAllowlistResponse, error)
 	MigrateContract(context.Context, *MsgMigrateContract) (*MsgMigrateContractResponse, error)
 }
 
@@ -936,6 +1145,12 @@ func (*UnimplementedMsgServer) StoreCode(ctx context.Context, req *MsgStoreCode)
 func (*UnimplementedMsgServer) InstantiateContract(ctx context.Context, req *MsgInstantiateContract) (*MsgInstantiateContractResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method InstantiateContract not implemented")
 }
+func (*UnimplementedMsgServer) AddWasmInstantiateAllowlist(ctx context.Context, req *MsgAddWasmInstantiateAllowlist) (*MsgWasmInstantiateAllowlistResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AddWasmInstantiateAllowlist not implemented")
+}
+func (*UnimplementedMsgServer) DeleteWasmInstantiateAllowlist(ctx context.Context, req *MsgDeleteWasmInstantiateAllowlist) (*MsgWasmInstantiateAllowlistResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DeleteWasmInstantiateAllowlist not implemented")
+}
 func (*UnimplementedMsgServer) MigrateContract(ctx context.Context, req *MsgMigrateContract) (*MsgMigrateContractResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MigrateContract not implemented")
 }
@@ -1052,6 +1267,42 @@ func _Msg_InstantiateContract_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_AddWasmInstantiateAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgAddWasmInstantiateAllowlist)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).AddWasmInstantiateAllowlist(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/AddWasmInstantiateAllowlist",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).AddWasmInstantiateAllowlist(ctx, req.(*MsgAddWasmInstantiateAllowlist))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_DeleteWasmInstantiateAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgDeleteWasmInstantiateAllowlist)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).DeleteWasmInstantiateAllowlist(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/DeleteWasmInstantiateAllowlist",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).DeleteWasmInstantiateAllowlist(ctx, req.(*MsgDeleteWasmInstantiateAllowlist))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_MigrateContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgMigrateContract)
 	if err := dec(in); err != nil {
@@ -1098,6 +1349,14 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "InstantiateContract",
 			Handler:    _Msg_InstantiateContract_Handler,
 		},
+		{
+			MethodName: "AddWasmInstantiateAllowlist",
+			Handler:    _Msg_AddWasmInstantiateAllowlist_Handler,
+		},
+		{
+			MethodName: "DeleteWasmInstantiateAllowlist",
+			Handler:    _Msg_DeleteWasmInstantiateAllowlist_Handler,
+		},
 		{
 			MethodName: "MigrateContract",
 			Handler:    _Msg_MigrateContract_Handler,
@@ -1503,7 +1762,7 @@ func (m *MsgInstantiateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgMigrateContract) Marshal() (dAtA []byte, err error) {
+func (m *MsgAddWasmInstantiateAllowlist) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1513,12 +1772,12 @@ func (m *MsgMigrateContract) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgMigrateContract) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgAddWasmInstantiateAllowlist) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgMigrateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgAddWasmInstantiateAllowlist) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1528,24 +1787,17 @@ func (m *MsgMigrateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		copy(dAtA[i:], m.Vaa)
 		i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa)))
 		i--
-		dAtA[i] = 0x32
-	}
-	if len(m.Msg) > 0 {
-		i -= len(m.Msg)
-		copy(dAtA[i:], m.Msg)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Msg)))
-		i--
 		dAtA[i] = 0x22
 	}
-	if m.CodeID != 0 {
-		i = encodeVarintTx(dAtA, i, uint64(m.CodeID))
+	if m.CodeId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.CodeId))
 		i--
 		dAtA[i] = 0x18
 	}
-	if len(m.Contract) > 0 {
-		i -= len(m.Contract)
-		copy(dAtA[i:], m.Contract)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
 		i--
 		dAtA[i] = 0x12
 	}
@@ -1559,7 +1811,7 @@ func (m *MsgMigrateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgMigrateContractResponse) Marshal() (dAtA []byte, err error) {
+func (m *MsgDeleteWasmInstantiateAllowlist) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1569,67 +1821,195 @@ func (m *MsgMigrateContractResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgMigrateContractResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgDeleteWasmInstantiateAllowlist) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgMigrateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgDeleteWasmInstantiateAllowlist) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Data) > 0 {
-		i -= len(m.Data)
-		copy(dAtA[i:], m.Data)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Data)))
+	if len(m.Vaa) > 0 {
+		i -= len(m.Vaa)
+		copy(dAtA[i:], m.Vaa)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.CodeId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.CodeId))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Signer) > 0 {
+		i -= len(m.Signer)
+		copy(dAtA[i:], m.Signer)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
 		i--
 		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
-	offset -= sovTx(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+func (m *MsgWasmInstantiateAllowlistResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	dAtA[offset] = uint8(v)
-	return base
+	return dAtA[:n], nil
 }
-func (m *MsgCreateAllowlistEntryRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Signer)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Name)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
+
+func (m *MsgWasmInstantiateAllowlistResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgDeleteAllowlistEntryRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *MsgWasmInstantiateAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.Signer)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgMigrateContract) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgMigrateContract) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMigrateContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Vaa) > 0 {
+		i -= len(m.Vaa)
+		copy(dAtA[i:], m.Vaa)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Vaa)))
+		i--
+		dAtA[i] = 0x32
+	}
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.CodeID != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.CodeID))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Contract) > 0 {
+		i -= len(m.Contract)
+		copy(dAtA[i:], m.Contract)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Contract)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Signer) > 0 {
+		i -= len(m.Signer)
+		copy(dAtA[i:], m.Signer)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgMigrateContractResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgMigrateContractResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMigrateContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Data) > 0 {
+		i -= len(m.Data)
+		copy(dAtA[i:], m.Data)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Data)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTx(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *MsgCreateAllowlistEntryRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Signer)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgDeleteAllowlistEntryRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Signer)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
 	}
 	l = len(m.Address)
 	if l > 0 {
@@ -1781,6 +2161,63 @@ func (m *MsgInstantiateContractResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgAddWasmInstantiateAllowlist) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Signer)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.CodeId != 0 {
+		n += 1 + sovTx(uint64(m.CodeId))
+	}
+	l = len(m.Vaa)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgDeleteWasmInstantiateAllowlist) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Signer)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.CodeId != 0 {
+		n += 1 + sovTx(uint64(m.CodeId))
+	}
+	l = len(m.Vaa)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgWasmInstantiateAllowlistResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func (m *MsgMigrateContract) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3040,6 +3477,390 @@ func (m *MsgInstantiateContractResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgAddWasmInstantiateAllowlist) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgAddWasmInstantiateAllowlist: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgAddWasmInstantiateAllowlist: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Signer = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+			}
+			m.CodeId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CodeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Vaa", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Vaa = append(m.Vaa[:0], dAtA[iNdEx:postIndex]...)
+			if m.Vaa == nil {
+				m.Vaa = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgDeleteWasmInstantiateAllowlist) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgDeleteWasmInstantiateAllowlist: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgDeleteWasmInstantiateAllowlist: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Signer = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+			}
+			m.CodeId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CodeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Vaa", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Vaa = append(m.Vaa[:0], dAtA[iNdEx:postIndex]...)
+			if m.Vaa == nil {
+				m.Vaa = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgWasmInstantiateAllowlistResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgWasmInstantiateAllowlistResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgWasmInstantiateAllowlistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgMigrateContract) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0