add vaa-gated wasmd to wormchain (#1674)

* wormchain: add wasmd module

* wormchain: update proto

* wormchain: gate wasmd contract uploading around vaa

* wormchain: add tests around wasmd operations and guardian set upgrades

* wormchain: split wasm handlers into multiple files and permit bank methods

* wormchain: address review comments

* wormchain: use legacy keccak instead of sha3

* wormchain: add way to compute vaa hash manually

* wormchain: update proto package paths and dependencies

* wormchain: remove wasmd keeper guard

* wormchain: add CLI helpers for starting the chain

* wormchain: increase max validators and add genesis time

* wormchain: remove .pb.go from lint check

* wormchain: cleanup and address review comments

* wormchain: stop tracking .pb.go files

* wormchain: address comment to create buffer safely

Co-authored-by: Chirantan Ekbote <cekbote@jumptrading.com>

* wormchain: generate proto in ci

* wormchain: fix wrong description

* wormchain: always rebuild proto in ci

* wormchain: fix unit test compile error

* wormchain: build proto in tilt

Change-Id: Ibc4f4ff0c34108f4ecbe1af3c47373816739c669

Co-authored-by: Chirantan Ekbote <cekbote@jumptrading.com>
Co-authored-by: Hendrik Hofstadt <hendrik@nexantic.com>

.github/workflows/build.yml

@@ -235,7 +235,7 @@ jobs:
         with:
           go-version: '1.19.0'
       - run: curl https://get.ignite.com/cli@v0.23.0 | bash && mv ignite /usr/local/bin/
-      - run: cd wormhole_chain && make test
+      - run: cd wormhole_chain && make proto -B && make test
 
   # Run Go linters, Go tests and other outside-of-Tilt things.
   lint-and-tests:

Dockerfile.wormchain

@@ -24,6 +24,7 @@ EXPOSE 4500
 
 RUN unset GOPATH
 
+RUN make proto -B
 RUN make client
 RUN chmod +x /app/build/wormhole-chaind
 RUN make validators

scripts/lint.sh

@@ -43,7 +43,7 @@ format(){
     fi
 
     # Use -exec because of pitfall #1 in http://mywiki.wooledge.org/BashPitfalls
-    GOFMT_OUTPUT="$(find "./sdk" "./node" "./event_database" "./wormhole_chain" -type f -name '*.go' -not -path './node/pkg/proto/*' -print0 | xargs -r -0 goimports $GOIMPORTS_ARGS 2>&1)"
+    GOFMT_OUTPUT="$(find "./sdk" "./node" "./event_database" "./wormhole_chain" -type f -name '*.go' -not -path '*.pb.go' -print0 | xargs -r -0 goimports $GOIMPORTS_ARGS 2>&1)"
 
     if [ -n "$GOFMT_OUTPUT" ]; then
         if [ "$GITHUB_ACTION" == "true" ]; then

wormhole_chain/.gitignore

@@ -11,6 +11,7 @@ validators/first_validator/keyring-test
 validators/second_validator/keyring-test
 ts-sdk/node_modules
 ts-sdk/lib
+*.pb.go
 
 .idea
 *.iml

wormhole_chain/app/app.go

@@ -69,14 +69,15 @@ import (
 	upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client"
 	upgradekeeper "github.com/cosmos/cosmos-sdk/x/upgrade/keeper"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
-	"github.com/cosmos/ibc-go/modules/apps/transfer"
-	ibctransferkeeper "github.com/cosmos/ibc-go/modules/apps/transfer/keeper"
-	ibctransfertypes "github.com/cosmos/ibc-go/modules/apps/transfer/types"
-	ibc "github.com/cosmos/ibc-go/modules/core"
-	ibcclient "github.com/cosmos/ibc-go/modules/core/02-client"
-	ibcporttypes "github.com/cosmos/ibc-go/modules/core/05-port/types"
-	ibchost "github.com/cosmos/ibc-go/modules/core/24-host"
-	ibckeeper "github.com/cosmos/ibc-go/modules/core/keeper"
+	"github.com/cosmos/ibc-go/v3/modules/apps/transfer"
+	ibctransferkeeper "github.com/cosmos/ibc-go/v3/modules/apps/transfer/keeper"
+	ibctransfertypes "github.com/cosmos/ibc-go/v3/modules/apps/transfer/types"
+	ibc "github.com/cosmos/ibc-go/v3/modules/core"
+	ibcclient "github.com/cosmos/ibc-go/v3/modules/core/02-client"
+	ibcporttypes "github.com/cosmos/ibc-go/v3/modules/core/05-port/types"
+	ibchost "github.com/cosmos/ibc-go/v3/modules/core/24-host"
+	ibckeeper "github.com/cosmos/ibc-go/v3/modules/core/keeper"
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/spf13/cast"
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmjson "github.com/tendermint/tendermint/libs/json"
@@ -84,6 +85,9 @@ import (
 	tmos "github.com/tendermint/tendermint/libs/os"
 	dbm "github.com/tendermint/tm-db"
 
+	"github.com/CosmWasm/wasmd/x/wasm"
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+
 	"github.com/tendermint/spm/cosmoscmd"
 	"github.com/tendermint/spm/openapiconsole"
 
@@ -122,6 +126,16 @@ func getGovProposalHandlers() []govclient.ProposalHandler {
 	return govProposalHandlers
 }
 
+// GetWasmOpts build wasm options
+func GetWasmOpts(appOpts servertypes.AppOptions) []wasm.Option {
+	var wasmOpts []wasm.Option
+	if cast.ToBool(appOpts.Get("telemetry.enabled")) {
+		wasmOpts = append(wasmOpts, wasmkeeper.WithVMCacheMetrics(prometheus.DefaultRegisterer))
+	}
+
+	return wasmOpts
+}
+
 var (
 	// DefaultNodeHome default home directories for the application daemon
 	DefaultNodeHome string
@@ -150,6 +164,7 @@ var (
 		wormholemodule.AppModuleBasic{},
 		tokenbridgemodule.AppModuleBasic{},
 		// this line is used by starport scaffolding # stargate/app/moduleBasic
+		wasm.AppModuleBasic{},
 	)
 
 	// module account permissions
@@ -164,6 +179,7 @@ var (
 		wormholemoduletypes.ModuleName:    nil,
 		tokenbridgemoduletypes.ModuleName: {authtypes.Minter, authtypes.Burner, authtypes.Staking},
 		// this line is used by starport scaffolding # stargate/app/maccPerms
+		wasm.ModuleName: {authtypes.Burner},
 	}
 )
 
@@ -223,6 +239,8 @@ type App struct {
 
 	TokenbridgeKeeper tokenbridgemodulekeeper.Keeper
 	// this line is used by starport scaffolding # stargate/app/keeperDeclaration
+	wasmKeeper       wasm.Keeper
+	scopedWasmKeeper capabilitykeeper.ScopedKeeper
 
 	// the module manager
 	mm *module.Manager
@@ -261,6 +279,7 @@ func New(
 		wormholemoduletypes.StoreKey,
 		tokenbridgemoduletypes.StoreKey,
 		// this line is used by starport scaffolding # stargate/app/storeKey
+		wasm.StoreKey,
 	)
 	tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey)
 	memKeys := sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey)
@@ -288,6 +307,7 @@ func New(
 	scopedIBCKeeper := app.CapabilityKeeper.ScopeToModule(ibchost.ModuleName)
 	scopedTransferKeeper := app.CapabilityKeeper.ScopeToModule(ibctransfertypes.ModuleName)
 	// this line is used by starport scaffolding # stargate/app/scopedKeeper
+	scopedWasmKeeper := app.CapabilityKeeper.ScopeToModule(wasm.ModuleName)
 
 	// add keepers
 	app.AccountKeeper = authkeeper.NewAccountKeeper(
@@ -353,10 +373,11 @@ func New(
 	// Create Transfer Keepers
 	app.TransferKeeper = ibctransferkeeper.NewKeeper(
 		appCodec, keys[ibctransfertypes.StoreKey], app.GetSubspace(ibctransfertypes.ModuleName),
-		app.IBCKeeper.ChannelKeeper, &app.IBCKeeper.PortKeeper,
+		app.IBCKeeper.ChannelKeeper, app.IBCKeeper.ChannelKeeper, &app.IBCKeeper.PortKeeper,
 		app.AccountKeeper, app.BankKeeper, scopedTransferKeeper,
 	)
 	transferModule := transfer.NewAppModule(app.TransferKeeper)
+	transferIBCModule := transfer.NewIBCModule(app.TransferKeeper)
 
 	// Create evidence Keeper for to register the IBC light client misbehaviour evidence route
 	evidenceKeeper := evidencekeeper.NewKeeper(
@@ -383,11 +404,40 @@ func New(
 		&stakingKeeper, govRouter,
 	)
 
+	// The last arguments can contain custom message handlers, and custom query handlers,
+	// if we want to allow any custom callbacks
+	supportedFeatures := "iterator,staking,stargate"
+	wasmDir := filepath.Join(homePath, "data")
+	// Instantiate wasm keeper with stubs for other modules as we do not need
+	// wasm to be able to write to other modules.
+	app.wasmKeeper = wasm.NewKeeper(
+		appCodec,
+		keys[wasm.StoreKey],
+		app.GetSubspace(wasm.ModuleName),
+		app.AccountKeeper,
+		app.BankKeeper,
+		app.StakingKeeper,
+		app.DistrKeeper,
+		app.IBCKeeper.ChannelKeeper,
+		&app.IBCKeeper.PortKeeper,
+		scopedWasmKeeper,
+		app.TransferKeeper,
+		app.MsgServiceRouter(),
+		app.GRPCQueryRouter(),
+		wasmDir,
+		wasm.DefaultWasmConfig(),
+		// wasmConfig.ToWasmConfig(),
+		supportedFeatures,
+		GetWasmOpts(appOpts)...,
+	)
+	permissionedWasmKeeper := wasmkeeper.NewDefaultPermissionKeeper(app.wasmKeeper)
+	app.WormholeKeeper.SetWasmdKeeper(permissionedWasmKeeper)
+
 	// this line is used by starport scaffolding # stargate/app/keeperDefinition
 
 	// Create static IBC router, add transfer route, then set and seal it
 	ibcRouter := ibcporttypes.NewRouter()
-	ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferModule)
+	ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferIBCModule)
 	// this line is used by starport scaffolding # ibc/app/router
 	app.IBCKeeper.SetRouter(ibcRouter)
 
@@ -424,6 +474,7 @@ func New(
 		wormholeModule,
 		tokenbridgeModule,
 		// this line is used by starport scaffolding # stargate/app/appModule
+		wasm.NewAppModule(appCodec, &app.wasmKeeper, app.StakingKeeper, app.AccountKeeper, app.BankKeeper),
 	)
 
 	// During begin block slashing happens after distr.BeginBlocker so that
@@ -451,6 +502,7 @@ func New(
 		wormholemoduletypes.ModuleName,
 		tokenbridgemoduletypes.ModuleName,
 		// this line is used by starport scaffolding # stargate/app/beginBlockers
+		wasm.ModuleName,
 	)
 
 	app.mm.SetOrderEndBlockers(
@@ -474,6 +526,7 @@ func New(
 		wormholemoduletypes.ModuleName,
 		tokenbridgemoduletypes.ModuleName,
 		// this line is used by starport scaffolding # stargate/app/endBlockers
+		wasm.ModuleName,
 	)
 
 	// NOTE: The genutils module must occur after staking so that pools are
@@ -505,6 +558,7 @@ func New(
 		feegrant.ModuleName,
 		tokenbridgemoduletypes.ModuleName,
 		// this line is used by starport scaffolding # stargate/app/initGenesis
+		wasm.ModuleName,
 	)
 
 	app.mm.RegisterInvariants(&app.CrisisKeeper)
@@ -545,6 +599,7 @@ func New(
 	app.ScopedIBCKeeper = scopedIBCKeeper
 	app.ScopedTransferKeeper = scopedTransferKeeper
 	// this line is used by starport scaffolding # stargate/app/beforeInitReturn
+	app.scopedWasmKeeper = scopedWasmKeeper
 
 	return app
 }
@@ -694,6 +749,7 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino
 	paramsKeeper.Subspace(wormholemoduletypes.ModuleName)
 	paramsKeeper.Subspace(tokenbridgemoduletypes.ModuleName)
 	// this line is used by starport scaffolding # stargate/app/paramSubspace
+	paramsKeeper.Subspace(wasm.ModuleName)
 
 	return paramsKeeper
 }

wormhole_chain/app/wasm_handlers/account.go

@@ -0,0 +1,30 @@
+package wasm_handlers
+
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+type AccountKeeperHandler struct {
+	AccountKeeper authkeeper.AccountKeeper
+}
+
+var _ wasmtypes.AccountKeeper = &AccountKeeperHandler{}
+
+func (b *AccountKeeperHandler) NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI {
+	// New accounts are needed for new contracts
+	return b.AccountKeeper.NewAccountWithAddress(ctx, addr)
+}
+
+// Retrieve an account from the store.
+func (b *AccountKeeperHandler) GetAccount(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI {
+	return b.AccountKeeper.GetAccount(ctx, addr)
+}
+
+// Set an account in the store.
+func (b *AccountKeeperHandler) SetAccount(ctx sdk.Context, acc authtypes.AccountI) {
+	// New accounts are needed for new contracts
+	b.AccountKeeper.SetAccount(ctx, acc)
+}

wormhole_chain/app/wasm_handlers/bank.go

@@ -0,0 +1,48 @@
+package wasm_handlers
+
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+)
+
+type BankViewKeeperHandler struct {
+	Keeper bankkeeper.Keeper
+}
+type BurnerHandler struct {
+	Keeper bankkeeper.Keeper
+}
+
+type BankKeeperHandler struct {
+	BankViewKeeperHandler
+	BurnerHandler
+}
+
+var _ wasmtypes.BankViewKeeper = &BankViewKeeperHandler{}
+var _ wasmtypes.Burner = &BurnerHandler{}
+var _ wasmtypes.BankKeeper = &BankKeeperHandler{}
+
+func (b *BankViewKeeperHandler) GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins {
+	return b.Keeper.GetAllBalances(ctx, addr)
+}
+func (b *BankViewKeeperHandler) GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin {
+	return b.Keeper.GetBalance(ctx, addr, denom)
+}
+
+func (b *BurnerHandler) BurnCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error {
+	return b.Keeper.BurnCoins(ctx, moduleName, amt)
+}
+
+func (b *BurnerHandler) SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error {
+	return b.Keeper.SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt)
+}
+
+func (b *BankKeeperHandler) IsSendEnabledCoins(ctx sdk.Context, coins ...sdk.Coin) error {
+	return b.BankViewKeeperHandler.Keeper.IsSendEnabledCoins(ctx, coins...)
+}
+func (b *BankKeeperHandler) BlockedAddr(addr sdk.AccAddress) bool {
+	return b.BankViewKeeperHandler.Keeper.BlockedAddr(addr)
+}
+func (b *BankKeeperHandler) SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) error {
+	return b.BankViewKeeperHandler.Keeper.SendCoins(ctx, fromAddr, toAddr, amt)
+}

wormhole_chain/app/wasm_handlers/capability.go

@@ -0,0 +1,24 @@
+package wasm_handlers
+
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
+	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
+)
+
+type CapabilityKeeperHandler struct {
+	ScopedKeeper capabilitykeeper.ScopedKeeper
+}
+
+var _ wasmtypes.CapabilityKeeper = &CapabilityKeeperHandler{}
+
+func (b *CapabilityKeeperHandler) GetCapability(ctx sdk.Context, name string) (*capabilitytypes.Capability, bool) {
+	return b.ScopedKeeper.GetCapability(ctx, name)
+}
+func (b *CapabilityKeeperHandler) ClaimCapability(ctx sdk.Context, cap *capabilitytypes.Capability, name string) error {
+	return b.ScopedKeeper.ClaimCapability(ctx, cap, name)
+}
+func (b *CapabilityKeeperHandler) AuthenticateCapability(ctx sdk.Context, cap *capabilitytypes.Capability, name string) bool {
+	return b.ScopedKeeper.AuthenticateCapability(ctx, cap, name)
+}

wormhole_chain/app/wasm_handlers/ibc.go

@@ -0,0 +1,82 @@
+package wasm_handlers
+
+import (
+	"errors"
+
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
+	ibcappkeeper "github.com/cosmos/ibc-go/v3/modules/apps/transfer/keeper"
+	connectiontypes "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
+	ibckeeper "github.com/cosmos/ibc-go/v3/modules/core/04-channel/keeper"
+	channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
+	ibcportkeeper "github.com/cosmos/ibc-go/v3/modules/core/05-port/keeper"
+	ibcexported "github.com/cosmos/ibc-go/v3/modules/core/exported"
+)
+
+// This defines which modules we actually want to expose cosmwasm contracts.
+// Right now we only permit methods that are read-only.
+// See https://github.com/CosmWasm/wasmd/blob/d63bea442bedf5b3055f3821472c7e6cafc3d813/x/wasm/types/expected_keepers.go
+
+type ChannelKeeperHandler struct {
+	Keeper ibckeeper.Keeper
+}
+type ClientKeeperHandler struct {
+	Keeper ibckeeper.Keeper
+}
+type ConnectionKeeperHandler struct {
+	Keeper ibckeeper.Keeper
+}
+type PortKeeperHandler struct {
+	Keeper ibcportkeeper.Keeper
+}
+type ICS20TransferPortSourceHandler struct {
+	Keeper ibcappkeeper.Keeper
+}
+
+var _ wasmtypes.ChannelKeeper = &ChannelKeeperHandler{}
+var _ wasmtypes.ClientKeeper = &ClientKeeperHandler{}
+var _ wasmtypes.ConnectionKeeper = &ConnectionKeeperHandler{}
+var _ wasmtypes.PortKeeper = &PortKeeperHandler{}
+var _ wasmtypes.ICS20TransferPortSource = &ICS20TransferPortSourceHandler{}
+
+func (b *ChannelKeeperHandler) GetChannel(ctx sdk.Context, srcPort, srcChan string) (channel channeltypes.Channel, found bool) {
+	return b.Keeper.GetChannel(ctx, srcPort, srcChan)
+}
+func (b *ChannelKeeperHandler) GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (uint64, bool) {
+	// not permitted
+	return 0, false
+}
+func (b *ChannelKeeperHandler) SendPacket(ctx sdk.Context, channelCap *capabilitytypes.Capability, packet ibcexported.PacketI) error {
+	return errors.New("not permitted")
+}
+func (b *ChannelKeeperHandler) ChanCloseInit(ctx sdk.Context, portID, channelID string, chanCap *capabilitytypes.Capability) error {
+	return errors.New("not permitted")
+}
+func (b *ChannelKeeperHandler) GetAllChannels(ctx sdk.Context) (channels []channeltypes.IdentifiedChannel) {
+	// not permitted
+	return []channeltypes.IdentifiedChannel{}
+}
+func (b *ChannelKeeperHandler) IterateChannels(ctx sdk.Context, cb func(channeltypes.IdentifiedChannel) bool) {
+	// not permitted
+}
+func (b *ChannelKeeperHandler) SetChannel(ctx sdk.Context, portID, channelID string, channel channeltypes.Channel) {
+	// not permitted
+}
+
+func (b *ClientKeeperHandler) GetClientConsensusState(ctx sdk.Context, clientID string) (ibcexported.ConsensusState, bool) {
+	return nil, false
+}
+
+func (b *ConnectionKeeperHandler) GetConnection(ctx sdk.Context, connectionID string) (connection connectiontypes.ConnectionEnd, found bool) {
+	return connectiontypes.ConnectionEnd{}, false
+}
+
+func (b *PortKeeperHandler) BindPort(ctx sdk.Context, portID string) *capabilitytypes.Capability {
+	return nil
+}
+
+func (b *ICS20TransferPortSourceHandler) GetPort(ctx sdk.Context) string {
+	// not permitted
+	return ""
+}

wormhole_chain/app/wasm_handlers/staking.go

@@ -0,0 +1,52 @@
+package wasm_handlers
+
+import (
+	"context"
+
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper"
+	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
+	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+type DistributionKeeperHandler struct {
+	Keeper distrkeeper.Keeper
+}
+type StakingKeeperHandler struct {
+	Keeper stakingkeeper.Keeper
+}
+
+var _ wasmtypes.DistributionKeeper = &DistributionKeeperHandler{}
+var _ wasmtypes.StakingKeeper = &StakingKeeperHandler{}
+
+func (b *DistributionKeeperHandler) DelegationRewards(c context.Context, req *distrtypes.QueryDelegationRewardsRequest) (*distrtypes.QueryDelegationRewardsResponse, error) {
+	return b.Keeper.DelegationRewards(c, req)
+}
+
+func (b *StakingKeeperHandler) BondDenom(ctx sdk.Context) (res string) {
+	return b.Keeper.BondDenom(ctx)
+}
+
+func (b *StakingKeeperHandler) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) {
+	return b.Keeper.GetValidator(ctx, addr)
+}
+
+func (b *StakingKeeperHandler) GetBondedValidatorsByPower(ctx sdk.Context) []stakingtypes.Validator {
+	return b.Keeper.GetBondedValidatorsByPower(ctx)
+}
+
+func (b *StakingKeeperHandler) GetAllDelegatorDelegations(ctx sdk.Context, delegator sdk.AccAddress) []stakingtypes.Delegation {
+	return b.Keeper.GetAllDelegatorDelegations(ctx, delegator)
+}
+
+func (b *StakingKeeperHandler) GetDelegation(ctx sdk.Context,
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress) (delegation stakingtypes.Delegation, found bool) {
+	return b.Keeper.GetDelegation(ctx, delAddr, valAddr)
+}
+
+func (b *StakingKeeperHandler) HasReceivingRedelegation(ctx sdk.Context,
+	delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) bool {
+	return b.Keeper.HasReceivingRedelegation(ctx, delAddr, valDstAddr)
+}

wormhole_chain/build/config/genesis.json

@@ -1,4 +1,5 @@
 {
+  "genesis_time": "2022-09-27T22:08:43.044644477Z",
   "chain_id": "wormholechain",
   "gentxs_dir": "build/config/gentx",
   "moniker": "mynode",
@@ -287,7 +288,7 @@
         "bond_denom": "uworm",
         "historical_entries": 10000,
         "max_entries": 7,
-        "max_validators": 1,
+        "max_validators": 1000,
         "unbonding_time": "1814400s"
       },
       "redelegations": [],
@@ -337,6 +338,19 @@
       ],
       "replayProtectionList": [],
       "sequenceCounterList": []
+    },
+    "wasm": {
+      "params": {
+        "code_upload_access": {
+          "permission": "Everybody",
+          "address": ""
+        },
+        "instantiate_default_permission": "Everybody"
+      },
+      "codes": [],
+      "contracts": [],
+      "sequences": [],
+      "gen_msgs": []
     }
   }
 }

wormhole_chain/cmd/wormhole-chaind/main.go

@@ -6,6 +6,7 @@ import (
 	svrcmd "github.com/cosmos/cosmos-sdk/server/cmd"
 	"github.com/tendermint/spm/cosmoscmd"
 	"github.com/wormhole-foundation/wormhole-chain/app"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/client/cli"
 )
 
 func main() {
@@ -18,6 +19,7 @@ func main() {
 		app.New,
 		// this line is used by starport scaffolding # root/arguments
 	)
+	rootCmd.AddCommand(cli.GetGenesisCmd())
 	if err := svrcmd.Execute(rootCmd, app.DefaultNodeHome); err != nil {
 		os.Exit(1)
 	}

wormhole_chain/go.mod

@@ -3,31 +3,35 @@ module github.com/wormhole-foundation/wormhole-chain
 go 1.16
 
 require (
-	github.com/cosmos/cosmos-sdk v0.45.7
-	github.com/cosmos/ibc-go v1.2.2
+	github.com/CosmWasm/wasmd v0.28.0
+	github.com/cosmos/cosmos-sdk v0.45.8
+	github.com/cosmos/ibc-go/v3 v3.3.0
 	github.com/dgraph-io/ristretto v0.1.0 // indirect
 	github.com/ethereum/go-ethereum v1.10.21
 	github.com/gogo/protobuf v1.3.3
 	github.com/golang/glog v1.0.0 // indirect
 	github.com/golang/protobuf v1.5.2
-	github.com/google/btree v1.0.1 // indirect
 	github.com/gorilla/mux v1.8.0
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
+	github.com/prometheus/client_golang v1.12.2
 	github.com/spf13/cast v1.5.0
 	github.com/spf13/cobra v1.5.0
 	github.com/stretchr/testify v1.8.0
+	github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15
 	github.com/tendermint/spm v0.1.9
-	github.com/tendermint/tendermint v0.34.20
+	github.com/tendermint/tendermint v0.34.21
 	github.com/tendermint/tm-db v0.6.7
-	github.com/wormhole-foundation/wormhole/sdk v0.0.0-20220921004715-3103e59217da
-	google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd
+	github.com/wormhole-foundation/wormhole/sdk v0.0.0-20220926172624-4b38dc650bb0
+	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e
+	google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc
 	google.golang.org/grpc v1.48.0
 	nhooyr.io/websocket v1.8.7 // indirect
 )
 
 replace (
 	github.com/99designs/keyring => github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76
-	github.com/cosmos/cosmos-sdk v0.45.7 => github.com/wormhole-foundation/cosmos-sdk v0.45.7-wormhole
+	github.com/CosmWasm/wasmd v0.28.0 => github.com/wormhole-foundation/wasmd v0.28.0-wormhole-2
+	github.com/cosmos/cosmos-sdk => github.com/wormhole-foundation/cosmos-sdk v0.45.7-wormhole
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	github.com/wormhole-foundation/wormhole/sdk => ../sdk
 	google.golang.org/grpc => google.golang.org/grpc v1.33.2

wormhole_chain/proto/tokenbridge/chain_registration.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types";
 

wormhole_chain/proto/tokenbridge/coin_meta_rollback_protection.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types";
 

wormhole_chain/proto/tokenbridge/config.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types";
 

wormhole_chain/proto/tokenbridge/events.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types";
 

wormhole_chain/proto/tokenbridge/genesis.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 import "tokenbridge/config.proto";
 import "tokenbridge/replay_protection.proto";

wormhole_chain/proto/tokenbridge/query.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 import "google/api/annotations.proto";
 import "cosmos/base/query/v1beta1/pagination.proto";
@@ -16,36 +16,36 @@ option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge
 service Query {
     // Queries a config by index.
 	rpc Config(QueryGetConfigRequest) returns (QueryGetConfigResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/config";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/config";
 	}
 // Queries a replayProtection by index.
 	rpc ReplayProtection(QueryGetReplayProtectionRequest) returns (QueryGetReplayProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/replayProtection/{index}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/replayProtection/{index}";
 	}
 
 	// Queries a list of replayProtection items.
 	rpc ReplayProtectionAll(QueryAllReplayProtectionRequest) returns (QueryAllReplayProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/replayProtection";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/replayProtection";
 	}
 
 // Queries a chainRegistration by index.
 	rpc ChainRegistration(QueryGetChainRegistrationRequest) returns (QueryGetChainRegistrationResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/chainRegistration/{chainID}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/chainRegistration/{chainID}";
 	}
 
 	// Queries a list of chainRegistration items.
 	rpc ChainRegistrationAll(QueryAllChainRegistrationRequest) returns (QueryAllChainRegistrationResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/chainRegistration";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/chainRegistration";
 	}
 
 // Queries a coinMetaRollbackProtection by index.
 	rpc CoinMetaRollbackProtection(QueryGetCoinMetaRollbackProtectionRequest) returns (QueryGetCoinMetaRollbackProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/coinMetaRollbackProtection/{index}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/coinMetaRollbackProtection/{index}";
 	}
 
 	// Queries a list of coinMetaRollbackProtection items.
 	rpc CoinMetaRollbackProtectionAll(QueryAllCoinMetaRollbackProtectionRequest) returns (QueryAllCoinMetaRollbackProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/tokenbridge/coinMetaRollbackProtection";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/tokenbridge/coinMetaRollbackProtection";
 	}
 
 // this line is used by starport scaffolding # 2

wormhole_chain/proto/tokenbridge/replay_protection.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types";
 

wormhole_chain/proto/tokenbridge/tx.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.tokenbridge;
+package wormhole_foundation.wormholechain.tokenbridge;
 
 import "gogoproto/gogo.proto";
 import "cosmos/base/v1beta1/coin.proto";

wormhole_chain/proto/wormhole/config.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/consensus_guardian_set_index.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/events.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/genesis.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 import "wormhole/guardian_set.proto";
 import "wormhole/config.proto";

wormhole_chain/proto/wormhole/governance.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 import "wormhole/guardian_set.proto";
 import "gogoproto/gogo.proto";

wormhole_chain/proto/wormhole/guardian_key.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/guardian_set.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/guardian_validator.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/query.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 import "google/api/annotations.proto";
 import "cosmos/base/query/v1beta1/pagination.proto";
@@ -18,55 +18,55 @@ option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/ty
 service Query {
     // Queries a guardianSet by index.
 	rpc GuardianSet(QueryGetGuardianSetRequest) returns (QueryGetGuardianSetResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/guardianSet/{index}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/guardianSet/{index}";
 	}
 
 	// Queries a list of guardianSet items.
 	rpc GuardianSetAll(QueryAllGuardianSetRequest) returns (QueryAllGuardianSetResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/guardianSet";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/guardianSet";
 	}
 
 // Queries a config by index.
 	rpc Config(QueryGetConfigRequest) returns (QueryGetConfigResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/config";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/config";
 	}
 // Queries a replayProtection by index.
 	rpc ReplayProtection(QueryGetReplayProtectionRequest) returns (QueryGetReplayProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/replayProtection/{index}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/replayProtection/{index}";
 	}
 
 	// Queries a list of replayProtection items.
 	rpc ReplayProtectionAll(QueryAllReplayProtectionRequest) returns (QueryAllReplayProtectionResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/replayProtection";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/replayProtection";
 	}
 
 // Queries a sequenceCounter by index.
 	rpc SequenceCounter(QueryGetSequenceCounterRequest) returns (QueryGetSequenceCounterResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/sequenceCounter/{index}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/sequenceCounter/{index}";
 	}
 
 	// Queries a list of sequenceCounter items.
 	rpc SequenceCounterAll(QueryAllSequenceCounterRequest) returns (QueryAllSequenceCounterResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/sequenceCounter";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/sequenceCounter";
 	}
 
 // Queries a ConsensusGuardianSetIndex by index.
 	rpc ConsensusGuardianSetIndex(QueryGetConsensusGuardianSetIndexRequest) returns (QueryGetConsensusGuardianSetIndexResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/consensus_guardian_set_index";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/consensus_guardian_set_index";
 	}
 // Queries a GuardianValidator by index.
 	rpc GuardianValidator(QueryGetGuardianValidatorRequest) returns (QueryGetGuardianValidatorResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/guardian_validator/{guardianKey}";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/guardian_validator/{guardianKey}";
 	}
 
 	// Queries a list of GuardianValidator items.
 	rpc GuardianValidatorAll(QueryAllGuardianValidatorRequest) returns (QueryAllGuardianValidatorResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/guardian_validator";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/guardian_validator";
 	}
 
 // Queries a list of LatestGuardianSetIndex items.
 	rpc LatestGuardianSetIndex(QueryLatestGuardianSetIndexRequest) returns (QueryLatestGuardianSetIndexResponse) {
-		option (google.api.http).get = "/certusone/wormholechain/wormhole/latest_guardian_set_index";
+		option (google.api.http).get = "/wormhole_foundation/wormholechain/wormhole/latest_guardian_set_index";
 	}
 
 // this line is used by starport scaffolding # 2

wormhole_chain/proto/wormhole/replay_protection.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/sequence_counter.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
 option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/types";
 

wormhole_chain/proto/wormhole/tx.proto

@@ -1,6 +1,7 @@
 syntax = "proto3";
-package certusone.wormholechain.wormhole;
+package wormhole_foundation.wormholechain.wormhole;
 
+import "gogoproto/gogo.proto";
 // this line is used by starport scaffolding # proto/tx/import
 import "wormhole/guardian_key.proto";
 
@@ -10,6 +11,12 @@ option go_package = "github.com/wormhole-foundation/wormhole-chain/x/wormhole/ty
 service Msg {
       rpc ExecuteGovernanceVAA(MsgExecuteGovernanceVAA) returns (MsgExecuteGovernanceVAAResponse);
   rpc RegisterAccountAsGuardian(MsgRegisterAccountAsGuardian) returns (MsgRegisterAccountAsGuardianResponse);
+
+  // StoreCode to submit Wasm code to the system
+  rpc StoreCode(MsgStoreCode) returns (MsgStoreCodeResponse);
+  //  Instantiate creates a new smart contract instance for the given code id.
+  rpc InstantiateContract(MsgInstantiateContract)
+      returns (MsgInstantiateContractResponse);
 // this line is used by starport scaffolding # proto/tx/rpc
 }
 
@@ -30,4 +37,40 @@ message MsgRegisterAccountAsGuardian {
 message MsgRegisterAccountAsGuardianResponse {
 }
 
+// Same as from x/wasmd but with vaa auth
+message MsgStoreCode {
+  // Signer is the that actor that signed the messages
+  string signer = 1;
+  // WASMByteCode can be raw or gzip compressed
+  bytes wasm_byte_code = 2 [ (gogoproto.customname) = "WASMByteCode" ];
+  // vaa must be governance msg with payload containing sha3 256 hash of `wasm_byte_code`
+  bytes vaa = 3;
+}
+
+message MsgStoreCodeResponse {
+  // CodeID is the reference to the stored WASM code
+  uint64 code_id = 1 [ (gogoproto.customname) = "CodeID" ];
+}
+
+// Same as from x/wasmd but with vaa auth
+message MsgInstantiateContract {
+  // Signer is the that actor that signed the messages
+  string signer = 1;
+  // CodeID is the reference to the stored WASM code
+  uint64 code_id = 3 [ (gogoproto.customname) = "CodeID" ];
+  // Label is optional metadata to be stored with a contract instance.
+  string label = 4;
+  // Msg json encoded message to be passed to the contract on instantiation
+  bytes msg = 5;
+  // vaa must be governance msg with payload containing sha3 256 hash of `bigEndian(code_id) || label || msg`
+  bytes vaa = 6;
+}
+
+message MsgInstantiateContractResponse {
+  // Address is the bech32 address of the new contract instance.
+  string address = 1;
+  // Data contains base64-encoded bytes to returned from the contract
+  bytes data = 2;
+}
+
 // this line is used by starport scaffolding # proto/tx/message

wormhole_chain/testutil/keeper/example_contract.go

@@ -0,0 +1,867 @@
+package keeper
+
+import (
+	"encoding/base64"
+)
+
+func init() {
+	wasm, err := base64.StdEncoding.DecodeString(_EXAMPLE_WASM_CONTRACT_B64_GZIP)
+	if err != nil {
+		panic(err)
+	}
+	EXAMPLE_WASM_CONTRACT_GZIP = wasm
+}
+
+var EXAMPLE_WASM_CONTRACT_GZIP = []byte{}
+var _EXAMPLE_WASM_CONTRACT_B64_GZIP = `H4sIAHxMI2MAA+w7DYwU13nvvZnZmd2Z2Zvl9o47jKLZNZWXFlQc2XeYWhVzCmCKI2PHrdw07XGG
+tbnFxuYA28TR3eGfBNImIVVT20nb0NguOC4JlolKWrciVZuSxm1JmzhIcSOcxC6VSHpRkUJUEff7
+efNmZm/BOIoqVcpa3Lzf733v+//eexYTO++VQgj5ohzepGZmxCZrZmZGzmAZ/kr+o1unNznwmZnm
+quAafO3chydNbxJikzszowd4M6Zo0XyeCWNLabuASjoBitY0QZyezo/S7fBxZqbhJ9RHVdVqb3/A
+3XLn+FR7YouwsOZB7cGpyV1tIbBaps5773ugLex08M7NE9uFTGvb2w/t4qnhxJYtU+MPTNwzuWUC
+5lNbjdpgwn3bJzdDz/vbQmVjt+6+d2K7aYt2tjff/87rR7ZdO/5Ae2ryrj28yFDWPNXeDJhMjd+/
++85t7T3Cwe5qe8s7r7/+2hsKc+pp450TuzZvLXQ5W9p37r6bd+Pv2N2e2jO+eevE5HbA9011UZWE
+63ku/IRwy/RX0c+GH3ykULKMvWXpSaXcihK+7eox8384yxWuCHCqK3CqJxS2CP0HKpZd9twwKJfd
+alitumVlCQVAYY5dxkGWEq4NYlaGfwLWVnZfWYRlr6qCqAZLW3qwgGm+CytaijBFQLZYYIsAcBCI
+K0IRHgC0LGsB/LMti2ACDKziT1luVJEwAEBAl61gw25ZBDhOKPpTBkRsRETixhGmksp3rX43ggaA
+IZTypGdJV1p1NTAIuAClFEEtCymZNDB0oaHTkKSf7cj75YMPOpYUtdKwNSOT2dkTwp8RydxPcl/3
+I7JSuhekcmoPkH9y+85dE9t3TaLMjbrth9qbd0PpBvfeybunsG2VN3HPPfdtxuJeWdnSNrVHZG2q
+vWP35FR75zgIPAy+b0p8SPZPbofKXROb2yg3Oyfv2z6+Epor4+Mg1hPj7e1bLOmPj29tT9wP4rWz
+banyl6QUifQfuPqvVaO5JP6qvOZR+UH5mHxc7pP75Yfl78rfkx+RH5Ufkwdka8Uv/cLyX1z2plr6
+B/LX33P7mvfu2Pgbd9z2m+97+P2/ve2u39ravvt5dfPqic2b7ly7Yf0tv/bude/6pHxKfkoelJ+W
+n5B/Kf9G/bf6B/lleVL+o/yK/Fv5uvwX+U35dfmKPCVflv8kvybPye/LH8j/kn+s/lT9iTqonlJP
+qCfVP6u/Vz9UR9W/qS+oL6tX1GvqO+oR67vqe+p1tdeatSr7z7oX1UFL2jNXz8JPJPG2prOEirFs
+KdEoqdVqdSyXC3tNKOJSS3kNN5A+tGG56cWlxO7AwHXYG3vRx2gqjfN8bElkp+mOKA/bROx1kmWr
+hPBjmYhVIGerY5cgNKWB4eZhuD7PcztJE+ZhdwoQ0aKubbF1C8+MrehAr7mxgp7HH4WeRTzMQNDY
+A5BEbmAgieoNJPnMefErGgXVwR05SdSBqh29uBfGE6GclopCkQDdgEgwwOvQqCTAVZqlEYDkxM5S
+VW/ao5aIBXTE1Cpie1TZiWyUfCjzwCTuMCv8b0hp5TikuBkpgNSwYrk+RGC0lyZA2dWUMbTG1oar
+mjLxYJi34aqGJBRtws9C/FRsj6g6fATMG1ERLG9hqzWihuADwGMF2Ecv6NUUDEMxULAvXAkqEhvt
+WETPPAJjgLFYbViETCx5ZxZ+lNlNnx89y4NhWyq3LSvbVqw6TdVzWwo7L7kthduyeFtWblsKWxVu
+y6JtWfltWXpbVn5bVnFbWG2owrYUfqwe23qlohxw6HpjB+TPVeqKVcpGAlkg+mcEKAYwykaSuNFf
+pBrGOrYpRPU4KzrLhWjY2LKFxQB3j1R1E2cXsMtO3pQ71jRKDDCxpxplazXhCM2h4P16zRLQzpBc
+xiVNLuxDfZQ4ntAj6pRSgjOWMjk9ewL4bMMuj+cNASEZO8vF1lXiRiwBliNqpZ7mJCs7yas002Fx
+/H0tjunUllqJsoIQbsxJimUkxS5Kip3nso2SYhclxWbEA4Wot9AoabqQdTK2acuoWhbYOOa6Tlxm
+neDO8lIlsNPCThC2GzNhs38aYbO1nDipnJR6y0nTS0RLvIbEGgEgHiyYiF8Wr2NDKj+leVB/GoMO
+G70jdsbkqLXR8OkUUOjoY7BU9Abqd6zFM/oJAg2xdgKFFRm2Ef/cER3bazh5e5Pkkfpg69FLZM+5
+bzX1GE6cmMeJdxlit1AbRPR5BIxTW6Ei09Ow0GWAcd0E9jIUPphAG/+gxA+BbLIGJGJd9Ll06lBo
+MXeH9Lqt7mWXjarFICTJSdx0MgpD9slOMvchrL38OBLiG9oqOsmSjtGtZikvKyWSlcU+e0m9WtEJ
+Lm5WRi2v4AQr853gAZl6wSOWsjO7+vNI5e1HKmQFmEupkL6toKXcHbSULxO0vFFg1wrj35lddoFd
+aOYbDrPLZpNsZ+yyjUm2tUm2ySQ3ndRnZEbZsMshCIZd4CXyMByf5zmaXdCdAkzZ5WxL1AaemaTs
+6poLUQjYoece1XZIArkTsVw8jw0pVMtA1TtCwDIFrHoDTllIQ4iFqO2xii7SaPQX0AdBSdx08NMy
+NgcqS5pEUyRAZnC4i/lsU5SEfLYyPtsUzsQW8tk1fLaZzy7z2UY+88BkRcrn71zvRcBnOaOmJX0N
+z2etjOlWckChQVLRM3u5vk91uDX685x3t5aLfQrcMyBqNyRLBLTtV2TI/keshY4qdejJz2pwswbc
+09yyXDymGmgmL8gO7n1WNe38UtmCFyQvqBrAz4aTagL0/Fg2MAaWOxqgi8lZRTEEMuMoF8tQPK46
+jQrOgfloex0Ea61Wb/M/kB7YYTNIlsEW4yC5CFtVoMHQGMqkDFu+CmlBDcDeJKIW8PopAeZgm3qD
+iPqcpCBnGMs/hG34Zgk3aa5lAATvIupH0g8jgkVI1LNFOGcZzhCT6j8JBANANizKYwBEgdrzXGup
+E6oR4PclhdRrqeOqEeL3mKKVoXRUoaCGELYvIvQocnu4U3XVwIA7MGAP+Dn6BNQj8LTCkuAVw+Q/
+OHyKPogGM1RAexlQxznq8HUHbAA6IOoJlwox9t1vf/HpQ587/cJ5cRuzHFidWEwf8tVhzlHHsgpW
+zK2TGwmFYbxZ+hMs3NDxkuqgy7MOKr1Xle41WAhWNXSzyT+iyd4lJtMostEZiLi6JlwMFryaYhYs
+nk+ABeAB1oQlDSHt+0OzCAjqUosWIWJ0USnyYz9Ra0NHz097e833NV6KmQhbrPegbkhxzhpDtnTb
+GUTeqQbaDTPuC+vBgG/k6rOpXB1VYHcH1oUI4UwmrCygZ6QxHnEfCJavDchrsmhAdGdOek8TKGM8
+XpUNJMUpNh6nZVPyMiAyEYM8pZcClQ9cMhdfkyDpDpqLAFu7jQArbzNkFQ+1igdGxaOg6pOgGxXH
+llgaFE8CMjJTzZOsmgGWvwJLG/uQqXikFdwHBY9wv1ZyogjkBAPRZPpSQb+jIMwvj3yQBf0Ou/Q7
+0Eys5fW7RnCIADXScBd5FyR/tBflwWX5gxi1UUNVlDQ5xEGi5yCf1TTIq2kNMnaQNGWMtJnHwta3
+JuxDUjqhytQwHaLVkGYGHd0fkEKmLvGYGlXnFEJIqfBZEz6xRLrJwFqS9NNFKDogNlBeBQRiiOlO
+81EFDgdoT8xqmp5WCMfCnvPk0M6w0mkQ1mlGxL80Ig6qRsatJ1PIwKUFmkt9mktOyiPUpBOKTI72
+rC/pGqs9FhfoSX3YfUHpYxBGcwEX56DYx7uFkAfQDDLtPVzU3rVhX7aKPX8VhSwLIIbpMxaPgB3P
+hBc0jCT/i6h08D3O6hg4SJy4f1Q9g6Sujyg0LUvBwDQGNDYcJhzOIqYUJ2GsXKM/RQRGVCmjyIyv
+j8gNFpAb9Auw/+xnDFskK4HKRzgsu05TGYLqDhIaS8s6fB4lMEwc5HGLO3GV24bSgD2pd+L+sXjf
+ryod3w2MUny3EENMgamgiNkPXAXjxwDVbGd2JmpZ8JRZY9wfJswFa7wpM8YLwd6WtJWZ6LLF3Je3
+xaJgi9/XQK8GiTgueEfTzS+xMTXCJXLmNhniWxt0aMN2uAT7GIB/Q1celOlIqc6Wuj7PUstgqMtS
+YwtkhMZSA65uZmRvIhs7iMX1+VAsyIdiQT4UW0imughlNUEZ4H0nxUBsYX51ZJdbMNTD2gTUuwx1
+IRALgA0L00CsnnygU3Xsmqq5tXwYNkzt0sILJR8pQF691B2EBS0hkvP/+oXnS+uyACygEOHU4199
+4/vfPPa9HgFYnS17vTsAi7BzYCN0Dm0El1QKK5kZ37+3EE2lhmw4sy/13kEVcsxASbdxeSjaSqmg
+f/7WwTkMjMnbTACW9upwJwUznIGpE01yhAITN4Qg0tjocdqafTkQ80OxqAedyxTAZqFYSrMegDNC
+1edFZOGasIbwyVeChBV8z1lj6Cro7M4pNC0VzjLPK+0I2buwfBrXhNLnpVzxC8QvCK3itY/m1+42
+QSuNxrCarMxyydT63FDUnFJec84WNeeC1pzzWmPmNDLnkBq051AfZBiXW4+D6Cmy22ar9XiYm+IA
+WQAj8ieBRv1SsQSEwF/BfvvHZGMoKPsFBmEYAWbZmUeJ+bRY0UWLFRktlJ+E5sgcuq5tki1L3tOp
+2rYQUqB839KhtvJ60OAqq7WmFCCGFnUwqOSJ18L1jlAlSDZ2joy9KR9tDOJYXKJF1quMxaW8GtjX
+FeuhpZ7csCEsW6tzoMBjDY6JscqYiB7jyK8xjJguteIxcWsoaHE6CoemoeaibMEPNAfjRe81I/is
+JEUL1o4IjQoWa3k0KoDGqlvCSiD8HgQHLzgIfvMQsH/wUGN+ZDPf1/fQVaNPoEdVcPqhcfHVDHz/
+IZgDayyMa0cag5AcV4PhnJ1KTcIV2ilPq1M8zCEajIkDDtEgMjqOERLEccc4o2M/waLnU5ygEVKU
+35Au1roy+VJeo3tIIhPj7OWD4nM6GGbtM8FwalGkb0wIbXQuR89zaBYcfZzlFiPDMirpcuGR2Pvk
+aiz/8qyh+EHrIbglG+1RCe8DgWVYzHiGQSYQNQsyMVe6ZKTUO146mmWvuBSr4lGOY2NrjHP1YW22
+XuDU7Ad8nFk8dEku7EexsKLnupNkdMg+pudWcrg7Vz58iZWe686VswG5hQ8W8+VnJB22Pcn58kGT
+L2Pfk5xjOlh+CsN1lcZmEROmGJm9VZ4czMuTg2KefKCY4h7I5ckfL+TJfhp/BRD0YvQVQfQVMCf3
+FYHsK+TJ+wt5cvBWeXLtEudgAbMq7OMTLr65xOw4TJ7emzvbwcQ34Ow4wDQaB4meg/weh1gByC+Y
+vXX5/DidSREA+tXIBC653itPjfv+j1Jj9VapcXeOrpEISRmgazZjK7Ny1pwYhaD94BbD/NnwXtlU
+xjO67BlVl2cM0WVr9qePEDJpuICXxNr/KPBSOBNVZbl4iK+hsbin6eqEYMV6OvcAjyjAI6Zg1JGx
+ynRzAE0yqNHAoSYefzAsfCkRrKdzu7ncUgD0foJPNnBHHr4E+KtgGR/licM5MS+tnuSseit7be0V
+zxDhX1LdvAPia/tN8R4xwxL6oIAZ72VzQjocKF/mcKCWS5YDAm1qMl/LRb+Q8aOJGkCjHfioK6Be
+fnpYUcsOK9zssCJkfALEx88ci8pCPJ6jz2ZZyC9zaAFywF4jStcNe66rPXDE6zrIoz7yL7m0X0NI
+lzpvlpqHpX7xQp5oAXmiMjLWzzyzfSnP7Ok7fbxU9/K3/Zk/tnv7Y8Yjd3RrHLHxaIIlSLIXFjkv
+rOiOGj82ox9o9F1E/9IUoQym+8REH+6wZHAxjZdgS/0kh3g4ckwHO0fxGY/XST5NF9pDPDT65CyH
+tf14xcWTklkrveM6J6VMXyrNidytFgIOGK5HoWZS7yR8MjYG9ghjsZf3wTojKoLiXpw0opYR+Vqd
+ERVTyYNSC74Cn4dY+PpghU7+MYbPPz5A/mE8S73R17EJHWB6U0+K3POmnqi0YhTfNCX1kfT0B9Ol
+VCvRePwMdjv3/26333azx3VnhHldB7b6hMi5irc4MFLp8YxIq3RA07SSZ2c61attWZKX+zmyRBr/
+Ox0IbUT6c8jZRMaoM+BIuw0o1hqWhUTilSBcwlumfxf8vUhf40FQG4wfwuDYwo8OjvGIEd/poYkD
+V4ilKq49lMVAMHiIVraxOMzxzzrwO9kKJ0UW+FCNvTyuRDVPmzPVUjfjxWpL3RSWdPYskgG9Kpdi
+a00Y4iW3SZJCRKhVQIhzyhIWlxJC34IYLr/nGIc/nUMP1oxx+BKYGR1jRgMaQD2IDzyzh0MpubFP
+x+sawxDlSy1VN7N8gWDltsrX5agSmCIqPI7IobuS0PWweIMOsddB/puhu6IHuitw+HWI7otd6FYM
+uocvjW5wheiSCPhYqqQsQBethcHDEp4mYyaooZwWBgR5ff2OdQTXYZglM98x8+23xocE0TJzlZkr
+r2wuEv6M0e8fq8LzZqPeJuCRDatblUWmYjIVdNmtSs+bCqioFmysBPrqhCos8g5yJkA9aCkvVOyI
+takA4UcUKGhMZm4O8TWijP4KkWyCDmDmHaOS0bMgelobpG9QCQ+zb5vp44ykxLELg3x69utostrE
+CCSrTatbvgYCjZGZWlgJrxporDJPXQnVZzKrW3zp639eZY7kzGUdSQzkin70iAlSwMqRCOfEa6k1
+BG6ZH/ji4c0qcQ2ZdPRB+i3uKZKF5BF2PNor3Qgdf7efvNLKzCvdTr4IJoyom6h4TQff/qUOaiMf
+ZyH86DA/+8Ol7Clqj57TTeBcVnJMtawp9Rlei4iiIxbyRCtZXGXOE4Fr4dyFomojq0dU9iL6BBDM
+Tp9EZ8JJ0uLQ822UFhSzVFrwBhQjJqQlSws+ABT0SAr9LD7+Qt52PWfExugzKMyh0lplqK6MhUgF
+Q6dcInHN3ZJtwkamBTjd9cX31Fjhx08io42NVOh+PE3b0RJlPL2NtO/h6J9bUuqfkdNO8dnRGVl4
+diS7nh3JDrca7bezbG+fyQWd7OlR8TTE0U+PZO7pkQGZPT2SdGV1ga+sZvOvB5xsuYfSuysX/nkJ
+EErph0d7ILynCyx8YXRS0mOjCp8YYVFfhWKmhvf5jZDnN9xexymXjlkobqjyMUtVH7OUzTGLg0cJ
+C4NBpEM5O2sxzbkcd04Uzko48axT4tlQvllKpcctYA/puKU/6QeC9neloFne2c90mswfttD6g/gy
+JHfiIosnLrJRpRMXyVnScYl0hBxNNvp0CkTaqhpR3JcBhK4++t8bHu5Ula36MFnp07SqUqMUkLNM
+JwLo8XE6ItGXP1c1+jDxm04k9DyRP5SBHto/Llcm4U6veZN37EresTsRN4VVqFg7qgrWxLEevWDn
+hzjEbgPRHPpK8ipVzEa5GLFAYDHdqRPX8MrRi2tdt9QMM8X/7cFEOUNy1ZFpXUTA6yuPHxPgGmmf
+uWPKFjhuFiCoZeYIM2JBUPO7iRhWzOsshv1E/vTqymDruyNZPBjC0x19MHRGdB0MbcpsgVe4uP6W
+MQVeXghPiyx6Sy+tW+oOytnBOB7Gc1QP0mXJjide0OMa2wNTIM17oltTK9BP99teo279b3tvAxjV
+VSWOv/s+Zt7Mm0leSIBA0vbNWG1o+QgfJSlW7YsFirSlav12LQHSwgQCCYG2ay2BYkWtFrUqq9VF
+7VrUVtHtKrpVo+IualXcZRW1KtW64tpVVqvi2sr/fNx7330zkwAtXd39/9IOM++++3nuueece+65
+51Sv3iytXlJo/oBOj63SRGTtzbxg0aCRNCgTUkfTqaYvU+NsRNGPjqiRDMVZSPD14pXVN1Oi3LCl
+qrkkqUaBK05RTiqY9AMtGhJoXUyUrpPIZXfZrnNsBQPD9ShBM7uUBSwB0DTGfLo/Cb4nw6chPuWT
+fqkEnsIEcIokgI2aADayRrwxoX2YArzEOPCyE5LFm5HJdMBV1xir0TbtLRsDPoBuTVXCW6xJPPIp
+Jt1rxOx2iuTZKZI3VZK8rCR5U+qRvKmwSLKlydGUUo5tGBqV0SWQnxTFm0qJlpAUb4q6rVJD8abE
+D5kH4ZLi0WqdYqqhx6B40UTcEk26aiGbSDJ1eqj6OL6GOk2uJuxRGwJ/YtSmyd3koLrXSKIm4g6W
+G3pw5GRkZDKunaoBAjWKJuExvZDVPFR90l9bTVBFjhqRyrFBn52QowOi3IjkyGWZOLUKwmR5qYPs
+pjR6ZEz0OJBGj8MSLQ5JznhQduUBwdZgB0SRNkGEDoxcuaghvNM4yKakLCexEi5nmC0pHCuSxLtP
+lPk8c3JUBIGx3E4PrXiumYva7y419IjSJNIA89zxCZ4BDaWqZIiQRTSqmh8QKHsW2KjgkEgbFVDp
+xKhAkC0s1x+kUIhWicafhDFMSJ3l6pbrTqieT8C6MIV1UN1Z98LofIPZKkQbF52rmW0jn2WgvabU
+HUNeNulyotx86Dx8N86HrAiAceATVMlEydDzgUw6Sya1ybYnmjBNK48NuKBgygc6ouZAB3rygDQm
+5HnVamQ1p/TuUAKJgwZoH8De+fJY19YK5UY+1s2mj3XlipiIONl6b090a9Rw7/ZSezSZfufg99nw
+mpDhLsEnr3h4mQnfo7q0W/AR8B66y9ICTNcbxnOViajJJC0Y2dTZaD/XRpvcqB3vLtnR2ZAe0yLi
+KykZZvSoeJqQUPUSH/hE2GUBHCzgvvDJwW5am1I0udsQTQhK+fHFG1va9WT4xmMWelgSdMlR0O0d
+fCfim2jvlTHMqvDymEgujiH8JmDeCVAPb2WzeL9W025TgOK9TnqteGOvFbOvTQvp1KHJpBtnpP/Y
++ybd+yaz90xqk45/8H9Tx6uMNyfwr1CSBNqth3q33sS7dR+VOnjNp6lK5NWDtk0LBNNIWPCgDb7q
+K2KaNegW8neEB28IEDPUTyJZ44ASM8nSsBVGdTN+FU9SSmZC7hfwOm/DfwyyG6iVlJqXEM0RaVIA
+rABwAKGeHJu1dubkhDQ9ZaQRMDGTeXco1yrOTg7e8zzlUvMEjGwCdDJTCpFm5ciQvRryJuzZSC6Q
+R29kIxdUHb2xqb9JM+1xaGaoaCYA1iZgoRGZcaSb45M4OzmJA8GGYW+TyYDNB5e0BRNnFLnHpCm0
+z61ZVyk2R4zFlyhOTO8+wdblewWf4j2I+qA44qx8imdcUjuiL49+fjxVpMuqSFZZkbbouKmK9GtV
+kSGbWNPhFOl/6SQ00U7mTkc7efQ0tJN/NtXkf4p6anT7FH1QuHjFnn6dOHHiOYORWBQ7wyWH1hNr
+xKQHB1c6poD0tG8KutNOHivQN4WHE/dU+qbY/Rw3t0XcnEnUinuFeTboV8JPnPxgkJZLUfYvLJP+
+v7BYdjNy5I1UfEeeNzpQG16BDTNeHkWdBLodQAEElZZ0nPD7WxDdbeP2LhTaIU67iQVjtvB+0rn6
+scveDGT9AEv8dZsoO4xXVALyAzmRyAUTVHDlPsDHa6nJBV5HX7515D1Xh+/buqT/l3deyTkB9pGu
+usZ3KPEVm54GTXc5rXyoNq8im3eHyk5iWILXPNhBAamLzhDEH7mFRXd1wfYMw1u5noDvgnkv+4m1
+wxaOEoA7TKHcgGEwPojz+Fp6d3BpFsuenkfXnEe2lSTHEnSJ2mGPEy5fd/boVX+cXcolgfDvrFe2
+5z+/+vV3v/OR737iN1aXrMTXlahjA1femca3dv161J1pyqLcdbikamadv1AwLrvsUETC2DORmc/o
+bhPsTwBBoO5SH7XWVuh63/QKXQEm1yKOxkQUUlDfT5p6YpWO9jJCHgictAcCx/Qe4KBpqSO9jNA1
+fkddaOfeZ+KvEh5m1Lo0177ssRP58dUwWWgZRQsALR/14iwUbL043fTirJlUnseCXpzKcwgdOj1q
+pdyC2NKEaC1ftSwwxri68oJZeUHOVkFjTEG1ZEvPHQU904X0TBtlf35APFOWtk+/tMaTgsQTiSBR
+kHhyOvnZiV6eBNFCdPIRT68d8akUGwdQthqqU3+o5WLKP0Gx2j8BFX2SAJSlCSgeo0WDYwnbCk42
+PhqSxrGCpsJyuX512yhZut9nLFX3lOBdUzFSXz1zPkinxJV1S9+glrKxFX+X24SRf7qa+eFiWmCt
+Unxwvr1cU3H0f/IDKpmH2ldJVz6ysJ3KJlWFkG1DJXyLkc1h6oFPy7GxVeFe7AEes1R3U8T/Jrsp
+Ut30T6GbSfurZPsmGRmrB3ltJpivMhNsGu9lON7LxvFeNjxZ5Nm/jVWy9yUL+rSWbF0U0rX/gWWC
+2DJlJBI44+2iLnW8CbdZZDJTn+1exRMt4X+b4ImUDn8g5YaFRSepYHu6gpuwfNOTBdlonfXmEaKg
+RfSTXXZQQxFJg+c6trDcBKt/JrHajX9Jv4IngNV/oJJF6OzqxI/W+Fg9Lm4WarvnxLfSpBcUbVAt
+LKS9/Hg1PYnun7xyo5q3MlZCNcMpEoR2dGNXEtSO1Y7feYsc9emMNXgqxxqkx/pe6mBAvsBA3gnf
+/ERrYmi9zYTWeJiRr4WWiO/hzsAm4dMmOfDHqSdXW48Vf+mJQD33VEI9NxasnkhxdWof+Sbnw1Oa
+sWvwsYajpDgZa0cDkmdbYJKnRcUC24qOQ23HnWR/vJfOSWrOB2NQHFJf8B66gPODIgCr8XBW8Bff
+AtJiewEJa5HtkPB3OQQKq8X2QhRKAkz58NYvXvIBmQ9JcAFJcJjsIYDSr0ISTDWUQ11H0ayjGHC5
+ohQ6C3jbjSuEsiG96o/dpVwS0H1nvbLlJvTWR8QIvfU1kbe+GdY7lNBJRWtqFapWu36tSuikLBUp
+ckpzHcSwQvgPBGWhUK4QNUYNzMzM6+sJV0jw8lO87mAe2hNiksh+4xCLKumuLoIXnVSez2kqXUgL
+iu4YeDMuNronQdWxX9rjvRTjvCQTvfn2DSzR1OuxGOOF1MrcILekWppweVEdJAtxak4vqzxdvbmK
+Fg+1Wr+ORUXB3RmvDnICO9Yu63GrapsFm5nDpAktTWAnkLSt1hKWqKkr2R2bptFIGZyreHv8FO4E
+fbVny429E5xmHUTc66KdoE+L8rC5E8w9+a00LbGgBz07KP5WvS6daAJvswO9hMiDJOpeTk3OfMqA
+mFXD9esPt+fXX/3CT97xq+986pdSU4UH7WcEZkpCbnBh5+xYiXDw3VuUcPBfrP8JP0ngdGqzCK2q
+5Cx2bRY7/in/kllEbRYnPmLWEpiM/hQ4cSD5NZq8JbuX1UXcGENyyUcD8ijL3nsXs8dSGgv7UHXS
+7kqh6CXFnCafeJkCdf5/Wy2B2NKJ6lj9mk79Qoe6DjPYiw2dtf2kddbilISU7BnWq3pKH5qprw8t
+e8iHP7xd8mFPes396HapDaKiZ0zR2l6laD2XFK2FlKIVmeVOQSvdlzpLV+N+gfWshbh1baWECgrS
+rxYS/apPStWCVqq6klCYfkILpo/PAvoJVXtS16AaCuvd+E9yI2+nDjvsRKK+NJGoL9F4iJ56b6Fj
+EvQqavLwjJkHQA6E16uHrsfHR5abWHKWLJQw9lJDF1DEVVSQ1UcZuYyUqAyD9muW0epiVmH5KePe
+9CrcM9H3CWEutVuQWOYoLHOrsEzAYmbXZFTPw1/81hsz82Vd6NBVknp8LTSyijSyCtkPYSCrUM5w
+UfknqtgTEUvU3fim5OBL3Y2nZsOTDlgVK8PZKNM544hIFCc3sQNWkXLAejrUKidvuqWIaEfRt0/z
+MAiB+bhU8nTSyqyUHS2V+OWgy+mQx758HBrwcXCyeTspohpCz9gncmurSORxq7qymyBTYEDmaE2O
+tdIZti0dZY/b4KXcoM5Zt7pLzQZHa3Kg9219UjYv9Wp6l9MqC/t49o0WYmYnbLqr1MHTVeDjd5oU
+4/idO+WTwXNSrKPLWR0/ZJkXwNCa7DGycnjI0pfAbJyjEcA8vNdzg6Y6x6t8lTNBoLfhx+UNHx4r
+9FvIAumO39DlyH3SakZj+LW2TG48yUmyNh9QRgNhpechSNpZ0E6DHWUpEfv6jhDUfAlnwCuZyU5i
+r9BH7zzu6rs/3N06l3++mjX9Sx+0/jc6mM4pP9D5sR1MT7Net12K7YLE9lnW7YqHU9Ez42AaDSjI
+4ylyLjcmouaXhRl6gTnIJWz6yRI7GVVeqq9QCWbigpg43l0gJi64VmTiGUIukWbiIj0XwoSjwLkQ
+JhMXaiZUV99CmJLTTJz6aLMdzmUYe8GhTrKBDd8z767E76JSjmbgVMoxc7xnO+/UJRtXajNHeu53
+JO1w0rSDrF/Jcz+aYBEV78CWQeiUtBwNcYoe+sRTLNyWLDxD/qMjuhPgMvQSLu6g736XLaXn4Ymw
+4VEjIw0f7ODk3SITsnMrek7KrlmTy377OVerrKmjuqLp5NpfXs7Xrv0TF+Lt6ELcj+q4EPfkFVWL
+7ZukcVGjRXY+MPW/3pZ+fgvtQtr5uUyJFvcXXh6jzC0ys4XWPioxqeG39DyYmH+lLgFbaP0l7/DS
+7oKUBcxY2TzD10mRoF8oCIFgchhJEuUL92MTZPimDIkiEXy9IDJbaFVgR4rcP3LyZEl42Swl2Gxa
+gDf5RdmlbZLyzIZLoMHmw1S9Bl02XGxwYavo0j3KVlUd0iQycURtiTRO9IjmJXms2jyc41wzR1SV
+A5Kmk5LSprzED5kreGTCFaFtZclWvEPbWNbYCCKMSrjnXw6YX7SIIk3HAD0uiCiyUpcq5V+YVdlZ
+utzRFrOjrUlPbIM//QWMiKrtTFebdNRPunGx6qZDN13T0+ecwvSZQ7Vrh1qwT7MOUacOZp2MuUy6
+U/PQQVZNRmXtBmzPPaOwbWdsiVSlQkNWpLBFUO5Q9qH1jPYh5D60nHR2gfchcZeLP6DV7ydws+/t
+OWrdfHdCCvxEvgo1BK1qLKc9MvdcWlx6UlSz0mtAGjnL1zx7phSHkmvZ5j0k9jFkvLVSI7u3pxW6
+qBt3ky7yJHtUwlhsCFvsIpsMe2XJ3jWqpPEOPSPYBkI9xaPk9phsUtclPeX5z/BgGRfQYkvVAVKN
+AlJ7yWMgRamJbFXziMM3gNSRLCuLSU6Cq7KL5HXFQAtpR2uAKQAe8DTgYdQuA4OELWZySbb7HcpU
+x2IJczYEuZywc47rZbK+FWjEotNKOelJbez1w1c5srpbok6/6SDvJBm8k2Vw62Uw1owwgWPaMkvU
+EUhD5cp54lXYT74KUa+Kk1TQGAQTtNTyEUyZGlvB7+3EPVFo2F0nJsbxCNle05awgI8hunjDMJru
+MtJlifg5g5BpaIHVQE+FzfERfCrQU2azfl1EP8zMcSw2WbQSwdzSegZLmixa2mSROu2AtKRMeI02
+i6qVUWpTenxOZWmkpwmb42N1u6V7nfRT01LlVcJnm8Oy0x+JZdxbgKLe+5CWWfXSJr8mKs4SGf9X
+5HY0lPIbAH54LImRBOGnSGh8qbC3yLVaVipZRw/O6o/sZaTvgjrMwVlS32Xx7QU9MsiGI4PRfM1N
+hrO7ypKdu1xIjYIG1pJKQl9QeEJqJOFeHgi/mYQOmoDKmcN3Yfgpe3h9m4Ksn8sEIVI8Ta+Q+k8e
+PCJPoTsl+rkdn1uT55YE/LbyVyNhb0u9fHeFNTjQNaOj3TQcSm1PpYYytSWV6svUBEaoBip0Od28
+7FazImY5PB2z1ElvWhHTXeGX4ccQ7kggUCeyvPr+BRdN/KmoQ+vuBs9yHGE7gepR+KERrbnsriSU
+hXbuFxtUXFTnsKpy4Pvdhh4mUb3sqh/47bWZBJlGrTpEKc10fDzUQpZjsfU+DxchZp8LCXfcNop3
+XiL4eQtWg1SMffTNh17aBPn56AYLfl3M5w20aML/oBVk8ckKVMtKLO4wFVAt3KZaqCqYOVnB42+s
+X9BLD8Tm3AffqAey3RyIe6oDcetWe9eTrZZwpqUSv5ZLW9yIzSo/hnM7NOdwc8feoJt7rdlcOEZz
+If1qr9ewfVoNj565hkV9REsauPWJAFKqlCXltIIXSmJtMiGHFCGSTqM2yziXsCiAWgeda5h02sFs
+kk5/UlCltfbmC8nxE+rCrMs4Pq1PAW9gXwG7EpBO0c6k5LB/NTFfxmujcAzonRYXvXQyBg2TchlZ
+IuqXC7bkHh45RfssK56LQlUUSY5tkX+w2DLCwCXOxd5t3K8bESfzGSlvxJFeKX6dwg7tRHI3X4hL
+O5HEQnhbbi8v5u4qt5LdNHVVDiYvYweTl0QyegipvOp6mDxY38Pk8fE8TF5S62HygDb8ILdQUr31
+z67IbKmjqHbYP2FV/LsocQtcIt+vHaQ69dQ9P7ya4pjqoMQPDLkXWURKfuXExC1ktQ8XdmKCKYbb
+GsPFo5O4eETvIyWpb8H6feXEBE8X0YVJJm6GmjJSC2jUwO4pHR5LykWFa/hJpsGYPpsuZVdNl7Cf
+iotRpUyaU9wxIqKTaiObUmpA1/BKLGa7DFDU034LSUfanbp8K2sru3z7VgUotTjeZaJMZcVnR+ry
+bQeXEqx57bA5LlInb8/phmUpS47jaTXoO7c2OytwlbMCvGSLPpdduuQIcjCtoyz7S6zncM9m3w2G
+nvRf7ASROk08SiYx7dCsle/6slOxKUlIMhg2zqrLWOOSz1Bhogm6sXbQBxA5CkwmLTQQNuWWxJWh
+d5rYQ5qcCdpLeCn/QS5rqSMNYp6aSE2NI9VyGZoH/EUYcW7J54J+aqgMY89wCIFA9auBmtFAzUqg
+6viVP3HG9w9ZTYifqHdIR4mQHYmrSF9iE3mH9LR3yMiTviHd2KeY1BjP5ddffc/XPvnmH3zi19bz
+0UckJj368Gt/88lvfJeSCObEV9zwE8ygYtqO0SYefuGWFM+CiR4Q4XsCdTtcN/moyqiKKQKeJ594
+Y2t4/UzStP9PlRbqs8Iab5XcoDdfeQK1jAHYfEzCiXSeQCds1Wfuxs4quBt30ZHVg08jgg8iOyrq
+TndU6ZEbiNYKZRmVj2Glx+2S3aIstraUKat7rymfhg5OJJEuqQuweKtPCkdUcJUsR8nFrGSyahWO
+2KGSlSgcA8mmUvXxL+Q/vqkIM1pVDg6stKpsupmjoypH8KYpDt55LmrxPhXDFTc3Vvg2SQvYlb56
+2kleXtSTDLq6oUxham8I76i/QahaXMBUjws2H9R3/6kuGErZ5jv2EXlv4Te7pQtyPnZyRuwuZy97
+bd9lV8oWuycXsopWPqwlRnqHrWnMHlsRmfge/ikDvKLBZy4Zyogo5/F7hwjfrTjDcZS6qFIkKbdx
+8QKfpRZls4VKuQGfyc/SiM2+Gh4TGBMCeRQ87BRlcgSzS2gvlZ3ygr/mqp3KdQxC2qHdKw1SwwQT
+w4oeairdgGI1uHY6LCkdtVlUOoKXlEeFjK+Q9hSKdfFbPpYj04T9lsprnCJC5UekcwPB565QVG5Y
+i+y/Tfs/dnmkhk81etae4aaXpKBEnNgQNFhOcpR/HaTKlHWU7cWa5ZjhZ63bvInM+CZKccnS4pKM
+GGol4hJFWxxfXMoxdzU8XU5S4pIdTSJxKQ+czyZ/S3XFJd8QlkwP1ox9hpi03S5ZEpEmSkSymYEe
+JxmftJf4z8RkVfM+TIlKO1Ccp+ALhNjkRsJ0UXJcuyhx4u1JGMgR/ikFJF30g1v1UuBi+frFAtnZ
+iezV6Xi1U5qk1eaoRYpmzYi4LSljdxW+VMtmo9KZjVMtfVksGdiJ9OWS9JXI9vuc+rK9XmBW9eIS
+1avKfuLLiWh69YKy9II6ap/aasqf2ogeEHpGDvBPgt5+nBAHZVGMCQwiunQDAwjToDyiHGdiK/sC
+Ut1jgnd1x4UExA9uxSafxnnZBwuRNScugGAUhK/DsZn/4igBGgdGRuXGD4NqxHcmj/fB40jyyF0o
+25op6HnANy2V8kQW8BI6T5EgRJInAm6gGYcu/aBdiQIueFiH5YgPJXE7DuqIpvEDtnJDgxwjyiV1
+T69EPr8YpWgnMAv8uC/1iF3aC106Lj3Y7EATlab59gEd+IIYF2Xfq9FGr7UDdiX8pJRMmcZpZaSi
+7TJdqy6FTNAaTkUdz02X7FAltdqWjDj2U2cVWRjlEHfdNF5FZMt2oq2ld+dWSOoyk9ordP5mJrVU
+SDgxkwqsYdVJcodvU8LFTHRwBbUqVtaejAHTYfQTUwma5xVSg3pMLUpoYIfDi3TE0UtxxKnmeRzy
+BhfcW6QBnVqiO5zUEh1xUksUyvESlebldwg+2ptgHOrxm+3yTd48FYX0YWnRYex5PUkBGQxMpjQ2
+jyokYGqVSvdVup+SAHY6Xc6oqEOyjo8hATApO15HAhifYCGJ+5Dc7IXk9wkvqyVgCDAtQDFZRMWq
+c3nLPJe30uJ9CU+GQEwWtPErLKQ4Yd4wG0IUk/N0pG4npZMnz2FLv1ieKa6zv+bIr5pWNeEk4I05
+6SRY1pt4y5z4FMt9b7JpPs6LUs8wM96yrQ2xHhPlnJxiScfluxwTIprKt+JUUvQ2ZOhS1B9VwW8i
+uzGFdabQqVGuSujUHaoWOmUvKGFUxCMYLSa+QJa4h572bjMA/mZH2Gdi36Z81JcsZWuovE7JAyky
+IzFEJj5e5LlO+aw3NlhuvQ3WybeHmbrbQ7T3S28PPXN76NVsD13Ee3f87WHmTG8P//0C2h5OVNvD
+na65PcQIg8n2cF9qe3ggtT0ccUie3yN4f7hXnNoGcaxN44ijNo1HFeaNOFWbxsPqzR4nRQN3AA08
+ypvG3Y7aNB4Wsgpz03inozeNex29abzP0ZvGfY7eNMoB7pObxlFj0zjiqE0jNnIHFw9404juc27j
+FIoRuMNhDeN2h9z9YfAwhz2o4vfBZMPId67gfVoAXk3bRoxIhg7zafHyKt6dAIESw4oecCrdgGU1
+0HZJNjoiGcdxoWUeXOVpxrGLZSHbZByPWSpveut4XHTZw8w7NnBRKexOlo6PKR5AOWTP4shReLeV
+V6PkTiAw3kdC5z+MyM3WPrvogJQbckBMzKC2WVVFyrJQokmFolTFpymaI+W3Es/N+2zoDoYnZClQ
+YgHFfJwQq10TPkI2f3NJSsDT2NsvVibJ04QgypGv5OYod3ephft5hLQueseIfulRizDD6i21RE28
+U0UfpSEpYsMCRXtuSfleDymWT8pVvWW6qsdTFx1ffWLd+OrsYN2GqjLSOX2IgboHqewxNu9ulYOB
+n1MYEqWp0i/7JGe8NRzSjE7gXfkEuStv0bvysNCsx8S7ckyJJqac2k+sjrfexM7sKXh4KCP9ym15
+SLUpV+xhUJggjwyMSjhaU8hgSAWNDjH7xBTuTEy26Ads1D3A5koGix612c/v/VL3A5jUxLMFXbi5
+0uC4eTuPezAZDBX2vZgqbAw2YcU3RxMwRPgvv/gPH8ksaoO2MQwops6C1Ed/KDBNx06fYMZODxOH
+6zl4MEJMTMa8kyjiJ09XPIqnarGtPVQf4H17MyMq/myJdLThZDhtGOZjsuH9uiVI6ryT6nRPs050
+IZuMeDEGQJpMJ51UrapT+Vrfn9Q5asTyvV/CfJ+qUAJrcZFM9yaxAT9WqAZ+GhVG7cUGjgV5jNAu
+5eF1AxMCK5oatcrdzFSkoq1VR0yMNNrz7j6bTt0YBEEKWGlMYg+7Z7Zh+5QazqnSlun7WVG+k8AO
+MpPL3smmy952jIM9KWo342DzBQxLn/DI9XdJcijKUSWQRDTVqxXJbRzgLKFndrN2iuZQP7/L+RtT
++VsDCYOzJAza5GgmyyNzeHW2fNUuX00ygZyanwRQrdEUOUE4N9GUqgniudUaLjmv9OoxSwP4uJUA
+eBhmJ8uHWoqAxfQK42SESQwNIjKwiTQ2OjvcsVRGUlSwqsUEUS0f2E9cMCDJtVo0sLRoMGKfmlzQ
+ckojmmV9lrSBnwfJd3jI4MFlxXJNYjTDIgJHXDhEJJmsQ7tOws1CO4UnNdAlYKpai+XM8dkp6amz
+6I4Uh55OUWSUEjzUwaRkoJBIMenJpCJAhXgLsFFgzhMS5tzOWENMehcz6bOxSC1j5p6Vm5kdN0t2
+PEGz40kFioM9IWHHmBKFppI8rFaSyyPoFj3yhBtPkrwYleSTWEnup2pgBW6eB5szWfEk9IIVpgJR
+hQkrHhFMx27idXID0/Dh0kRJMnGuJlIdNOyJxJJd1CYbHIiCIQAlmkis2cVD09TboA7rnQgYYnAt
+gxkynwEsaUCQTaYsPEE1/HKfipd9zKqOuj3cBcSG3abzkKtYQQtTmrOjdlnqbIRouylot8y3d8lI
+27gCw4Ti7CJNPGnb99vGMZtah7tsaj2fFE21vstWzbdGZ5uE7uyq5ocTehcmDGnDQg7yjU23GypB
+OZT7bY7q/EQZEYK+kBJZCvJQxkrO+5ODGSs5mEEMxbNuFIA102hDtm3WVkwYUBueTlW3hMh4FiNj
+GyMjBodRyB5L2iOYektX7U4Q0DF+nd3KB1MAsJRff7l1bYnaWRV9B+5so0kpJfmE6OyUer05OosC
+ZrTdu53p+w67Um4CBqDUp5NZZYpq8O0O4+F2B8l7XQ3/A05Kw7/fSWn473dSGv4RdUp51NTQW6zW
+b6GI4lKbv5v0tIfTivyHnYo6rjjiaJ3+g47W6R92tE7/kKOUYLiLV4r8exytxT9ALexwpRZ/NPWI
+XTkqdcaoxccDH3RWf9BhLf4eAgxn34e/RtwKkAtlE3YcKmvS3T4GT80m9wQO5xx11ARHUo0QH6R/
+jzqVcJ9xEM8886OJNvABqVNsrNE23j+GivkeSi+kdMy0HHgPmzBGuXaQG0KNtB6Y1+VSCJ6rK2Eh
+r/RTkpUv46RPkgJn1CyRBH62JGcpExjkgLb328ReBVYORCNV+6luLBQnpnsYw7wjHKKTSbkBj5oJ
+/1sk/mPz9+OhDMzdPlsjafwpEi7OkfCXx11PiWbluBSgjtnmmj+ZAJW2YBxbwHtMqYyq1C/H7Ppi
+ls1WqFFDGr3IoFyw6r7whFX3+gCAEbWQqO5PS+n+QKJWP1CrdL8/ebuvWul+j6irdecFiHb7htp9
+xNHbR5pF1tgZavftDqrdDaQx1O4jcl0banesXundd7ppvfu+eni1bwy82jcWXsluUMI+29C7YwnW
+u+809e57mu0mI/SBbV4YMY2A7JQRkM1GQCiAkE3bOGY/uGvYKZSnsP1Cm8jJEDM4DffwT4/rRZaV
+YaUr9IHbGRFlix2rSEUo+Tmh11qHZesIgm7JlwENE/sTliJ9djR5TAd1JfcrnCDDcaMMniPEJWcs
+ZV/L4HmuUcvgAdnxowxe4BCFOb5/AfJ2kS3IS7iEDrJtSiOWqCOCF6SOk0TwsCY4a55kVjMuK6ZE
+vu4/4IxfHbk9T5HbS1SS6y8oETwPCSjg5EAEz7PvlzBVA4tDOR5ryqw3jwJZ0nA3FvuI8lpzGchB
+Nlr3klXUJQgLtO5tYgrRTUeBVAMNugmXfpxFATwXf5HE4SwH3YutxRRWB+RwUp5hJqtupoBdSeXQ
+9ZNax03AOQKyIsY9JcraqhyL4xMWFosIvoCydKdyvF2i/YgtT6m7DWGc7gFd3GVvt3W8d9+QhnGI
+AGOSShujoizUiGu0aPpdASnlIN+KQ7SAKlgWt1HFL2VxG83L4F+QfKQsTu5aDgpqPJcUTbV+UKjm
+G6JG2XwDNt9Y1fzF6poQ1LBLNd5Noji3XExEcVuOZLvN3k671VIxwtB3l31u18bzYWkWh7jfQTpv
+QoIQ4Q5Ax52qFAyCVH0fPAP11ZFNbTyaUpd+9go8IaSLXnuEPkWk590CjxHp5y6dSx9F7kR7aYpv
+ZDRI5s7MmlI3lB1mLY7JAmmYGJBMiXA2HQsTZ7MMzobpdJ5XiIRxQlkIeEVN4MET5Hy9ZCnmk40W
+UAX88o2YT0R56PbbXqFYBCeGFU1qU+m+StcshXBvF0DhIPJRi4yBbBJVBC8VnsEqUYVRlN5rXQ/N
+p8yd9kR0TKAJgc0mBFSU5RAm/CWUIo2ranvsunIOy5mEpjuVBQ8jdIF/7kBjHm4zD/sam0QRgRMr
+Uqgka1CYJ209c1xDB8Xgssk8jzgJjKkcqCb4AqFsJOS7Rj4PaieNOh6RIiXmlRLl+NOU+Z+ZH1OU
+HBPEUXBa01dvhdSuj1NYDpa5HAIlfJgWEjaaXhQV8SYo3Sn4FqT25XWHKDeDUGbryYjku2Zc4nKF
+sqgmuPYPyvnZa+t7uxjGjtqoma8Ru/6y0h2qnjbZC0oYSSQ1LsGS2m5TUmsWYkuEN8Z/JsVJEBsb
+6WptZIdHMa0xmCzzoOlY+HPK50ZuY1L2P5KyBG0R3r2NShatnjc+/LO3/3rf7d/ZtyVoNT3t4C3w
+8Isj1IlnJpe/QvPul+C7Xxbf/QJE3/5mHIBFMvaxrVR27hhlbSrEN9AcaX4YfoHbq/IHJC/Sh78i
+Vz8lQgxIQf2JPRzf9vfQJuaIYfCU47lcvIQ4IsJfbCNKRL8f4d8Egs8xCOj3Y8bv31U5GDpA+HeL
+nRrHGFdi+UJsVl6IJXdiv/oEgsTnrvGlVBH/60cxMa8TPUz89ocwsUknkrPEUUqcpBMdTHyQ6mzW
+iTYm3kM5W3SivIS/40Pc1H/yReWI70MijXsrv4nwvnx8Jz6EX8NMUwGzDidXItWd+cgKVteDgYQ1
+NXZ0Lw9BN8Yt/YGSs9zSHW+r05IwGxKnOIO/NWbtT8bvx2kG7xMn6+0d1K3J1b09ci8mB9zbe/aa
+vY34Vivm+t24uUKZ635qwhtn5FYaxGO4wvpVFVJ+g5DyH+sOsRodldPhWgxz6mHY/xQynXx+HvwY
+1lk0WmuVrf2c3uS4tUc/lgY+Z9lOkPfrQT7CC0mc67axc9Wfn2QKvkVT8J9OMorOU6cLeLFZiagP
+7xxFPWkrcXDq1aFPUApfUParLrSPV3B0jILeyQqOfKh+QfdkBR/eU7+gc7KCe8boqn2ygvvHaFHI
+gsmlcEIDlRvkfZyZ+XhVXOLtdGLIUYVjTqJtnPIF4KcuhXcm0/8lUdc1gsZavP0sg0620lXo93Gj
+MqFgJkh8nsc4C0IU3pRHxcj+j42qMu/n3O0aafkie6u+H38x3YbmbS3dfY/wZjyOCAWE/9AobF5s
+H9fd3uZ6+Kz9oiBIzzVh3AIJx989yve57fgD3F+GbIfuUYF6yURedkqYgBXGuvpcFan7Dq2zT9vj
+r7M0qXtiyH5SnB0L2f+ycbbaV+Jf151hjcHtpoMK7M7hvbo77zO6c0p9qZrlur4cz7zvxgdwAqKx
+3fD8P2db/z9wtvVjkZo9SSCkU02jtPPk4fRnGmQQfEYkDgMivbti7SDf8pcxl2MyiCdPGXSN7iHe
+hZGr5IV8cbC1RAZqLSXpSr7Ae/OMuTdHJ8fsVI+3+OZt7MiTbm5d1uO6kYcXzSyOwK1jdus723sc
+x94ibvbG8DREJtQhecTh4VNocnKYjT6nyFVKQfnhg9bdLuKkDnl44Y16ZyUcSa7p+3xRSUFUKzJa
+yy4Tjg72mk/HFNOTwwjyTUC1GdoDKFLbDJUQ5IGeb/ufS5cB4Ed7OSf9MrXimYFWguAwaWbZGxTr
+SXxTj0iuBDOJLoU9tXgMUun2oIXdHkRVN+79tAsXUwhoDOI770bJd1J8H36HX+KNd7yfUs+KHzZT
+/1YIrz6WyTPDunjlSsPDVvb238IXIxCvsqwNytZoVTNpr45bVJh5S9XMrics6eNBo1IOxkn3QILl
+KV5iKd6Gkhi7HUAei5Rx71ukjGXFdykZy4r3/Y3k3JYUzkL4HsXE8JOsj0lc+P07Fju5C796DvyW
+kXvI8X3o2WO76fsPxbDHc9NH5clLIDX+ZN3xVfv0OxVXg6fiwu/nNJa/IBd+J5MdTseFnzG4k7vw
++zd0DVVnlWF+vBxLSKTkFSC8w2VCoshe2laG4eCQlraxa+nIlS5eBEV7no9elyRUQqDMFCnLRjTH
+sBlovQlS+SOyNewlm0/76qoQsQfoqnLeT48llkilNw9lchNpAhP+HWeGYTm1s0S4ieEq6g4LUiNn
+zGE5jIs0LNsYFjmmdFgYxWHZ5rBsOSzbHJadHhY+lpzUsORernZYp+gc7OeKHv5fdg72iLEpPmad
+zDmYSPkC2/vWUeUL7C61d0x7/jL8fXWzvUxnpNz4A0/ehSrnandfo6a7r72klEZjGQzJ8Siu7/i+
+20er3X111rr76taGM2gVIZnNkxntof91o31nleM3T47W49F6PFrPdPzmVTt+83j4Xrz9bXL4XjJ8
+D7HpYvhycMQelUZg4C92+uaREy8Ei8dO3zx2+kZh++BfdPqWhgt2h1/XwsUjp2/14eLVcfrmGU7f
+PMPp2+gYfqVoVRBzML2TmauZYmKwJSce2KibECLxPSVSvqcwk+F7yqn1PSVZXUE6gTB8T3nse8ph
+31PktU36nhJEU5gqIFnJ0L5Ch6XJUkA0xYOJKqaclyX00SU64ydiaa23J8qR5e0Me1ZV0qq8ssqV
+IcFhp1Ku/tWAvxxFgLhQPWdq5ErK1uSZBqNizYiSomcmLQ8mK2VElQbs/7nz+9/ozu83itP+5bjz
++2E2EX2OWCaNQHpe1/9cPe6vb0epR7ohBcLn322pNDwNkFWM9+eJDHXrVZWGwLbUnydlaejFvYkh
+nbKJRxMwCljiyJYAW/EuNLoRxO/H6bvKI969ypQsh+TG9NdHGvFCo1zYdA3MNhHZThAZDdgU3fOM
+Fg5YptO9Ayr0De3VDyiPykgHO+zLSyTYAUXTu+uJslX+hYJP0bRG4HDSHakOdVCHMvhzGnXo+9bi
+1JiJFnzA6B60GWH2c6Fk+ChPNHQDoAek3tdjuDsxerpMsQHZwyJpS6bZl3cpMmoMVZNIS5uiGd3t
+lm6mbHWVFV1v5Yzudtbpbidmn4fd/XVVd/O6u3vG7m7hFLtLKIA2+2hOJsvmNDL4kspbzCAK6fi6
+tLJk9DqX1x7VmdHlPV3ePXl/CBEdXdbWZcWplUXAH/k/667zN8kW8M/mrvP3p+WuU1FE63/QZefN
+lQbXyuUEoLDAa8e/+rZYVMwhHov4+MdRrPTYXJWU/KZnzpzyzElVeJ7wzCo8NvhIV+HIKsb0wZmt
+44MzY6Sdmg9OL/EAGj9GxiV2+KsRnlRPqo95FCmHnKh+cE0Wr1yUpiuRvZHKuwQgKReeb7dPbeLP
+0HSnpGS33nRHHKzu9zQ23vaC7P17VgNRMCfjdAdpSg80yC5qCBT0eER02SmdbRJW0ZiXRIhwJZHR
+YPmwsf86Ur3bdHm3acl1CJv7x5TqkZQErGUjeVvF/VSbPT+hbSxE4S4q2a9Cty/F2wp30obtkmS/
++krapQKBnm9fhT/n2y+NpD9L3IbuUY6k6MojvQk/JNNgTyU7No81+g6yIPM4xPC6LYy+ckBLdUWR
+py38IZdxDHr8/r9QFPpDGoX+MDYKVa9uu87qFmOt7jQWJas7hU+/EVaaeMY3VhqKwuU/23Jdx2XN
+8e1EiEImRHwJ6G/NJDpgtJPV3FjliLgRqdnHqIS036dzMqcqxwjlaFTN2Lwh/SSlNstyNJiqlliN
+Fj8gyaVJaBqr6czTkatxbJLwx1vlbj8+ymYLSqYIrkVfVIK3CUKeyEjtGya7JUC92JVbZDqyE7wp
+Faz9rKmxMVCtUUG5HT18gYc+lrJbsjfX0yONvQ+IT8CfM0jhJOHJHgYe7Qywoyu1u6RNfQZh6Ond
+PB7wIQXPRsppPqLFpRhXEpc2ko1Rcorj39uTuZkvBZL4kbubQsSyhBLhOQKxIU0uAJ0TBeclHCz0
+MgwBmYm8Ct2bcWMb1bt5zIrHOW74OlZ7ZrDCShmzBfga0ZkOF0nvAFLBZXhvJrbCL5DpqlcDiyyI
+Sw0ZyxO247kA3xJqCeI8yTNxwHu2Am2JYzqv6y+7qGld2lYu4K20YlS4Ao/aSg3QTiNwZrz4iz9Z
+JItCdCkZROESsv+3r8ALJtDqfe+ACQ4/LfUKo29C3GuP76LUf5Sah8Z4Ksg1S4uehJuIQhg4UJxy
+vjLbwkuXJ8TzyZrRo/DZyZsmePMCug4EgAjZR5lHUdiTPBN0HjuVxzHyNOs8TiqPa+Rp0XncVB7P
+yDNR5/FSeTJGnkk6T4bzUI6skWMy5RB4p6eCtzTz9/b4t0Yh3sXcXsrh7iATNVbKDVFTz7xbo1zP
+glu3RxN6ZsK/zT0d8G9LTxn+ndjTDv9O6pkE/07uCW/dDnDsxuwdt/KVjZHRE9Yt2yGhVSYcec4t
+8OTz07FzbtmOL/0d+Hi8EV+14u/HslSoA37/ycHU7h3bt2/vAv7gIwbLEfs0nlZz/vCSFr3LGe+a
+5Lu8fJc33k2Q7wL5LjDeNct3BfmuYLxrke+K8l3ReDdRvmuQ7xqMd5Pku0b5rtF4J+ckiFppMvKA
+osZ8NMBc/qXNRmjMRlhnNprkKJvqzMYE+W5Cndlolu+a68xGi3zXUmc2Jsp3E+vMxiT5blKd2Zgs
+300+jdko/MXNRqscRWvNTNjxFPluSs1M2PFU+W5qzUzYcZt811YzE3bcLt+118yEHZ8l351VMxN2
+fLZ8d3bNTNjxOfLdOVUzAe8A5hP+0mAOuO/HNyGd9DH4dyOGt2yMGkp+hL4ogqi4tJgH8hvEI8iN
+4lJ8KMWV7CJFdKjFsCyLCkpXfgyNHeKZ8e53YekHUjwt3p9if0fexA0de7vZkGDDDeY1dvws1t8S
+CwM5m0QX6oOrOmAHPaKU67HQ7x4qlj2WJmyyYLDxJusNlbIfFZYSK/aXFVMiknNJFNDpexQsweC4
+wOKB1zQCBSvno8YlIGPngVOWW6P8kmImasUkF75S/DmolMMaikLvQsmfW1P8OUD+HCh+GEr+3Jri
+zwHyZyOPU4XVnMdJ5XGrsJvzuKk8XhWWcx4vlSdThe2cJ8N5KEe2lvpADuDPeFWfvCQQouD05Jk/
+/+WthgZEs9aoAfGitdQQuSWQLWBJuIgjudRSuO+dJoaipufRuoLcw+aS0anbU6Ubo9b4Lkq5X6YA
+NsmU6vruSJVsKLXCWnWjRpR5W2OBn6VtKIGCeKq8A57efyitMiAa2LfB0mITSruLiyjMotaoAAsr
+h2K7NAZEQRfvpLeiwIuLrtAWqIJ5XDUBrpSJsNJgiUxgYTtyeRELFNkbEXMCvVIQc1zYFKAPLfhv
+5A4c8acU0UHRtxX3AM1QvFEupsBgCQgEkK5tem0br5krOPDauQIDhsNrx3jNjMGD1+4VxQy9do3X
+zBuy8Nq7oujTa894zewhB68zVxTz9DpjvGYOgXOUvaJYoNdZ4zUziSIsoxtAoIXVkQeo4X70tJfI
+mIsBtmDPspDcneqaeLbFPpBhl4bLABd7nhIA39D3RoKTj6bXAhrhABdcVizoHLvvMFcBbDTjvalZ
+xQ0Jl8nrMqOpMg78d7CqjCPL+LrMkVQZ2J7Ex6rKuLJMRpcZMXlN7MF/O9+eLuPJMm4ynlSZDPy3
+t6pMRpaxk/GkymThv4NVZbJUBpgKUUxgaJ5iaAVigugFAhdMqVGuQF+uOlyBBVyNDu5jAfxhBAsk
+q/e2tMAEM07IezlxtVbZmuBmekb+28KmwkBuh+3BhZIxlYGSo5EQWkEFbUByMEiJKAW0/MogMeDB
+ml8SBT4u5nyx9bw22YKVbqHJoGa76lHHu+qm3memAgvPLyLfEkBDTE5KHbB1wyINx8akukOp6prQ
+90MFNvJ/vTZ+9uC9sOYgO4zRp7Em4wQWgBRObu1rKGCVTqHQkGui6yN0Qyt8eIQa6/GhAsGFC8Wg
+J5SPooQuIXpak0f4BJgUpZPgQ63hq446rwS8gn521n8FnxBZMPKs7QSEfQYX2/9OMwVIdvxwig8J
++G+nuaaStff2erN26J11Z/hNZqriqftT8w5g1XANJEBzUdOt7AHGw6OCfJRF/M1znBw3Ksh59+lM
+Cm19I28pi4cgfwAunBC3oAzSYyMyOEnLB//GRAYivy6RwYstVDVJC3X05+yV8izxQNv4WdpWthcB
+P0CqByU6ZQmbSwRmCZkPvQcAqeV8DudrrJMPPY0B0eZ8LudrrZPPrRAZ53we5wvr5PMwXyjzZUhL
+hso1HsiSNjbVN2RlJ0gnRLm7SavtoMVFrmfk5lvQc0oT+ftCYAFso6btd5OSjkyv7dR1fdQgo2Va
+/lSN0SIZ2QnPAD7PrgXsUzBFI4WhG1SfTnnaplQdW7DS0Zfuj1rleUA5p/1qtZab0IQXjxQQCNPs
+eaUJEbrSj3IqhEDUpM2OJnCogYJqCmuWinQhTySPGbbyaiWkMc+G9Xbkb4zVtbv++YOQJwdkdMxW
+riN2+Ln0iQSbp6rfbpnNszxtnkUmreHnSKELE+bQJEE9kSArrc8mxxb4+FW+MUs2X6yM9iNp0Gnx
+kG3DpjXeg3rreEZ8GL+V1X89UyoVGJssbwXfQRQcZxdq9eM3UEUFPhiha3DxrncbE14go4Dwh2Rn
+9Z+OyNaYu0JRZ7jskKrZ5dHjcorpBLqUBZ6ZoQsWuOYzuONDiyAMvgfvs7hTzNKhs6ksF0Qr7WF4
+h/TGpWaybFKLLWQRvg5dR2CFubuw6OojTwadafdDYVtEBNTAdy6h/uGkZmJ/cwwS2WCUiVs3D8ES
+hO9htFUajlFoGxwqybAAyAizkdcfZdhO2IsyUo1u8UkSWfZ7ZKQ9VII+R0gNIJM0GaYSlXIGemZf
+wlfpMv2xs5Qqy8RuUplfwqNgTANaq24IIODw4N3CmyaIkmWxCK+b4QlHlkyeFLrvfKtJ4tV2f+Q9
+RqpGkqyhQ9DlzZzBd2zH2yJuTt3JUivCRikfkfImNAlnOJUBriAqeAhFL4Ei/paA9hDQQ+VMPzAS
+GD7biOOxGxr0l7NE7ESUvbvk4FSjCMaW494SjtDglny5wfH6y9X2kF7aHjJDCw5nQl9LEHy9iQFb
+ZeSAIZAAU+GzpE2awhBbc+7d3mWjZLMXYRNPjR94j7HkNIvbbUIOuUL44Sp4G4vy+pTVeGTRQIQ8
+bb+MbpaJ5NTKDujaFD/b7DSLb3fKC5fSTjIxdafyam4LyUFWv2yX46hYyUU2dTtAX8/Sp2iJQWBw
+eleQPiBsAciDzRndd6VbGey+y2dxLp3F8WFYOMKzp29YyTANctwOXiNDO83kGhnMJh0/S2M+N3nV
+mBp6/U5+KLlxSBfkjJ56HICGnJ54zNg8No2tngzEIJ+/XL7PQPqzcCufZRud9VK9e5AQaocbP/B+
+E5pmp43fS6inRuOO7K6+4qEctKTMDMJtfNyXtBz8F15awNNFXF8JFU8P38fh+zxRPk+UzzCuBVWW
+TUdpWWXZaiIr7SIwIYNyTXgLZi3hnrEWeohudMUsa3QT1ad0uc5IA6x4EIE1X09545gAo5bkb+jK
+Qdd2EgeKeHXRHev4NkJH50urscFji3efv1xGCpjT8LV8ZosRD4uCDnNhxUYmKfKUeQQJQtY0a+cH
+YBBdFhuEYcKOJMGnhJEkAZ6Ov18+USSl3dhvVwtEjhaIbGks55gnyXS6ixbpbBduVxVStnqG6Gbi
+KS7AjLzH6aJRL7AcmNEEp2Guu2gVUz0uCCnaKMVFo5RzIW3vB2jOIvj5d1gIrw9AEXlbwEUU6KZT
+IiovTVL0iKSsOc0JuxSlxryJdysGrk2xo1wZCYrNxI1rsAYSualrlSbKRIbg5Bg0tC7xeK9n208K
+o5y6GAU16enDGBTmkkdUcnrQYsnlhY6Uxglv5cxsqk2lskwrM2laSabYXeNON6DuuWOgLsys1WEd
+prm0Elw+WI3LB6pxeTSFy/s+YOIyGimNjonLgqMwETtHORZHZKeQL3NS5Dv+vwX5Rsfg2jQh42Ji
+/dTX11A8ZYpmmyZQKVuNNHOzapgb7kTi7yUIilwyzd4ha8/3LJ4VT1vkAGt/HReQ8GGK6vKUumMg
+qWcgqZ2mSR7Jm0SVuQ4DyGgnwytE32BPG8qdC2m77pJo4SRo4dC1BkQLhy83yetaY6GFY6KFUx8t
+6Mqfq2PPpaKhG2jhjIkW3xsLLU4DFbYnfjHSPN6qy+PTJEeGR/X5S4E1TcrwOCDLpCzLpCwj576K
+EFIt4Q6WGxoC6V4J/rLSx4O6GO9WYqwC+GlWm8zi8UiWnf1npcEYBk/ZjVMZd8eH7zKGzFXYqgpH
+JjgqQdq+ktUeJZALBPbyIVUKII+wlZOBWcZvQzAZRwoxfv/B1iJx1Uyw8MMzkeWZyJ7yTNTAOIsL
+gISu1/M8476q7DVkhYW+NDxL3vBwE90N2hP7d+NM+ry0bPQkT0vLTwGASvgJD5FmznoOjlbNAYpq
+yFRESXISlyGPZSk1UPoNE7TZUwLtaexG3vAXtgDecEYXwP6/wyF/ATYTHzQhcZzm5JnxfX9Xsy7+
+nMvgy25yyaqzv+xLpuSTkHqCf5OnBPwi5Ut9zuQwZ3KYM5E3V5/YOMBXV4M+UuArLOVr59TlOXV5
+TvNcQQTcJ8omFXQA4sJXVMrU8DlGCpeRwh1rwjFggRu+kRGl7oR71RPupSbc4wn36k34nroTvuuD
+Y024Vz3hHk+4l55wvi6QUgcADM5lPpYxmZhTnaml7HBgC6cup+NMLs9hztAuAOg76zPAM7whvq1m
+Q/zWq9ws0OXGRFg65o4jzJ/uf2lCYdUV+lENFr5JIaeUGywdHMFlU10f9uwuBTY1RGCKlA77b+lw
+36UY6ZSqb0riZVF3hnXQ5ttMZwX8/C1bXj1VYTt9FbbTL5yNkuoBV9XEYTt/yy3OsA64sC9BL/1n
+BTLD38nGq4qUHS7EGhYqSBV8xS3lZG556xqlwgMuOxUX+PCAC2sW1fAorB906fQg6HKO29Q3fA+Z
+/c2YAeuRIm2esh9yKYwYZ4c+Sq/8rZgVY3NoyPiyW7a6hlUotErofIWhk9fQySvoFApTAt15hsxx
+AzIeQKZAsepSUJFZy0XOrLROKZjkZd6iulgroSJdxis4lAIDQHStK9/g2UE+59sKNAUEja9BUQrS
+UAqigJStDVFwd6kRO+tSVNOivpvmclxTCZTJEii9qSgNmA5F1CgPUwUfULP50lKIkzHDeiXUU25a
+YG1HKhnOt0doRi0dUIyr1nFNMT5rc2xD7S0Bvng+gWWnS3ezW+AnxgKHnxNxL+VUSpOiJjqeb8ay
+zkmXI8wjzmsjX91rpKuxjoyggxe6C4WnBRyMAY2kkylM+oud4oCmJfy5hE4CYzSHc5FCb6dz+rzE
+HnmtuwAJeK27FDdDCzQdnakKO6nCcxgWs81r3ZQ96QiMXkdUQ+zAQMTwvd9BS6oOe9RBcHXY9zvQ
+Jnzvc4olqLRAY311pcGxC24Bb0cXJDgaKNWyBUhpN8d4epm60NYG7Qt8I+DNa+mSWFa/wYE2Mrlv
+TCh5IQlzig8qzGnUjHqJCcWMnkJd339KUnaAIy3DgDA8Ff5s5EmWS1sOa/LC4tOi5miyvonztKC6
+28UctIdMmuDlYtSn8NiIhNk+DPjMMGuVMJssK2/Gi65VAy3SDX+KLMA9V29/Kbu9P+n2qO42VZfn
+5qDPU4pnF84JGJFTAdogw069widFLfLe/CSUDFpS9+bV3P8uGQfqRSRUghT80gjB5By7roB0Gl0n
+e7Oxq7YVaWmtRFNZDfMgDHEK/8QXIVp2TkieYefcmjzBMCfTE8acegBJA4z3gCtHW9T3mak3CSXE
+wRR03/c5irQZ3cfqwx8RgjCf4gjksBSlIylOgn7nk407pyVdPOxUdfFBh7t42GFdTkIzee3Kq//4
+UwVGxRPNhEzu4RoLRptRgXq0x0FN0xGnbBJnaXyUxxDH1B0eEtknIWk+O5WMl/b18lKTfWrLK1CY
+hLQUKTvP9FQ501Pk6wkmKqbQOJmelmiiRGPE4GhiFRrzEviNQmOF/vTuTlf3cZebzOgdwOwwlriL
+VgtJbL4CgnkaTjY7AOCQqoVC81jqkfp7RlNsrJYfIneW9XXiY990KU6pw3xYkqQZ1gMYxgg5aFU+
+36hIzmdNwQLzX5paDLBWhUujhlwiJAv+gl3Fg4XJg/fZKR68z2aJCIOnIhcOF1iPoUQFm53jOI69
+kD2vAydNNrgkFNlrK5bcTPM2w/q4jRBXvLiV6Sr+xKDizVFYasSy9XiwDG/UwFy3QXLdUHPdyWiE
+1yi5bj5ZK0n/sP09tgybBL8/ZDNnwkAfxHcfc+qEUZoswyj5wHcn45Vvl6KzGXXu4jqlJPg3tsl6
+J6PhU9IbxNt8wnp3u0wO73SZ1e5yNa42KcLO8ZQmU7BZW8VTooCmjRiy9Bf/8ukPZFKBlBo4oGnq
+rYyg1FgdQakZ2Rj1ysVAhgmD2+ki66OeTZE9myB71oyqHl0QqcTrKbSBm1AJJtH8XgdWclFZe4fb
+BSQa77goYIzBx8YMeY20DiVAJgQjVIcmBCOujK1ECwf+3eGqS8TYvDPCzfsqQ2vsJ93jBuF1TjEk
+Y2zM7iYUs1z4cMKgoJ6EO0lin5eL36T4rqT4LJ7vqS+eMz9LSegp4pxTxBkaSeq/X9a/D79321VS
++G5b+ZLBp/fZmqdYetlXsYs80QvFCGTTxdSj5h5TaSoNKkD0dob1Fptp605beoXguD2TFfQaNPQ4
+qA5RtqiRZ3gyMnKS91TcnmYzbo9JBY39CcGrgBIjbV1SG5QmLLWjlkDuSAHn9dWk0TZJ44hJGmdY
+25mWHRcVQj273GBC/bhI2PgfBEVjE4Mm8QuTjUiT4S2qzubClrsJ3lxkNZFib1GYEjXoTmIcvYaE
+OB3jbnj4+7+gG8nOojnZWTRrh1EFvDEEO7l0JUe4EpdH9pBIby4yZvPI1RsSCldvU6F4PVIyVIM1
+sqmolv8R6AW9i8ftCVIcFzVQJ5fqxhVHDXlO1UhL8qioWjJHhYkVPxe1S4ZWCYs6DWTcaghWAOY4
+kK9y6Ve4YiYGGk5jSD9h1CSpUogLvamO9NNQLf0spuEfTiZOCTffFSwsHBbSxZUITiYm2SwD0YLV
+66kQ0sITNUvooKiVMb4lxpMxDoiUjHFAKBnjAVFPxhgV48gYo6JaxviC+B+WMfaJlDywTyQyxqfF
+E5Qx9qTr3CNMGeND4n9UxnjowFvelh1TxlBvn1oZ49GP/9+VMdTYnryMYT/FMoYtZYy91QRzb4pg
+frwOwayVMZDEpIUKnrNaGYO0i7tFjYzxPsEkbrf4i5AxSGDaVQ2aXQZ59CV5/Jtq8uib5HFnmjzu
+FEoPeoeopwjdIaoUoTtErSbUI9L4enFmVaGnogydWE8ZOiJSussRRp9m/L1VnI46tJmElmaE/LG0
+gnUDVdnEIBlMiyzNT04f2mzqQ127WHSLNQpR17JPohEV8c2wiC2r59df/fotv//69z/9U+v5p6IS
+LYyvEn2cmvJPorNJ9F0prejElFZ0Yq1WNP9EtaLIo9KDfUHRr1KLqq7X0S3W1c9pzWjI8v0Z1oxm
+T0kzGj4ZzWhx3KqdM64ZFWdeM9p4hjWjQvKw44lmFFfwDewmmZfzjXX4yxPRi+ZjlM/SMjpup56g
+ApQxqVbD2pzWjPp/gZpR2vYdtWpUo2t487DaUI2S2Q3tcIgu4/LFCOOEyrscdNwAsN7jMBbsJjKx
+x6mYaLCDJ6qB7kc03rvdEGNuc1j42oEo0K1PWpW0351sqi+SOED7RKxSAj0Attys1uUOY+flI6om
+R6pHOV6rb2KLT9hy1Oa+HMd7mbjvoW1QQFJCNIVEhQnRlIQ2N2OPJhMcEuKpt02ZJ1UczRr8Yeag
+qBHWMGPPDmhxmj6NNvdGkZI8mmljVsW5IUNprBPqZi2g6hNq8+xeABclPK5/Qu2PeWavzqf91Jl9
+s9zt1z+dzqkj6ebxj6SxP3nWiyDytCaRswEA5qhbTVl1iikZ0LD91JhU5HuSKNXyOaSXjyElUpeb
+eUhFvmbULO/3NdIFnSLOWCOycJ9YO5t0FBfiUWMR2b26ZtRYasCs+RKtqVAPBPsbSnfxrvLdTRIX
+YH0ztGIHrB5qlLOexYq1FEFJmVQSme1JjQYK00WsBgbTAOJsZrwTiVJaQqazCKxc3yBqNCzhFSQl
+dx0PfGq7QowoCX6ups5P1n9Oj96N8kVB1BygwB5v80VL6jExARZWPgUEO50USN2BnmJ4zbhmLjc7
+AZVFMoFaeNgbK5kWoTvmETHKo37LaA7dQtKibpaLGm86o1UOjIIWtZEXW+FDJDZVIQ+8Cj+ZRkHv
+sI957COuF9IeuGiwDKIBUOKjNm09Ka29ogmfpnlBl/2YLd/7ZKl+3C63MfXeQyIG73LKjXpnfA9u
+P/z59h43Mg12PmgsafIpLRJaL8WAMtvZ8+YVGtnB8eZ4T0Ym0cGz1b2SZr5XUuC7Or6+ZdfGFtPt
+0tg/g8sdr14aXjUdBK/P4HV4auvsegFPcnJn0kYjpDtLbXcn4c+46B7aLjEfwee9rt4Y5yUwHARG
+vCN1fxA96+7Hu8+QrmMq0MnvEYduFzh6r86ykHm5mlqVctb7Ea5K6Mbbm74WnvQswrQdBpa7z+EF
+BJ1pWcKW8nvdMvFo+AldNTFLzQ1aSZZ9XQ/IGgHNjMKJnh14E60pjRLJU6uMO0ZQQGjEWYkapz9U
+ilFPLpAZFWFMtrzAXTVkQgBp6dpaMeKisXU9ueINNeYr37FeyvDtmJsYDO4ww0eoa+y8Va5zjf3k
+Od6QO5UowQY7pmCFBYvNO7N+Lh+Q4eN0M1RoOyQcu2dUhhqNKW49W69yqFC8o22r6LAtGGMoEuR4
+X4cfDerWeSip8+7TrzNft877kjrfd/p15urWeeeTqtOXobv3cFGLWyB8UWG+w4hioGJbj35Et7XH
+bCus15ZPv8J6rWbrjuTAR57MSDLpOmWPdz6pOj0JnffVh45bBZ0P12/rdKHjnlarD5yhVp26c7In
+qf1Dpw8/u26ddyR1fvj06xSyznSU4Y6k+sc+JKtPF6wKB3wZujm2tKN78jlgp+yKrSrT52oHEkxU
+g2vkJYgoCc9pg+h1GpYyui4K6YmXrIyYnsHt2fGj258i0UQf0xQuvrFO2Po33ItvMox2O41A8kQb
+oegP6Mg/PFnRYx81iua56L9S0Xydor+gok5UE3WeKB0U/ScqWjytoj4X3fXR6rH6sujd9EbGut9r
+dFivGgoh/1FjWGYuol3QwJsoQ3Bafctw0a3cgzpFpWVFnaIeF/3lvWMV/R29CWqLpoY1dt9cbuAQ
+ZSjUaeDIk2zA4QbuH3MEKUzaf69R1Oaiu8fsW6roPWZRGa/zODLJeMJJUd8oCgXDw0w6oiTeJiz4
+otXzxod/9vZf77v9O/u2BK0qfBYFUeyw/fCdW2lVPzO1bJOABYLD41kcHs+vxHf9PfbAomsbx+qV
+tVTT8eg/jnIMcqAsfNXsfZwCL8N3cNlzuEMdY0W2rxt83P7fG3bxzxxZ806pLz7TkTX/zHFQ1bDO
+dBzU+jEI9v396BmOQVBVY/0YBC4u58+5p7cpGYvjTjQ5bqHY0Bg2TWhuIbHjk59mGSUug/zSginv
+USlTIKUZU7aqlHZImYAp/75PprRBShOm/LNKOQdSQkx5n0p5RolOHez4D5+SKR0lGWLsiyqlqyRj
+fL1bpZxXkmG0fvJJmdKt9kMfMVNoN/P4P8iUmWov8lOV0qp2Et9WKY1Kyv+qSikoGf1j/2CMiyTs
+O8wUkn6/fJ9M+aYWTV+vki5WguXBv5cpF0mxUK0HFActeVxDE9CuRNB4Pwuc57Kfn+ksNSIfOPD3
+krSi4MmxN21amEqS9LUkmRYkQxlvQyPvZOlnx4+URwhOv1CHTMbAlyJZxHSlDrbbBz+DjKA9vu/+
+0cTt0XXCk+IllrMJ/cvOMilqllznkngCOv6SvqWvr5Qz8eSlRWAmUWY4ftvIiDvIEYrIyaa6vIcx
+6oN4YnJTOPgCRvFCaqCaYt9QZVc3ZXg0oEYpukvE7mgz0HDDuZaVzcL/1X9mkkPXlrE/DpFn6bMI
++gPIEUQZisjl8ksgtktoadvM8ibSQuZ3GfUO/X/h7cllRYzUhy7BsD9ZBISDgHCQomlAIOHPUHlu
+OLOo6JKzr7qwr58aZTlsGPSomXskHSV9Rci5kmRh3BlDssxzpoGXycD/1X9mkusE9SfSLnm4SDJ0
+/GdzDg/9qSKEvBT0VKfHGJvEhpsBGeT88zAQwzxgKBkeRJZcLrNLKa7YJpd0eBqHYYVQXKBIJqhD
+IwdGlVIOZm5LhYIHiQqggI9oi7rGKAcl8DwOe4c3hoNRIdwtJ4WiZ0IRYTjHshwH/q/+q5Mk/8aD
+qAJGI4ciZZBCB8aAXArQwReaRTA2VxlrhaF/Pw5Rg071ZF4v4rgbOTqRiXLxg3S+5yMUfbq7jlp4
+fMqh/7lBOiLKoordjXLk7A39J+GrjZDMxbC7Pt/QR5+zKjwluxrEa9+JD6sMHZjhFXv0Mwj50bM8
+EkZa/JjenzhajJSe0p5mn9tFIW99poYYyNa+hKux6AdUVIfNUoVljuCTUw61WOe85XI0P9Dq5GAh
+ubx2KiWMsGqxG0aX3TAGRMljqWWAr3bpejgvHYIjqB1C4izDNlpGQlKGHAKPwefZhgj1xYPoTxQm
+YjESWq4U2CYpz6+q0FlHfgkFMsmwOj3+/JZKwzMs+msc80++R5Wss5TWcXuFvB4usMiZHa8oDw0N
+8wjt9jI2VxaqQZhvbIgeM+jdLxf/rXpcBpJ6Lv4QLEDBp9UCe4edTw0xhxFSr7aajb/Uw8n+OLOA
+jy1THPi4zV5jM08/xgdbLOXkyA/fs1ViTohISUGhAZl5yBJXC4XTKRn7RsngtEoWjJL50yqZN0rm
+Tqtk0Sjpn1ZJE0J0wOnE6OozxuAScRMgcnH86vxSoGutAXkGcdCNR5HSaW/fuXgJYA9jub+5nEfc
+8zSy01G5gX24Tgzss+ERsY98ueaxJo9rCjcDA4Sa8mZNmXRNmXRNGaqJTEsyWFMe+9Yq68mpeux0
+LSJdiyVrwcgb4S65E6HacgE52kQl3PAQn57H7vBQWfBSHlLOM1CjdgwAPrLXYbqM4IfmR/Z+fsvG
+eGTn/VuW0N4E11kS9FLPkSwQj+wDrga7NchE46DEE58CAuATnYJ9Z5QjExO0eKASB2+iRY/NwfYb
+iAGI2+isKT8M5UcwYCu+G4pB5qlQhxzoz8j9MHjqVdHHbCP7LXSybMPv50CdYmiB1UZPEzbHx/Cp
+lZ4ym/XrqZRQSBKm8L63EPnS8SrjGGyw3jvGsoZfreRyFd3Z+nKvrYgP9SnKRaINO02yMXyHS4jW
+wliWkWvDXG1/jtTt7pTYIY/ZmL4ADRxorlM1TFFlRqkG4Po53khUwwQaMQqMDaHYLdH6l1CJcss0
+VKLc2FDB07qcsnSAnMihcfKxK8Cmw0ByrTx5mEWGx3Hk0PwIeQxxJBtXvcYwCqiOsRizvNhzHP8Q
+wOsb7JovsJCnJBIepM4Z8QlvPGRKGTUa9uuDVSVHwRTWNqOj3ftaMYNnkBhNbgS1U3EpfuQzKRmT
+zDf06XZWF8vxL8HKHp9NvvUJpDajwKPe/SR7fVp7JfFlyv1GnkM1eQ6l8lhxo3SY5AfqND3Z2gU3
+4oaIDgWqBbYlHL2YZTZHSWnJTgi2H5PRMaGIsnLnUSQhDIP51Nn5MBgpUGNkY6DG+cLZMpbky9Ku
+1ITJMiBTLdDOW3RXeS+8mBzOOpLuC/IBJH1IWbIv2BOq2qnAzuZM1fQ41XQ7S/JmVWV2VZeuziVY
+6lolkFxVIe73ZJUk8svSXtIZi7cmPvtRl31yZZ9gf6g69EUxlrqH1Di0XNv16ZJUI7UmeoJH75d6
+grROQOofSGmZqBtqlQvxlxMFhNIu2HSgpTQOqJieXlV71dnVbPbSM+InHo0B2+hRH1b1jPhdie7h
+XttBt4V1NIoA6Mk4XEvHlO0hY1UHv2hD1JPfdnfciaQQA2WzIq4n/3KpFIybK8SkXEnIHXo7Qg4I
+t5Cv8aVk9YFUAXdQGV0dwudh62rYIGRhu5jBHWHRps24IhtHPmtuxluibH9JRmV1WaUtlZLZ/og3
+UegiV1JZ+Q4jaRJGZnG/4mrn4RJDqFuRW0mrK4NjDSJrKODdRPnKe+HUivDMFeEFauOb0YvBq8Rl
+9v0EjeJVP3LmZPPOhRy7O5KI2NPJ1TdsdCy1SyYBi6UmCtL7nEFyHnfOIDlQ9+JrlhKbzAxH/hDG
+3cUwDqTp9TENithQZKjE4SU2LKOdXA4lG8rsVGV2MDNyOPQzfswa5FzQQ7vOrggqvKHS0GY7btbL
+1Kp9sllhcaR13LCirzPk74uLWRauyfmSBGHGBGFGzlimAgURbobK5rTKYSngY9mnurWy0VjmqW7s
+x+bQvKe6tUfN1tynurVfmq05T3Vr/262Zj/Vrf3abM20PIZ1ES3h5SEoshGJvDYtF9RqIrfTAmYD
+PSmRt0BPhvxZBJHXe+rn6bdPsFznmSkGY25ED2v5JSWQZuMuDPLlA0shwngMd2ub8ck7SfV+lI9y
+bSVftcMO+k67e5H/BJYIt6UxPTXHRTWrtCkpkHJXpLM00pPahtSggcaSBC9c3m7TaWumP/KYXcKm
+UbHLqv65FBVGsUuKZI1vWd1uR1kSW2msKV5YPVwtiWVM6TCjGaI6Vg9ezIcjJmcvs5dqubVEGcLY
+V1qG7GnjKzYVkrLnL//j4z/JzLf4cAYZMnTsPiwavNyQbN10312z7/owu1aYJH/FFHmemgPJ8vsk
+WZpVn0REqK7aq181CA5/pKoP2KZX9Ej791TN5dLN5czmcqTRNcGfk9WyZ08DOqx/he1psarmsjd2
+3bLGBbx4sKEy649hRzl2sWoI5OpDQHWVZRRSLoTyIlaZRGwf76e0lPPa2bk8gM6T8Ct9b/qJZFfX
++mF5siWITHML5d/aQjkeq7vzc6PS2iL+Ksvx7fDzwBflJoHtblERbcUHMTH8JMuu94eOt8W+2cH9
+pCd1R21K4Yz3OuH5WhSWQR5c2sZafc6KZ1oYdVaowC5ZDMmewSBi6DTUwZDsuOnfP2rsdeMjn5Mn
+FKPmvttGCRwD6SBmlXPTQNbM93TfWg56Fuy4G3eVCHbUL6AFfJSviloK2ebtuBtISpLTVjnNCI75
+VDhTKDWzqpRDpXo6qpJdTi5XJSMtwjp1/Me8Ef8xr+M/5in+Yzl/d7kQT9qcqiGLNRTiMJ3qyb5v
+72mvahGtrFGirowFoNwpAyj/hAAU1AdQoT6AiqqNUwVR7YgbCMZ1QNdYF3QhA6gwJoCaThlAE54Q
+gJrrA6ilPoAmPWkMmlwXDBPHxKBWBtCEMQE05ZQBNPUJAaitPoDa6wPorCePQWdLDMpVg+4cBkUK
+dBnY9noxxfL0l/KWXxK5+C6TjCk1O6Q7G8rF/nIDkkG0FmsgdT7pc+O9n2NlwSGT1knC6SC985bQ
+FdksFZZHmqgXj+hoIcc0FA+n7/hCPRq6/QtpGooxxxQN9VDjBxLaZj00pm6eDOLrm6NmwlqI3WHi
+9zNkVK+4ffNQKpsta8DbOvD67NTrLGzIc3iaGzXA3oD81qAO4dG65P/hNEjqnmkW4y2VBtuygcEC
+eFHFDqBYRteHiM5ZUYPsajJKYvJZzOYSU6H+usNx52CSw6aDlFyjrNblar3xqm3gaiF3hpvIYJEs
+wVw2EaEiZwzIYZvcKyfplT0cX6xyoEiCKAF9oXtAjQmk7vqiOckNiIlfSB19AXrcl0rJItOtSbnj
+i2YK1nOopp6Hq0rB7KVSkJ1vN+v5towtlSFZlrxb4+gnbYrvOgTZUBgK799KikI9rXY8wsFwLQwn
+yksodjbiQiJtP8xABaPClbA6q7/scSBespCJn0XKOTTWIENHzKjPG6AIR9OrRBZsU8n6xYsPf37U
+CMHqQcoRcwTxUXwfnx/fQRj5AKfehpab2LOBsqMCFTqLMagnTJuSk+DBWdtP0cu81GkRD7GI7o8E
+WZY02I4t90kuGn56S4ZKLmyuwn+Uln9OiawbvCHaO7DBIG5CxEaUEn9kj2cHGFmAQw2OJWwrZWhG
+xsQzLJBYs6z4tfWFja+xhIhqTofVwI98SauBH6irBlYXH7KkDa7SMNtBSjV97LPVqulDqvq6qukn
+1OOdT6bHVVrrGXJ/hDGjbVzlVrx9P6LF3PiOLxtogWrJzWxFB1jeugnX8P0K0U9qfb3/NK2vD2HN
+p2Z9fc+3R5X1dQNvXt77bbUfCL/EZevuL6bIuIB17a7rW8QePTR6hi1iq2qsbxF7zEmFkagxhqXe
+lx10be2IIPzyVjVjyYUc2Y5xIWfk3xhTY7Iij5JLOWhFHuORPPyJQSQ0bJdcwo2Ry2cJOFUt0LDL
+xtVstFmnkdtkI1UNYN8EG3rK+1J3qIx2/HVGaXf8O0cUOtKvlCyKNYunUqj8oMCsTkAnH1XXnGob
++kbSkKUXITVpNsRxWOkiwjf0SkyufuGaxHrvGbPeslredNnFr99GalW6uJ5+96Pbbn/HZ14/+rYt
+Vavrz2yD/t2nyAYdltPTmBapvtPVLYsVT/ps+3yZh+IQU4akfcQQyzwGx4wwwkNIEOIL4h2HTXnC
+CtqrMgABSF5OUG2H/4Yjnhpbwe/tZB3WXvpCyxOCPa2HAj6Gy4oEe0OLiE+mFlGwktvik1grURhh
+AI/DpJ2x1KGuPs21WKMWoUqGywvUS1PjRmuN9JQoJGXbiUISE6oUkkJdzqnJdaRuJUVi4Mms0Xzw
+YbLTT/wkIgoffiM5UcaxyBHYpB1SGk2KXVIh7VByuQcAP5xSBanY1WrZusTfSGsG/0i3PjYfm5LO
+UiVR7F08P8XDs/h+nHRmjftpEbIBpQqMHbxUW4bDUOTgHD04q5/MTnG9RLY5OEvenrFQiWcnI0Mb
+gfloe/nnvhujFvCZvhvz8dqrSmNcU3LUNSXoFW5WoP9a/Rrra0pu7TUkdisxxuUlWx7hJveSCqk7
+S3VuKf3aIZsOYwXjHiQOYz/8DStGl/J9KCv8PonyaCuSvIY6w1sJdRykohRUT76KW9SvSpK/0h8f
+P/HqSnz9YPwaNIQ3WgJxqr9M/hmWtkWiP7Iw5DSgM4HeyPZqEPCXtqnHsvmuEt9U4W5yXCInfN02
+vf2AuraQ7T6aylpqlTsVVHL2D8qctjE0mPTwOOv1Y+K8sB/BzlUAGWFnYvdTqB0rfJz8INBJQPgn
+JlcwJ8mvB/EXTQQtjkQAkusB5lDWAcIRt1g2Z8CtXEFikxvewn2k31y/jTMKsmDymDSHeyCgK/Ju
+iGxjKtD1TzzDDhOtPZBxYZJxgPdvcf3JebUpLA9KIKc+r3bdeQXui5PKzFBDGfJ22Hv+CIRoITmG
+8eQOCrHwHDrlByEsy0Z8eBvS33wdUJ7NsRhERjfcHz8bLTZRUKb5kCeXIJrf97gUzZkv2pEX/g5b
+HGZT9phs9WkCX48DlYD38XYCxSfrh99k3YTByfDigM+EJmIBi9TwWDveIsArNZn4rM2xO4hUmBpd
+3IYv2iiCrhjGTXKRzA44/B/vm1yM942BkmH3Nxw+yv5qJDgGsd+Ig7/F5NU1Q3ICEENpw5waAGye
+lmE8wX5UOSwZLGfaSi4HCWwjjN6xbYTvkAcouiLnxBbv+9MopvLgiaD3L0Mh1eW68Y3EPrRk+YE+
+lHGSeZZXhsIRMuKDFsOt26ScxNNJaT8k7ESxCjZTQNqd4fgeHG2FJw/7chc+lwFokTtcdklZQOGw
+XD6RyETu0HzOFDkoNjoci8/FrwJHVCxwTGpfXtKEdRaeoGM2AAAtiLK85nky8sJWdsl/Sf+ytB0s
+w/9WTCTF1nC8opiFyRZ6JnG2smNMpGtOnsRhgLCcJRi7U4WhcmZxnEvKWZpTHDrOsjm5405detq8
+KMtZMRJg7QQm6OHizQ0XR+0b85bBDPdjBsBjDR4Pps8fLvt0ySuD0+eT5QTRly0bcfk6SCgcmOL4
+vj9qvFauh6Adrr/sLiKUpAsUHEye8SAb3xzZ1w9KVKDLTlAbz7OaZmCRWWqURPdzBsuOXGWIFcOD
+ckaAD0E3snW6AYBV3ciSv0WFY67qhh4x9MZJ90YCUsO/jAokZ5gmUK2NBLgc5xCBmzEXRQJcO41/
+Pl2kK2eS9SFP7PwoY6yPjA6Nl8GvAktD+IUn5pgfhkINIEjnc2cM8GE0Qrzpo6vMoFFqhsMp+mpW
+MvzlyyqzSZWOrHKclVis9XdnAsbhy03wvE8RKbyDImLuj818CqVRK2FMdXkUysOwR+CncCfNDhlx
+OsR5HLQM1uAmwoVzZawV6gdubeToZBeRh2GqhB10qRoJc0GCBrhKNFgM+JOPsq0aZSTy6Cr8QJ7S
+M87tpyJkgpup4P56P1eH7w7wamXmsLRtPickcB39E3FbK36AR+rgSK3wdmwJzbNpJwZEBBYsAeTI
+nyQRczDfkqJDESvD27ax3GOFb6K+enz3UDUQvpneO3KRyEoiqgM7RQnIlyoAkQcUzPE/h7cckYvX
+yXRn7KBuo3g/T7dp1uRItZBFF7rU+PDBDnStyH0JF+kl0ACNOOVcf7wGlSsIR4WrvhbK/H6AOmlp
+E/xa0lb25Xzlya6e51tKUuVAM5VC0kypaEicDTHBRzbWqBtr7C+HkoY0zueRQs4Add0NUSEqVipR
+WOkvB/N5iUSNURALWLGubLlgtNZitJa0HGIZbiIKodJiVOivVGgTAUtmBLYKD1LNOKoR5grTbAZ1
+E/mLw+dD+IxuvPJRE92xw5uHh2VvgUQcTGjCA/Jnfj6Xcmj3LAGGyPh77BaF8iwRLwImvbTI9vOL
+iihwuf1ybpDvUblwm5Q3LClv4BuWN3y6R7iZCL0irVYVP6f7uGVnUKpcfNpexdS4Jn68cTdiySLV
+swzOlJVSflZtE6VeNVOhsciZ1YQKRTOZltFpVDXsMHAjrGkG0iLNmYGYE/rh9qWfvAOpBRCRl3JF
+xCJyuGiFj9Hugg8utJwogWSxSFCQGgw2YclonZK/iKRhIvAZIvA1bC8LkDU4HwhGeD4D/VT4X/Ak
+nxlNaBQjqk2ka58kfxYjrQITMe+YqGE/XkvYl5QeVZxAcVZZd0Q3tIekH6QaGkrMzJGkh2R4Y3Z0
+vUn3MpXwIQKOk2aUmvLLAdynBiDpdzIAMqHDXZnCTVvjps24mc5MAoA9Ppbaw2U7wVJbYaltYKmt
+sdSuwlK+TaybxO1HfOKc+fbDckGebMVyv2Ay/siP9/Hj6B9Tb++Tj/fz44F05vvl435+PJjOvF8+
+PsCPh9OZH5CPh/jxSDrzIfn4ID8eTWd+UD4+zI/H0pkflo+P8OPxdOZH0m8flY+P8uPIY6nHx+Tb
+x/hxx2Opx+3ykb7n2zvTj7fJx9v4cVf68Q75eAc/7k4/3ikf7+THPenHu+TjXfy4N/14j3y8hx/3
+ycf7+HE0/fY++Xg/Px5IZ75fPu7nx4PpzPvl4wP8eDid+QH5eIgfj6QzH5KPD/Lj0XTmB+Xjw/x4
+LJ35Yfn4CD8eT2d+RM0gP448nsr8qJpBftzxeCrzY2oGH+cJfTyVebt8vI3f7no8lfk2+XgHP+5O
+Z75DPt7Jj3vSme+Uj3fx49505rvSb+/BLykPuJrXGAJPyTfkAS8liWh+hXqvvKS5ViKJuGQ5jIwJ
+JJF8JaHWkaXo8bgtZ4yWUZXiSEkENy2w16oniaDg5qQ2BVcg4ztzzCIgVbo6nw0OecLdgqpUpYRT
+yrLwv6X6j/i+IxOVThCV+SVBQ9ouQamY82Kpa46dwdjB+/qkp1V7CFTrEs9oDORGB+rop/rQeb8V
+vg1fLiza5nbA6pf7gMbAULvU5fCu5vDkG8NTbMKru7FNcXjkYuEftlLzqa4W+DIOa0IIxIuUXkSN
+GGeoDhsVlbI5dmajjQHnrpEaOLdCMKHmMN2O3pAZOzZ0RCTFH54YqcNiONkmnGwNJ3U4YNNgFJzs
+k8MpGUl13/REB43y5IonCvKTTICK22pBQKQFAccUBIQhCDiGIEDnl4KNCmyWACy2NKBTSD/4ji28
+LYi5rVw/4e4buMu8m2shDVmLMnpvY6DI/TIdC7xR6jZkwbLDyiS2Z3DVg6+sPcJK5LSxUQ+7SYGh
+qOpdOkwNUXx08DIyBm4qkidgPEAmUC2UpnLQ5/ZEk0YHUiT74qqNWxAi0O9FbdLvtMNnGK56kui0
+R84bVobzRs/oyQeB1MqthGU64SdpP+QaWhPlL78jC0/tVrm1MQh+gIDlS7pqeuNzyERCabNFjFcU
+UJttszbbVtpshGoP7KNCniU8WtcDpb0RK+vctLJkj1a72YZWCO+u2qz3xjt7KUWiQArk8YEOUgBU
+G+1htVFk6ZOu1gK7ohkusR8jJ1FzlzO0LsjpHqq40d0eNlfVCCojZWLZ5kNe6Q3FZb2tnWygIlqs
+AEGg/LIPHgHcVZmxaHCrI4pbeNyHmLrTlBqCLBAP3p4iptrsVCWyEE/8Eh1TuujlBwGUIQjygnF5
+1cdic3jHNkngXK1zyEQZyRCzmiFmYSOW5bGWfMnkcpqZ5Q0mZ56aFWBz9JhkEcg1oeocOlTJR0El
+KlT6K0uKWvDnnRypH7OaQtWnb4EeCF6geds23YDcBit6xdzCU9xCkQgvUnc0XTwrdKThC2lJ4OnE
+OfQP6m4e5s1P8NYA/TFZ6piNNCVMX/8fn5S8sD6nTJkL/nm55SKmjX9+xmjObMEZC8WxAOuixLKi
+kIeUhHmncUBp1RxQ4gGrtbRtIR/bSA2pULrl5LjbWNCGYhh1ukoPwwKpx5YcqMaB5q4g1MGDD9RA
+3zTIouuoJFB1VJbCVFmKOipLOm3X6lCF+nXIFyk40LeVood0aiikdlbwbSqB1co6lC0ggcTpD9+q
+apKmBVxhP0vkekk5/VoFLUFQSiBZYslcaVH1UTLK6nbtdkLQOUF/HbSV82EbcG8x9izJfGQSUR1p
+IeJlXX2mUyIbOSv8ERbrX8zTv08N5EE+zkNxcossQrLZCLmw0/IaA4I5zxbSCDGBRNNJqnhqY/A/
+JtO9S/BOZTxolxjMdgJjg3iMA27HALdrbhcNcDPm1wV34FqWVcc29mGsxAo+b5j1GcaxUtZKBJ5I
+WgY12JZw6BCdzdfYPJP4Fx8ckGWrW3Kl5YW08HOVfOPEDxwmkIbfpJ6jkc23SHaRBreQw0rl3zd+
+/lvG8OERWzOs29jEwUq54bDZmvmu74wqa+avJdbMbFJazxsH6tsfwDLqHp/pHubp0AeaQhj0TsIr
+O/5XthZra6IsOAkFZh3fo7O4PGLLEfr5oA8c3eBNOTYIsDkneZBHgycmuyRbRWjEf+qkV9S1DRFL
+2+i+C+w2nJrzeMc4j3e1tIHkSZnLeBKtM9XHiNq0hvByGTnbStitHWUMNuiAeEfMupiFX8qaAm/T
+oC/CLFbQj05BaPW7kIW5InrWkAIg+o3El9ANzA0DWcIN98dbR3xIV0RWSOcx/eQYFAUV9Jx0ToVf
+h+8gpOJjKJDow7fwFgv9CqKqpUxXY/FkcgO5h3T5tKTEAgavQotNjJx4uMIphMkp8Y9kVyd1csiH
+dBhSjcx1pKbcPFVEEy8bZ0SeKuLRJg6w7JkmBa5hrpQxzJVQLE1+saWSGySyCgP7ivHKY1sukyfW
+ySvylZHki0QHJSqp2WN5kwpnUue5kVBdkj4uPTaqk62jYxhtPZH0A1NZgMmGf6R1w6rz+5O+sBjD
+7hukyJSDXywyZRbRdiKHZDtHJ/EnOVWBWvy0qU0CIC/VMd/4pU3B9CDRdBCdnEsrOZfCYEVsnko4
+HN8Q36QWTRuay9Fk65BIkkxETiPt5knEEUmOqZqOSOszaXMmzdCChXQ8p+hOmXfzEunfruQMwQtc
+2cQh30T69DpqAJ6Cl6VskIViE+FBwvPjRBj/VW55LabV4b8w/8IVwjdR1AIhq/rwJ0zAP27bbmIZ
+l5Bw6Q3HpgsRLnNnpEXSxLbsyUsGGD2JPTX7HDMkbq1wPCTDKreVY3eZVrku/WolM39tldsqrXKn
+RuSlyJMG+rD+pjl+F1sIU11kWKKDLQm00+ec09j7FN8SB2IHTdhmJBFRFUlEYNWtXVQJdrFDhW/a
+dXjUvKNhspsDot7NjPoAExpg7kkAJmoBVseMeXyAubUAS43EqRrJlfIqC9rrC7lJNS+vALD8NLAM
+FLLiPWkY0Y2bmsSP2CnDZ0/adwskPbj6d6tTPoAG/WYJcYZ1VNlsQKZHiMpIhy0xOfk+KvdGSEse
+UdYeQEOsy4p0dZOvp7roGtDDDrfgZh8tpKG6O2Sb6N0p5ov25ex8Tmbx9E4WI2Tzu/AJr8pGNK2h
+FCrwdh3GVnfIrXLMThVb5EvdTinLtltbKrIFtI7E3oHIFlhyb/hfvBpn1wswg5PP2iMpMfmV8NdE
+ZSwpX7JvjQpe4CHT3qARZ0IMl0nI7R8CcYd+RNZgMAGZ2xR8vRnth85Z1AZ1xFmSiFDncMNggJue
+GZYb24OQSb8QXC0/3DyI/vrkZismP5pBIIs5gwuD83ROMRiJodiWhw6CbEgoHVOCs1n2dsZ4XTBe
+B5NSu3nIywj2NLrBoztVN0+WASS/++kbwIgj9/nhhkrQrm+ZhIj6WgpHeswBCrLUuYL89iVoCgga
+/XNz8Ay+I2rLnS3qF5ayjSl0Ev1H0A4sUPdcKDW4CGVYOw43X0JMR3qtp9twuH2G9b1lUdluk4oM
+1BkPR/iIGBDX+0cEGdyJuMG29B5DIZVlWP3py14k4P9SHtw7bIspt1w2X4c6Ttdpvs9Eh5Ykdga2
+gI7Uej4o1ROpQC2NlrpXcwvytOC5Uilmkbz6C97S0+9HlLUT/P4Na3no9x+N348SZ5WZ3s3EST7d
+mXr6PK1EvGXUpDvwtywaBr8d916PXfdmD3lxj7X/09O7L8NutKy6d34+uE1OyXh3fpz0HZ1614qq
+rvE8obtAp3Kv5/1sWHb693qemls9Rw4zOzwTt3qMoZ3SrZ4/57W8D6iVeoav5f0vvNUjV/y7eABX
+juFGSN3ZtuId3x2VnoL4zrYVH+AU6fjoID4pZcOf+fKWmuYzfXlLwuzfWfZ4tyv8OktTSC7oyB2A
+pI08Vi92hrXvJBCB9A1iEuhg45kdLPlSMMtKL0uRW8pyFIGLK3RV5Dj5G6AQAxngN1nElCwwZP7e
+IL9Xy+/l8vul8vsq+X0ZfWcq8o/CLIxa2EIO6irnyGFCfGkF3ZCSA2X0c4TRM7jBDJfwKxSYAfiZ
+z27VJPaj04MM9Rs31TJgrUuSJroIxMO7DKo00Lt5QBde5KjJgWhWe4fN4CUMJ3GgnDXCugq+phNo
+7o9W5UhtMvIu8ROgj6TRqkMhi2mMiI8gusdzuS5aG/E938MVIOPFbkouvRsMktFQEGHgRYzjFVEq
+0DBTLsUXyE6yNnpjgpSREen2tXW1iywPuwwR6+SeE3Z8f7SOrtFUMqLLug6+oy11jbu/byz/14mx
+xPL4QcxnxkWUMQsp2WORaS/VZUToK8iAd182cz2QyjVWvDtasPeeEehITexjPz596Nz2EwM6slMf
+O5Od2vcEOnXgx1WdAtyc6mxBn0ZN8igSJK1P8Pv78sJT3Txmab/CfCavDvVqVavxVrJrGGFDDmu6
+NWLHn9/yPEg6IfBIYLp1QsiEP8mEP6mExwX6G/Qidi2KZgJkKiuQBZCxakhBBh5BPGB6Smeu+qUH
+Lz/1U3opX7XzPRTiFUuBBxPTIe90pMOSNMgmYhRJYQSgII8/UYqZDvvUSy5DkkXHQi6DU5Aagx2D
+oJEGaXvgB95fxbUMXM1ZQu7qHY4zhFpHZDRAAfsZMij++Fj754kAImfgMTnYvkXKPbybama5WWbJ
+Jllursrymtosr6nKclMqCyS8mvxlotfyRLKgrgtW9AuER5ak7oqqiO4QwQs3OYChy1voFBpo3PMQ
+LtIFNHLIcwZRJYkOoNGBZGY4sobYwzxKS8ANAX2BQjLUU76gWYbYwIK1R76gSQC0Uk6gvcQJdBm3
+gxguIiNniyrGTSKOhhzw2LRRsWKHopeih4C2kpCWQB0RqW/Ir7kbd1ZQl+SRGU/8iFWJf6YWohs/
+nH7ESBaQ92iScghSfq4fe7wuex6k7v4ZLdxO+CkX7uWoWsfy81H4gZ/olnE1/cJIpcvpF0Z5eyn9
+Ohd+XUW/cK1fxr088DNjaY/ZuZ+lO/e15JEHyvZKPS739J5/P6WeLtc95f4VdP/8pH8P/LvZPzqJ
+Ihfn31E9xvUYeW00AbI3znh9Tx6RiWF3j/z0lLr7Ut3dqzRgZSeP/9TspEMdlPEX4mM/QE50Qfwg
+DSSJQMZirB6IJPX3nUlSf/Sh0yf1u0xSD8L/5fU3lagmbOX+tHB/Qki884ejI5JNP5JIBiAY/YLl
+4K3pYaUcFhkHo2pYTmpYDg/LiY/8QFbtJMNyaLPFezhajE7E7nIjVt/aVSz1i6mnL/DT4SwZIKGx
+oJNiTqRZcDHcCOkPFhfZoGkxRdqzK8iNpAlfhowZs0Dn/QKbWZCvHtofdWC82kLTVtKc0A0NlRUk
+ZdRcAMHnOBzOdHKrR2TX4VhFgk9tltNuGv3O6aQNnORwUuQwAUQq5zAdpQg/jqJ4PoX60VRP0jwG
+F97GzKLFk8/bB2AjGdI9+cSMsDnsmcNk2omXE5mPN9Al96Rd32jXV+06ddtVpktRlnYwclBZujrO
+vgLwkFQxVkrJojPrKGswWJ+g6BBjIntQ3iG2scLFZYFljHmgYIEcRNOTp9ShZObhz0hQlH2ydQfx
+Xs1gKStzw77M4e2XH0lR3Y5vGqQNB6U4FO2N2d/zKjSfxoNtPjj6Ae9t0aEHzMJNahayrDU0aqNs
+ZFiXpTgU0l+1F/lXSPjBz/5yVp1lx6RHjsoY3sZZ1AbjaHBsSxBkYY/G3YeN02aqUVTwVyYx3mPg
+4X003Ar7bOtr0R1LVlQuJEMWH/d9YdM2AvBCtAYSjbgHw+A0ctql0JhNJoKtgMloKUMBY3Dft6Qx
+aby2WmqUM407wU5wdYqKJUFBWtThlqJXIZAZOuAimtTONImICvEAtl5Ik5JRfjqfLB8xRqONhwPH
+/3uUr39Djx5Wv8PPkHoVZeYL0bIKSv83pZxVbcVCGu/w46mG7kk9fTT19Pf89LCheR0RdVWvrKgL
+B2nlRhjiL90XDk7LKmRp6UqOTU4A7+yMv4PjaRwEYphf0ha5FfShKANeQvpStKiI3c1oFMvzM4LH
+DvFWtK7D3Wd814+QG9pcJbxEfXt/eEQ27IzdcNdT2S4JjyMACe3cseoRhcBkr/hZT+TrsTGQsFgx
+BCt5gQU8qAdfjLgcYgYQKYrp8iVHbKSvMFECkkd12hVIViJVUKRyRZ5kEUVO/MiVXVTqGCqjrLTT
+jmQwGPx9rrHCXKVPRo4odWpyOcmIliU+rC0JTfzpprQy02QbwNgbpniX3JfnkEs7V/aUFU1Gn6x0
+n6zqPjksL+G1c1i55MIUmTf2bppt9USvR+Chw3GsPseAwEiUxDu1BRdBrMERFvrGzMXOcKlAvDUf
+FSrlAh5g/Qc2h9a/BaIOUBdSpCy2nmOFcJZdmodM4nTVBbPqLFadw5AKlXIuVW1OVpvFagPpRwTp
+R4BznSfAQ+FK2ZgBqECB31Zw9wHy6PucA7RadC0ZFY8cZY8hadM9dKwNzyTbygRZQZaUKeAu5IBc
+tCAMF5VvQpu+Gpku5q0pEpMvSTWWkPSeouO2kvucxDOnJJiGZ867lFxGFpKmPoxVplwv6WGTEwQH
+vfG9/sf7P/nw/v13HrSC7zsUBCDuLAFvNK8lJBSsocNXsYKFk8nYteGEMxkX//GA8zxI6lUKzoOR
+ZOJHLdKjx7/GbzeIf6nvynLsZBGXWX+ufMvG50n9G+/cY8G3IcID2sIkFkPXxfbmOLvxXlrwB63t
+JS92yGWieeTFDuXwh7+MokV97D+RKJ0f3/JL/B4V8Zd+hT8+6YRfIcA57Npm51FM7YiP0Pdu6Ngv
+8MfHbM7Gvmeg3l/d0s13Qf504oQ1GL/3WJ6vsByhxyNfl4///JZNlTjLXTn4Y8ChQS41shN+H7lO
+PozAw3uG5cOfFoMcftfVS9h+Zpzh0rmE6XZWnyR4aDKx1aEbQnEwLG9SRDDLEc+yw3ACbr8ZNRzo
+HTfe/ahknFCi7LFWwUPlAfBjPrgg4YDVK/0lhwzNJM2Sb7Tt4Tns9QmvnsRf8rBNTGSJ/i7dzsTN
+8mBFynYYDZnMHTB0rs2+oJJenUDISikTqtltVFO20T5bWur3k+7gSx79sxTd7KCnYQrP65K/DBuv
+1uOi2f1brALIINrhCFJ6sJqIIjbjBRvy9TnYSIsovus3o4ZPZehkvD+VgkON7zOTRhyRxQjoWa3A
+QrEpFsMVoukjf3IGY38znRgA0aKwXOxnXOCmowCUTIB0X4bfRcRq9FINxI8wK8othYkpQrkCjLcQ
++YuL8mS2GGHEU/hCfxkw3DxZKzvUvoiUD2aM+JdXrpjzUSAdkGbx2Kum1gByFEEWU2EOi3QJXoVB
+zCwkTMlUSsjK6QxE8KDx2hG2kGcbPuy/zR54y0U2cMnL6K1RgDadxRgXjz+MWcUQhSrDDR8dqvWX
+6cDOVlGnPeozYp/e9Y8cNXf9GLg62JahMBlkEMFWMACBG7X+j44BQUi5aRDxhiI4KyLiaGKiwzBy
+z6VpjhdvWUQYg+FkBklZ6VDMOIeL0BUr8gsP37AD27pt+w2DMm4d3qPiGNnkIseWRXCjAXWTmSYd
+yOEAc0HAkk1U8ulHqKLFpgh1Jr7zJxKb45sr5FY6CWyPhq09uJ8qBj2W3MaU89h0ARrOY8Mw5Zl4
+N5RsEGY0c9upLhEkJYzGd0JJT1iWZRPkGzkoLqxmwEbcwOLXJcuKRSSe+fiYxe87oQMcvPd2yEN0
+xKb+cjMZtUMr5nosCvbuyLcF4+3lRY8BdMRKIFQoYK3LB+PdWxYXc9zq7i1XFtWeFy12sQcF8m4W
+3zwYDywu+txXn/vqc8+w+Wwg21e981O9QxSumaNUjmzAkZkcTUZJFMONNyw4WXjU7L9dWyO2YnGk
+G5iQe7dHue1JSJpGIwAOqmCYF9Dly184Nq4BKYSMWinjNZRCZlgum0p5uGjZvMAns9fYHaRDsQzG
+8GmNf44qp/gX+C8AjY5H22LYoEfZNthtVu0Fi0IXpM0i/Giv+zb+hx/yfqE6BwZYxfPJghTcZJgz
+btrs18NUgVOvD5hByp8Yz1gssCbD17xKfIDVZ7iQQ+CY8WTacXoooKKlnT/NbkVpGL599Ak0DURh
+PPXwYUe/wOrGXyADotQJhKjL6YCvfJcTkaN61Kh2siEdaja+LQUzTFBj1YkOxa0wR4k5O+zO+GcS
+KvAwz1BlUQgsGIYXUYRX9E0/aqUtlKjVrzMZnH2KXsuhxL9wiRbaW6sNstxFK0sx03JshhUGLx1D
+Y9lixitFXnuPAretlMLtrMpk3SjHOMLTVbnfV1dNqCsGdILhlKVKcrrfnpzut5IEwOfLVu35smWe
+L1vS/oZuLiWGN+axMkD1bYYu1VhAKB8hHD11C9Owz4R5UX62vfjiSvwLpVr12Ju3F+/7oRTqPQWS
+eYQ+naQn9ggx59vdKZRCVFEgetwTuS2JZGFJiwneRJANFkUSJr5LJ/3xEUIp2rkk2xaLFEaokrLV
+ToxlEOToxtkhWhUskYdVzDL9/jLdUo1vqJAMQzoF9J8EacBbUbGQJxVantgSiMSItHliJYtklBbY
+Rnsk/vgyC+nCICcs2DwrN2WijYk2J9oq0cFEhxMdlehiosuJrkr0MNHjRE8lZjAxw4mZOL8YSDnZ
+rWXJ1GIpaUxpBCAi5pEiBiBoRkH8hjv2HLQ2xice/+P1lUEYEW+/8/gyn35pcH4yQrOi3BUyPnP2
+ChJYs6YmBG8Lkwem/lJAzVLkrrzshYajwOA6BMdKEVVIWDKPUethdvK8vyfGb7FX7QwrWVk6yC8m
+WkQR0eDVFXh7hi6gJAzVLVCc8Ex/iUKlLCtyPB2KiWIjBbLJxDKzqMgGT2i9DKOQpyskoAvWPlSh
+GWNrZNH2IKILrC7didNNO/xYIvUirG/emTdSMxEVUs0sSFG2ZEU6vCJtXpHEEj0+7PDCz3PR29Eu
+jPge7T2Q8/HmEiVwG08iWQetmCFKy8QKibrEv5KUWdScMwgZxLs1/iXlEfXyEKcGyh1wg7G1OHh7
+DYvWJnjcP1+vcDRH86RPYpd2VtRFutCfVfzaQ8edil//hvi1i5xawBdIIrVcEkO+2Qan9QpKnY/i
+Hdb1X3LQNaXZno62VyhnZbRiBj0OEL91UvzWIUcSkt+S5gZVvhnJbzPIb+kLZShIl/zWwYpd1vLk
+kN8Ct0d+S26riTgKUhubo2BlWMJJnTQnJQM/b4GFJjwciRH3lSYz3e7Ybt1pwa13leSktSc8Hx5N
+CiONS/KKIJdi/JMMED0E628lnng1k+LQvRG+KaCz/1wJBbWzIKRK4JSgnmGoexLqHkI9i18hObHz
+NNQ9DXWfoZ49KdTFuFB35a2mFLq5hlDjolBjzIOKuGmH32Pr4qALVr5cpGoG5I3R1njHjxieVkqW
+ZNv3QxkP1V2CwpabumBU0rdcxuu958SJW/70wR8+1PRirLfnxBe+M+vFuI9GnkqRcGl3toEiybP3
+gzKeGiHXA0F9OxUdKXv6982vKVs9D1sj5Sz8u+1u2PzHH8Q+VmZZ1jMt3CH+NRTu2fkNa2SsDDdg
+htHtzxozw2bMMPLF78wauTt+2NpQJ8cw5Tjwsd1PHzPLEGXZfcffveksyIPb+LoZgYRQxpGf3/Lx
+H07CnKJ+RmBi0N+bX3M3xUKOf3kEJ6Y9vu0hc5NO8HM1/HAICDv4hoIA2IetgbJft3oX4QYbz29Y
+A+N11kFO7mJOAODAmJ2FjQSkr+1nr7uiAntocv6dysXsy7sbenT7N4iHocDF7nsRLnh46FQwgCh1
+q0y9W9sP2WUHB2BHVTMO2RrGUMcecN66LWfoHYDrJ9R4Rq0lB+2LHHRF4lIj7rgVIQ3CN3mWDbgw
+R6jBSHN1izUy1m9J5+zEkyEKRTTNYc0jfNPh1o9o0/At1xGkfJEEdKcwDNTi8+bbt7EpsQBsiq4u
+soULetDp+c0nDn/hve/97ANv39Jjhdtv4QIRv/uXhz78vf+8+yuv+51lvDuItu1jFRyVL+uWHCXv
+wjgAbEH/7JQ/8RLqNCe6CW/uXn3vTRiob5pzyU14uxQe6a7wQV2DwJdX3RQJeJWU6Hn2DjSrgq8o
+02Pfup2lBKuneQckzrh1e89n37/tA2/+iDtSgk4iV3JlEF0Ay5G9n/rbT935W6tni+rwNCeMrJsg
+z08tnIPbRCX8gbSrhiLbryIw/pStcTpxX3mbiNdW5B1MeNWCYEesw/Y9bB8WnOoBiKdijFbhTZ1W
+I12W5+/fraTVLUmrkXV33Dm0wOqL6PrgbWxAx8casaWqxVLlbCU+D8RfeVxow7ud+jTQDrb7Ist7
+HryBijq/kf2S/ANTJZ/5WY4t7bMlt6jw0Tkel80osUtxPC8b1LcUpCY8lMtBGiJIVYOTWIU7aIiQ
+k7kTQwTcNgl+f9MgnZZRikOBrLW5gTANEYRpiCBMQwSOfY0aWaQleZK7c2yIYNRG2Uhxm8MlmaNs
+GbQj8QNtQkNSmaD9BY7qKOkbBJ/dk0Rce3ZvGuFod7L+FSzhwPIeLOIdBhQVYeeXK6EfczJwyGCQ
+Smng4AibQlhVt+yO2zKZb+QYjjm0g+DwzfjLD9RglUVEjkXfDFtE5KXCHABBh3Z5vJ1d1yICz1kT
+i4ixwFKtg8IEbrKVdrRCOnvxyUEWUH95ICS9INU0Tl3jMIH+Ern0sfso8XSSvg5AWCowyFAGiqo6
+Z5kwl+rpepBXpiXOGIB0ngJAWmMCzmLACVk39CvHpit4fsGdorPdDF9ENduQeI2ub2ivVGCYBHSF
+BneCwS12fUN2uuFmngIKeQj4pG+8YTpeThM83f8j99dwu8s30UhZSEotbUQvgsGxbqA94etnd6Jo
+Ns71M335UCk1gzfUnwh1CfP/V/PxlNwIPNmUzEO5y6EFouxfyPBD0JUwMnqJ9CXcdj4XCD7gK8Wh
+xZq8Mula1P3emLzuowcpkCTpGB3vQtMOPyNPazlGk2GZF7GHLMkTYdXLC4DIE32VQkpFW3M+2+SJ
+tskTbZMnCoIESAI+8kTfNM4zaqNseAhtGOehCor8cPNNJxzHTYPazP55fCDA/jwgTSje6sW2TrRl
+IgplNhrqZdDJGtqQIp932IHiqKB/lrSVGVCYd1iKCm78GIglebJTSy5GZlDFlSUfPBmK4qD4rcAI
+K9nNhI9D8dZt2/3BSLmxq//OHfvdWC9suljGLj1B4ssulgJETkakxMN9QLnN8Ymtj2XRvSV9V+Kt
+I+7aONxMggaBFAvh0LCcx/F2cTfHgXfLdJQuECKONAuQ6GHzFavH0KHmIBsnGCDIyh5n64Cg/jt3
+7HdjvTBBQHZYgFpCGnQ6rCxHRnZThb2ujV2NvIpKdWyRdZwEeOw5FiHBnsUG+S4aVaDNWxlENzF4
+fNZB6/VhmSvHMleOlTZr1V27SXdNmbVaqWx0/51sMGy2QQ5eSV4EtDkNcXtSL0nrTy3FhVrvA7WT
+YSk6f1VmonbkRDUCnzTBHMOIdIwjHksf8bAsdtoE1Uof8VRRUiXlhoOxu1k/RYOxtxmprFCDqVXo
+4hAs1l3ZqLuy+CYv6qdZF/y7MXXBYxR9ry8aa0/tWOnIGqvWsheXyURMKn/DclZrPXnSEjyyIhK2
+LBLDkBoH8ognXyLuHOWnk2UGmcDnyWAD8VYMlop0Bi5vCDWgDc9gqZGW8jXIIxrRAL1hqISn+7AU
+8pi7AdPy6mJQA2Umq/kGyI4XgzCzU5WZrdYbjftBRW0rj6crpTxuGIu4iMJ/3jaSGNnSfeyy3eAK
+W1iCrmf7aH5fqCBlhwRAZfIhRXdlWWznKHF0XYpUwL6ybndxYQacL+B8AUr5rG6PguR8JCAXKoBo
+UH0/aqbNQ2toHWBFgZ1C1Ue33EQDWsyuKEqNMJk22svxreLGBtd1BR4JNBDcG0HMAemp1BA/biVn
+cJAtk3UdGGk2AImkgcrjzQYHfv8Wp9Zhn8A2PP+RJ5+U/mEbJNBOOQRqjT6LYTcO6z5kTyvwOqSz
+7SibCOJ4qlSnq6q7nnAsb7zuUmc9FzYlWaNDblVnHWMgNrvGbKrqN9lBN8meNw6WfbJKJh40Zv+L
+Dh4uYsehI0V9qQwtjJJLZUV5qYzkx4DuYwRRoR8P0tAiKSdtn3DZ8akgGoyia5DknMs3L1KkUctJ
+UAtRxtYoI6pRBnlnWXed4uIlcqXbqFoWScsNJFeCIMqH869zRbZWCpc2pkiBgCefl1CfsOwlByQs
+n8ZbbV5XJOGibRgFbJQXENjaOFGXu2V1tYCEMNgWo+Ena+SV/qDBzQKGkN0LYghpSlB2RwxxdKZM
+jjAkhxiSQQxxGEMEYgjIl6UMY0iGWmAMEZEM8IMYkm2Dd4Qh6N5PYohDGOKomxrotagNrY/xooFn
+YLhNGF7df+y7XIxj9517byxG2UOnqve2MTKzy7QYs8ZiHL+rhIUOexs4T79g614j1MH+8bZjipkD
+XWKpFzfe8n5V1U7Nkjs1S+7UrGSnZqV2SVZqp2ZV79SkrxeLd2oW79Ss1E7NSu3ULOVr3typWamd
+mlW9U7Oqd2rs4Qt3avIOSHIsG1nGMlBQFCko8jZ3tmXeGLlX1L3pQSICTLRFIjz0xLi44VRfoEAT
+fvIxhGZTLt6fQMPUxqUcWtSiSxROvJUv86YvRKTvVFjqToWl71RUXZloYo28MYCPjDWAM3HzhBSi
+6g6IRJuxu1/nSkhV90dtV8hjuhoZKDm1o3YAs4T2yE1GrfGLKg2OsC023WUSLgXbhWT4jxow04V3
+E/S4R5kGuz1WT14fDlB9V+Gt8dzSIuz2pjl+j/WCoou/UDXq3XtT2Y0yVxcdpVlTEjSSFllpqhJP
+ZXR78jdjefJEqKVuMt1zQWpFMkc3g2KbRyh/kXaMD4SltlBZE1gG0wg+47g2W70aDhGfMgiWGGU7
+KiUXzy962P0JHThnUvB08AjHqwvirAZxK4CYzhvKHj6GN5Vhr3n1EEM9Kuei7L14+pK7uozR1LJ0
+JONfjYZ7L2+rPxF0Vp3qW6pVPSd0NcboGx16yKnmRvHIhzijMWM4yi55/BV5T3jutC/Do0/oVlmK
+XslbZWeGOBmkqfZ+Vx1aRILPGE13PbUt20E15ax6TNOZn9sOmgM4tbfL4vPkTovO5V+OC4UsYjCd
+UDsHy9Q498fD+7KHX3hqnU2Oe/065+w3VzCuw9hHtHSOjBSWbQ9QIYW30dRtUzwV/wm5pedu4PGt
+W6F0eUBMLWdOfpicX1JdSc2JN+vwKMcWmYMPfUlDqo7vJDxAMnHVZLgGSkducM9pMtDTQ5QzzT8/
+fJrc8nSuS55pZvlb4QgTiVP9BdpVwtZUqeTyT8TKSIttkrYounA3sCkYSYZGksGRYH97Qj7cRSTh
+jB7NQibeLTAfjE5O0c00RT0j9tWoHe3xd6DGlE2TAjmD+H0KI6dZGnuKfnPGht11iqPu+vMPuiTt
+Dx/BO0axV6tPCr5h1/ORmVil4XpTVoyHqRZ3LCtGm3MdGisX2s3ZyqcwPOV4E+ESe7NJpWi620QV
+WPhdHNZUdAjj836Ed5MOEVjJKsm0n7ecNA0xHbNCkRy+WqgUc9LQUZAyMH5UathqdIlFPm5tjd/3
+gzFy0NGstMOs2Qok/j7pOqXx/Ad6fl9deDPk/osgl6sDX4chhl4EHdT6KTAqr1v/TSX5JnD8IF0o
++5pSWZJKl/14vvZRboCy7Xx01HC7pSxb7ZRlqwQYu1F6KuxaTdgp09YBkbkZVa89eCrQeAveLFQ/
+Mzejl354jnaU/ZtBtHPwVz7K3AzCVk90K4h2JFlF+ci/GSW8q++FVJAgox3bb8IAg2iBA6h5Myp2
+b77ppi7HR9UIH1DuIAet+vEN6cfX0+MXbOFLC3riJJF0aGgRd4jR1qrCoc4W8stIsGyLZqlkDU23
+ejIRX9eKPL7UhRPr9oMccNNg2a/I0w+0myvnYo5SDHLBZXQK7gzjvbLBkg2/b8JzIrT+QHPqfkx1
+ozyZgOI9OjyP2iyDD0Tu8BA7DCdjEQ++UFpeIuVdqt1CMwAqKDqUe/Hq3AFdsqbWUaHGrjc4Zhre
+u6ORCjlSJSSnRmoF/4C88nRAyJUyj6wDNJeOIyvq/u9lCnnpwGUtHRR5kbxVYY6DTt7sugOobcsK
+nge95tt+0q8YnvLgLT+Xr1l6i0ntIfj0xNhSLJT3FtzI66dLXEHwjlcLVJCMWsFtr/Yt/hPwycEn
+D58APgX4mO+K8GmATyN8Qvg0wWcCfJrh01KVdyJ8nrt+zcCqvoH163rXrd80MLxi7fqV/cNDvQMb
+e1cOr1k/sHL9ADytHF7dt+a61cPDa9b1rVzdu2bgmjWrNvZBuaFrNw2s2ti7atVQ38aNWNENs1av
+X9c3a+WG3uGhNSv7Z81c2Tt03fpZQ33Xrdk4PHTjrI1DK2ddt2Z49aYVM1euXzdjdt/KlfPnXHTR
+qhUX9a3snjN31sr1G9dd37tx3YyNw6tmzJ7ZObNzxoq+4V4q13fDhvVDwxtnDm2Efu+B0fXB9zb4
+TDWed1U9XyufsdKVmzYOr1+3onegvwc+V2y8bsWmoQEcx/D6a+QYXgLZ4MXKtX29Q5C2bo2GAOXY
+tGFV73Afv6B/1q25bghSBvquv2bl+lV9AJd1G69bM7BxuHdgeA28kIlre1f0re27oW/lpuG+F25a
+AS1c17vxmrVr1q0ZfkHfhrU3LhsY6NvcN7Rx08qV0Im+oaH1Q71rr++9ceP6/oXrNgzfuHBz38Dw
+8I0b+nqHAa4roJaNsfrV33fj5t61m/pe0Ldxw3oYTh/m3ThJ4oYLn8nwaYXPFPj0Rpeu2bhhbe+N
+0Zp1G9b2rYO8vTjR0VDfMECjb1XUOxBRB6JNAwDxvpXDfavW3jhrCGAHU9B50ZxVnSvmr5g399o5
+q/oumt/Ve21nd3dXd9fc2RfOXrFi9srOFbO7V82dtXbNiqFemO/etYBQNHsw/WsGrqPJ22KH1lLo
+y8dzjKtq0q+BSV+wAIe5ccGCKwAQvdf1LRm4dn36PUzTprXDkEPPDKcsWPBcmfACer54jGJDEk4L
+FiiIPXvl9dcM9K7rA8BvXrMSXsAcLliwJJlFxIh6WSD9CkaAukNYOLC5brGFjAhQmtejKz+Ip23w
+aa9ap2chjACSMDnLXyDHumng+qHeDR3TlkcwdzBlyxcODS2PCBGssy0UH7mOc+Czbg0uzuuia9f0
+rYUqll/shkQflsI31r9q04a1a1bCKFQOSHslvGsy8mwa6B9Yf/0AtDC0BqACtUyPFHpgWyMy/1vg
+G/FuzQD0Zc2q6EVrBobnz4vOOy+aEe2Fd0iTRuHbrcoze053dB6kHZL1qDyb1q5dIrMB5cHZ7Rvq
+wF/Q6B8hD+L2lQDhaHj9+mjtehhlx9q+geuGV0cRLM9r5O9pVrsXWrgm5njcv2d7PC5dduNqIC66
+sPVSj+uum39178ZoRV/fQDTc2w//duAUQ392QJ6p1XlXre/bGA2sHwZoAQnUee+rygvYtunaa9es
+XAMLMiKqGgFlGraOyH68aKB30zB0cc1f962yMtynY05IOIJVMoXtGyLafW3fUAR5cP475PcwrKJ1
+uNqf6EpeuX6ojxbyGmhlVu+q3g3wvXFW38AmaBxwB1b2EmjrFdBWp+RR5h8Qrj6gZADqCAhpdD3w
+gGg9kLxr166/vur9OkDwNUAUazJdYCXrZTp8gJ9aMw06N0u2PfsvhM5dlx2PzmmCtPFGmLh1moq9
+kB7Hp2GnR/pWALMaunHBgh76fvazLzBozhz4zIXPPAnLFpl+oYS3SYNgmfYNDfSuZbgtiPrwGSC5
+aWCorxfW5Iq1fREyvAWA39v90Dof5+SMoBuMbc3wxlm9K1duWsf8fx/U/yL4fpPsXzWNi3JM42bl
+xqZxl+SY1qg8J6Nxq2T+TTlefyYc52M9T072WdG7sW/+vBmdM2fPndlJuVeR/EADvgvafDm08S+C
+abp6Plz1/H3BMqB6fqjq/cNV7/+j6v1/Vr3/TdX731W9f6zq/Ymq956dfu/b6fcNVe+bqt4PyHVt
+0IeNm1YQrtfQB1XGgT50VT2fazy78DzNeC4JlpPV8/lV7/F5kvE8s+o9PncYzzME83L1PLeq/lgw
+PVDPl8LzeVXPE4znxYLpqXp+qWB5Xj1fW9WfG6rmYFtV+28QLPur5zcLpplL1m1YD6sIlvECIMLA
+rNYPABVe3bu5L+pEwHdHawY2bBqOVtwI8if8jtb2QqaVq2HdTOfJGFgfKabOjHTjqkJoXW209Z6q
+se+p6uvH5ViXyWmNrl8NHBakn5Wb1gIBhxW+ftMwdQLYJbA5biYp/w6L90ZnfC32Dci1qMSRF129
+qBv4TZHbRfrZLmnkddCv9WP2X3Z8I3ByKymPON5kpXkc4vAqn3m8Ait3DChsA8tST+F+a2MfbQF5
+w9UK7am9FLZrPnvG80UW7zWe2zuAQg8whlWRrEjPlcqL48O5vvryZ176ggXRi1F4ZcTDoiv6Ilzx
+NyKivXAYNkTXgfy8sQ9nfhjT1q1H5ANwbIxuXL8Jfg1Emzb2JVmH+tbBJES4GYNOzIwuR+EQNoDA
+CaPFfcM0F9wASc0bo2uH1q+jDFA8WsNC2/V9a9cCwdmAO0+UGYAArYY+rkd5Ymb0QviO1l8LKDkU
+aeZIP67thY0c9gkrWbUGZ7yP9xIwruHrUXbshQYGZpBUiDIfbONAJGGxJOnVzOgFuPGGrNdPV8Nk
+uMLKBJBib1b0wRJdg32ArpgjmhldvT7aMLQetifDVJhGODy0fhNyakBHxNMBWLp9OOwN0WroJA5q
+aOjG6FoQjLBy2gDDjhLk0pV9peglIPxCh1A461u7EoeP9QJtIImE9qP49FxAK9xKT4/W9fYjoIdX
+A0DXAU+PNq5HNF4/0BfB/jaSrayHf4ZmPoW4DEJgojt4OGTdwEsspj0mH++WOLzAonMqiyme3lwg
+WFARcA2txl7ELOOBBaO+VbA8dzWx3D5WeZjH9QMgkKwFMlCTYNTzINSDe0LKs3rTut6B9HtrArcj
+t8tXr19PeK5X0ereDRv6BgATcALg/15YPtfh8kGwv/iKmQoWj1rMc9Rzk+RBktpd1rtx9aL1Q+tg
+AZxy1bquC2RdC0ncRjIazQGhEVYr0AZAsD6NLxEQ3AvHqTHp3/ki3d+lVc/Pk89PIU6tAwIzdCOg
+1AugNliLG9bT0ifSAdtWwKXm0Fol8QlppMy3cbgXUBFpCWZTxawk/3Nk/hdJeVSK29ajzSzTKg40
+BOIhsJkbow2wMV7XB5XA6tW0imnAAmDdSFZmA/AKLSHJqar8xjXXDfTCbqgP0RKm9nJ432q8h23u
+avnKWgvvmpM+wVRSr0jrZa6fi5PyL5Dduwp7J9NeqJpkZKrBrucisRnaiGBSo7asn0HbOJeXrtm8
+BnBnxY3RX/cNrV8QuROZBypZATO3Q1pe49rGPpDkYUURCbpxQ19E9XVO5DWzGL5tnReASDsImI31
+nPmVExkeKh9h/bXrYXOe8OXtsj3J71hiJ9lAi0kostKmEBvfDfmfYcAYyEYvyQIL9FbjWREIt5t6
+1z7rIORFmeKRibyHV2V6SAZIKnUnyfH0DcB4V2rInTuJ8UVORLRh0wrkMhqwF09inciLodS1uDky
+wP5KeId7wWRCFJQ3AqdZmZrzZ+m56bnx5TAz5rtnG/NjpiOOv1DOTh9MANd6DcJ93cbrAGU2Yiqs
+lOv6hin1yvXDixD0wE5WSUC8aPjabvnzUgDjC6EmBcMUTb8E6SeBVOZmAEpwQTMSQFcRfOC5iifE
+VTDCHOb7HhzL6rUvXD101frrr9i09oWbVsSrVkmMYMGY1uAnJodWFvJ+Gr4z8P15+PYM+BAert+A
+6hRoJd2Hp8GHXg2smi2/59TODdWQKvdc+BAl0AhKa0gtIituDUkeX9bKOGbOY9KfgVVS/rxmqG8Q
+qMpw8sgq1IH112zctHL1NUoxIbfSmwa07KRKQhsjrYyXt7fy+v1b+f2xVobPJ1uZ1pBOHvugWpFV
+qHUA+Ax7epKcJJUCGjclJD13ai3gmod05PU9vcMrV8vUyyAtSNYVTz/TIcqG4++H99dP4fV/vJXn
+62Mwb/fA50Pw+SB8PgCf3fBZZCWy+2L4XAYfM20JfPZNYbrxvBcuu5L0iL0RKuZ6o95rkXcgo6Nd
+Fc0Zsj6QB3uHhlhUWte7YaYuiNLj9avXAI3ZAMJmhCqStUi/tJp0o1EnC5O0gKDFtSh+bdwEw7sO
+pBYQAFevAaCgBM1KSmiWmkFJWwqcKI3TDmgVyndA32Z0z1y2ooKSJcJfisu9kijNVFO0CUQaJIj0
+D3E6/QoXtfo9sGndCuBe6rFv48peoL8bcbpBPJi5UClhSIzUAyRlADJTaJf6y6NMcq8nog49X4Py
+JeRaPjy0qW/59Gj5tb1rN+KP9ZSKfHj5eK2sMOs4b/p5y2XB815znlEOAXt9Ateo49Lndnb+eORt
+ly5atGja6VaPv/4qXTtK3qnqu7n6npNXj7UtwNqWLcLZBvFfsbs06Oq8ljNa59VAtJ4woG6xtYBI
+M0ktuX6t0R1in4hgstonKZ8BTVjVN6OyEdcCimmdM+fOnC11Z7M2DTAiodR/uD20roN193SLdR/j
+6aNVXtSLTrP476T6pyuhC6v7bojiFz53yZLqAVu6/b+xWP/xVI573fpVtNE5eFZorbBY94X7bPX8
+GviUjeetFuvTe1gzAehzLcmvq84On9q+whvV2ZugrZXQ1jdkX09H13zsbNY1m3+noi8cI38NPjx1
+uiTLuukc1v+81WId4CaUBcfTHoHgp/QoqiziFMqg6vmTFp//qedPWbyfNZ+fbjz/3mKdjXp+zGJ9
+lPncbjw/brG+23wuGc/Ngs8SzOec8dxS9RxU5Q+q3hcF2zOo50LV+8aq5yb5nOgzYau0rhftE4bm
+lViuVXmVblc9P1OVVWpMZMYbb1y3AqgYsItrr0UNFHR2g6xnO3xj/jeV+AxhoWKSfTdo3kka1N5o
+/owVa4aTnsy09kCZC4y2cMOA8/ZgiWWV6rrH1oky/0T9D2ljSTlLmoen8kjC6iozzO6X+FcqP+3c
+pz/jvI5p518wfUbn7Dlz5104v6v7okvinudeunDR4suWPG/p5VdcedXzX/DCq1/04pe+7OWvWN67
+YuWqvtVrKv1r120YHErnWyYzvgRyUr5rr+OcA+sh78bhTZuvv+HGv06auWD6zFlProaZs5LfT6Sm
+J9f6jGue5PhnnTjZnyVsx/UyWT+XDwonThQbGsOmCc0tEyfx68mtU6a2tZ919jkRzeQJOZUnZgBg
+8D03deIENLbgmRefOPGsZz/npE3+hf5RzxluMJRnydQUfBLoAFz4vQkdheeMNH+mYTyZP0uo0etp
+HGv0U9v4/Vijn3fhn2sQT+LPnGyZVD1qYy3QX/WoawD4v+jv2aeN/8/5P4T/MPoTz/m/tv4fflpo
+3QWfVfA5Fz4PA3++Cz7nToNPB3zOg88z4PN0+JwbWssM3cRV8Hk+yhhG2gvgsxxVBSBX3Hg+62am
+g4Cy43zWh9xwPssl6pt2xcuT57vOZz2Xej4j+whUws+ec1F6r9N3A1p3gHS1oXdgzcr957Nccsjn
+M4CrrUQfhjYjL7b47EfZ1C3bgPq2apu6aDls6fqkTR3r+iMy82E9KcBEaniv7YWd7yoQgLZcENLe
+8o4LeN+kbFk2Dq+i7lJp6O19F7Be+VIpa1bno0H0sxXRgxewDniRtJNQz4vhGe38Xmol9k8vk2NV
+84cwQHusUD6/Ej5/VZXnVfC5BufOgFEvfHBfuLIqfZV8xj9lE1RrADXUe/01m/twnLD37oVJudHc
+c903nW1odk3ncaB9COrUeqUKj8RZMvc5qeFWbdPXrhtGybR5BsN3hc37lmm1OaGDEnWmoeXfprWr
+UEty8bNwbxV1wA54ee/w8mgjYBVqw1bBvh4Toa4NM3iOXzaDde4Xz2DcftYMHs+eLJ8pmnDD8yhC
+FamMNN/hOfiiofXrUJe9UOoqpTR/veoWKmrp5BBVfvSAujOZi2wX18HIcOt6LXU3YrV5da61mFo/
+l7IuWLUGFmC1jkbuYliVpuwb6CiZD5s517SZM98/k+kCA2z9pmFcJCuwso0LWLMJwAUwkl6RD5cx
+IwH2npkh7VkfmMlnPaexNq21Bk6ug88jM1jHunxBpH9fOIv7ttZYL2hbtB7nFD4R/r06Pz0/Hb6i
+10Sv6ch3TM+/gvKruRrE9VNjoAZIN2uAzNI6b+js7JzdOadzbue8zgs753d2dXZ3XjS7c/bs2XNm
+z509b/aFs+fP7prdPfuiOZ1zZs+ZM2funHlzLpwzf07XnO45F83tnDt77py5c+fOm3vh3Plzu+Z2
+z71oXue82fPmzJs7b968C+fNn9c1r3veRRd2Xjj7wjkXzr1w3oUXXjj/wq4Luy+8aH7n/Nnz58yf
+O3/e/Avnz5/fNb97/kVdnV2zu+Z0ze2a13Vh1/yurq7urou6O7tnd8/pnts9r/vC7vndXd3d3Rdd
+BF28CJq/CKq+CIpdBEm9aIROq46J24Lo/JWbhoaiZ0ezL7Ks18/iM+mfCl67JowQf3FviLr4od6B
+6/qkhpanWiEFv0GU3gh0mxiMNLy9r5Pn/5/gu2zQFw1uKjCLqsO1fhzyIV1E+xtPt9lH+EvLdjaf
+Laj6VP4lMj+3z3mTg1nC0D40woUH66Wz+ZxsYDbvy1Udr5R1iD/zn/Wk/+xx/5yqPxf/jNK1czSs
+9HqvmDlz5l+RXkMiACz2FGHAX8uhjvvn8FnMP89hWM+bxXT1zjmMa3gOg7xyBUgLA0iocYo78Mc0
+VofgRCLvgMr8ucx/J81lG/KpcxkHqutcL+dPPaNeFG2Kk9MMMjSnjsL4nhkh3UTdykY6Qutg9j+N
+hqD6v3Yun+++dS6fp71rLstA1W1vkW3XwE6emMzaAER1GNWcrGs5DPWgzg7trVD3ZgnH8zIZO5vx
+s7mmfHswpTC1GDYUG93QmTChOTdJTHZbxRRnarZNtNvnTIqcC5wZwUzR6cy254i77Q/ZH3Y/4v+3
+/UfvcftPzoncvTfc+MY3vb/zJS99420723/Q0Lj08j8+NnPWc175V9f8ePub3vyWt37o45/5xy//
+01e++sOHf3rCcpsmTJs9r2vBM5+15Hl/tf3N8PK+z/zjP331G998+KeWW2ygtwueuXDRkue9alXf
+9re8+z1f+cY3i03TIGnJS17xyldds6rvTW/5EBT58ld+9PBPjxWbFi5Z1Tey/RP3f+7z//adY/91
+y2vfeNcHP/f5L//zN775ve9ftuuzX/+nb3xzyZXLXvKyV13z+jff/vFPfurzX/inf/5O06TJr3jl
+737/pxMj6wZ/+KOGcwbWt591zWtu/ujHtvzj/ZMmn33OosVXLnvpy1/5qpu3/MOXD/3bg8f+67dD
+G28f3vSOZ8ycdffHPvX5f/7md370rkveuavz9nP+5dA3Tly57OWvyPqN4XmzfvmrgfVdz3pOz8Kd
+b3nhdZsOfOXgtw5/92d/OmFF15S3/cjddqnf5maatt7TMPIR75zc1jZnii/cWe48N+uIbCbblL+q
+cUL2RVnHbc/nHN/JOrh6Cq7nBBnRMNG7MtuWfUnWzkwqXuU+15nhCLcp01hY4J719GuidW7l6SMH
+vG17namZbY87L8tOyrXmWgothUomn5maeVn2Am9RfrpbcIUzO5juTs0Ezsg98GrW7Cuckbv8i51G
+5+Jst3+Bt+1EU6s/q2mGU2osNY7c5m5755Rg4o47vFneM7N2Q2tu5HPl4cLIt6cWvJET3siPCr9+
+j9OV2/rKlpF9/sjXvHzrM518pttf5Bcyw8HZzsvdl+VGbmltz0/KXe6OvCHzkbsKk93Z73O3fu8Z
+2YLnjXww3PrbrIjOz8DbN7kjn3PanMailRECBmd72azt+zk77wV2gxuKJnuC19zUIibak+0pxXbv
+LP9cUXH77Y8599vftL9lHyr8W+7b9nfs74kj3kP2z9yj9i+jY+5xGxBVFM575rOvXHb7e9/7t69+
+49ve8f5PfObWj2eyufnPevaLf3PwW25L6/yuF79ky4c/+rHPXnhkwute/+b3akxERLxy2aq+V37y
+U23tWT8ftEyef9GCPR86/N1c18637Mnmn/nsa9fc/tb113z+l796+YpHHzvxrnfPnHVex4ves/t9
+H7jr7j33fub+/ZmgMPGsBc9Z+PwP3v3A13dnp0wtP/3Zz/nZI7868eV/cqOnPf0ZHXO7F1z2vMuv
+euGLXoxIt3xl37X9G294zZY33PXhj+0dPfjRjw2sf9uryq/2HHeGc60jZs0c2XaWM7ux3T03d7Z3
+gXep23D+yIcz57rnuh3+vODK527tyk3K+63PXHiRs9LPdU7ySk6bJy7pdpd6s9x8Npe9JDrPLeTm
+Owu8qVm3kL1qSdfc4tzsTD+/9RkvuLLDP3/S1Ge0t0zOXQkNXFqcks1nLvPPy20KnhOfn3mml888
+PyO80PFG3rji7Mv8/MgHX1VeGOQzxeYFmfz86e7kkU9fvOqFhcty+UUL2y7zX1hcsjW7KH+Ws3hJ
+l9Pg5zMXZfNb508Z+ZRonFO85d3XbgpG9r/h8pXF7bNu/9a2xe/79LaLsue7r8w8I78o3+E1b9v7
+ir6l7kXZpksQB9553N/+7fNz7//Z1rkznCbX33rb691+r+jksuFbly/ODV888rv8Rn/DxEUj72op
+vCQ3ZeR1Wxc7r+1pnLj9qnNGHrpg5N9mOFNde+sl5zQt8MT2IyO/n3a5m3ftW5ouvfxZI1+8OCPc
+F3lt8+ytDdPdVYUX50c+2n1WcbqbA7zPjLzrlsMw6KIzXHhZFlZRY8HthsF0+OUrt15dmOh4TjZ3
+lhN4mXw+4wNVHfna0/PbM2MSaPl9DVrwMI2+8aKQ7MDxzkeH8Yx7zUnGM+6r0S4GzUdRjjXlp02W
+tEfSGwI2tNi04Zrh9WxyBZJSWubajPzAsaxb3Mh6i7fc+qvm3daEydE5hWj5Ob+avvuC8zuj6es/
+eGS6vWf5jLP/uHym9ado/ntPLJ//uHhovsiXus4tPtT1kYbei2a1vu+izvaHFv/m7NLlxyoPLVu2
+vnTVe+5/31XWN3uf3/et9z3f+l7pBdaRh17Y+VDviz764/e9+ODRh14cWQMvOSZOvASE6Kw1A4QR
+G/4TlwWdE0PRB4TOtoX7NHF22yuCBbmcaHVFDuiCd4FzsX9+q4i6oIDrA0HL5u2zxAIs7vqQJW9P
+FbZ9ERAQF8UPcbbtiACfPcggWuxJQF4WYFuQO+vk7bPFM6FsAUp2QPVQK0ymcLN2QLVil6BRG5/b
+7YvspJWzxGXCFVC58MXzhZ0t+CvQaVzmeXYbSVZdDQJa9AJxbk5c64oMdMqeYrtO6BbhZ0Y0CoC7
+c5Z9Nvx3iS2yvrCDnACyLjbZZbHZce2cyDjfByBAb7NYo+1n8rboPGe22wnPnujIFewIBimcbkEd
+cRb4tr3LEUWRxQYd+58uscSXSpbzJrE8sjJrbMsV+ci+yraQwIoptifeaU+dUBTP8KcEM51OgSA7
+Tzw3g5JbAcY1S8yFWm3bg3Gfb/vilwg2AcJIGOKWSPxYvN2zHBil2+G44u+gfsv+m2C2+2oxv3Ea
+jDLvzIYas+JZzrme8J8tCva8HKw4cY2DgMyI3cLxJxJUhZgkGrKO9yUfBzIZIZrBScIJ+AX0KwPf
+bfaLfEypCCos+hyYUM/KCfu3MB+ADWIntOaKKN+RoVnK2M5MALaVBWCIF0yCjkAtf51xsFaA4GXY
+lIBxAG+zxHPc5+PvmfZkEMod1/N9O3u2e4djdblzfNEgJnmiEWpqolo8wFjxLNfKrstay0eOWSS3
+oU7jGcbn1bAffRV8unFfCh/cT/5/bE4dzHI2AgA=`

wormhole_chain/testutil/keeper/wormhole.go

@@ -1,40 +1,133 @@
 package keeper
 
 import (
+	"io/ioutil"
 	"testing"
+	"time"
 
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/CosmWasm/wasmd/x/wasm"
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/store"
-	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/version"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
+	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
+	"github.com/wormhole-foundation/wormhole-chain/app"
+	"github.com/wormhole-foundation/wormhole-chain/app/wasm_handlers"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+
+	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
+	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/stretchr/testify/require"
+	"github.com/tendermint/spm/cosmoscmd"
 	"github.com/tendermint/tendermint/libs/log"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	tmdb "github.com/tendermint/tm-db"
-	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
-	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
 )
 
 func WormholeKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
-	storeKey := sdk.NewKVStoreKey(types.StoreKey)
-	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
+	keys := sdk.NewKVStoreKeys(
+		authtypes.StoreKey,
+		paramstypes.StoreKey,
+		capabilitytypes.StoreKey,
+		types.StoreKey,
+		wasmtypes.StoreKey,
+	)
+	tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey)
+	memKeys := sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey, types.MemStoreKey)
+	maccPerms := map[string][]string{}
 
 	db := tmdb.NewMemDB()
 	stateStore := store.NewCommitMultiStore(db)
-	stateStore.MountStoreWithDB(storeKey, sdk.StoreTypeIAVL, db)
-	stateStore.MountStoreWithDB(memStoreKey, sdk.StoreTypeMemory, nil)
+	stateStore.MountStoreWithDB(keys[authtypes.StoreKey], sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(keys[paramstypes.StoreKey], sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(keys[capabilitytypes.StoreKey], sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(keys[types.StoreKey], sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(keys[wasmtypes.StoreKey], sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(memKeys[types.MemStoreKey], sdk.StoreTypeMemory, nil)
+	stateStore.MountStoreWithDB(tkeys[paramstypes.TStoreKey], sdk.StoreTypeTransient, nil)
 	require.NoError(t, stateStore.LoadLatestVersion())
 
-	registry := codectypes.NewInterfaceRegistry()
+	encodingConfig := cosmoscmd.MakeEncodingConfig(app.ModuleBasics)
+	appCodec := encodingConfig.Marshaler
+	amino := encodingConfig.Amino
+
+	paramsKeeper := paramskeeper.NewKeeper(appCodec, amino, keys[paramstypes.StoreKey], tkeys[paramstypes.TStoreKey])
+	paramsKeeper.Subspace(types.ModuleName)
+	paramsKeeper.Subspace(wasm.ModuleName)
+
+	paramsKeeper.Subspace(authtypes.ModuleName)
+	subspace_auth, _ := paramsKeeper.GetSubspace(authtypes.ModuleName)
+	accountKeeper := authkeeper.NewAccountKeeper(
+		appCodec, keys[authtypes.StoreKey], subspace_auth, authtypes.ProtoBaseAccount, maccPerms,
+	)
+	// this line is used by starport scaffolding # stargate/app/paramSubspace
+
+	subspaceWasmd, _ := paramsKeeper.GetSubspace(wasmtypes.ModuleName)
+
+	bApp := baseapp.NewBaseApp("wormchain", log.NewNopLogger(), db, encodingConfig.TxConfig.TxDecoder())
+	bApp.SetVersion(version.Version)
+	bApp.SetInterfaceRegistry(encodingConfig.InterfaceRegistry)
+
+	appapp := &app.App{
+		BaseApp: bApp,
+	}
+
 	k := keeper.NewKeeper(
-		codec.NewProtoCodec(registry),
-		storeKey,
-		memStoreKey,
-		nil,
+		appCodec,
+		keys[types.StoreKey],
+		memKeys[types.MemStoreKey],
+		accountKeeper,
 		nil,
 	)
 
-	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger())
+	supportedFeatures := "iterator,staking,stargate"
+	appapp.WormholeKeeper = *k
+
+	appapp.CapabilityKeeper = capabilitykeeper.NewKeeper(appCodec, keys[capabilitytypes.StoreKey], memKeys[capabilitytypes.MemStoreKey])
+	scopedWasmKeeper := appapp.CapabilityKeeper.ScopeToModule(wasm.ModuleName)
+
+	wasmDir, err := ioutil.TempDir("", "")
+	if err != nil {
+		panic(err)
+	}
+	wasmKeeper := wasm.NewKeeper(
+		appCodec,
+		keys[wasmtypes.StoreKey],
+		subspaceWasmd,
+		accountKeeper,
+		&wasm_handlers.BankKeeperHandler{},
+		&wasm_handlers.StakingKeeperHandler{},
+		&wasm_handlers.DistributionKeeperHandler{},
+		&wasm_handlers.ChannelKeeperHandler{},
+		&wasm_handlers.PortKeeperHandler{},
+		scopedWasmKeeper,
+		&wasm_handlers.ICS20TransferPortSourceHandler{},
+		appapp.MsgServiceRouter(),
+		appapp.GRPCQueryRouter(),
+		wasmDir,
+		wasm.DefaultWasmConfig(),
+		supportedFeatures,
+	)
+	ctx := sdk.NewContext(stateStore, tmproto.Header{
+		Time: time.Now(),
+	}, false, log.NewNopLogger())
+	appapp.MountKVStores(keys)
+	appapp.MountTransientStores(tkeys)
+	appapp.MountMemoryStores(memKeys)
+
+	wasmGenState := wasmtypes.GenesisState{}
+	wasmGenState.Params.CodeUploadAccess = wasmtypes.DefaultUploadAccess
+	wasmGenState.Params.InstantiateDefaultPermission = wasmtypes.AccessTypeEverybody
+	wasmKeeper.SetParams(ctx, wasmGenState.Params)
+	permissionedWasmKeeper := wasmkeeper.NewDefaultPermissionKeeper(wasmKeeper)
+	appapp.WormholeKeeper.SetWasmdKeeper(permissionedWasmKeeper)
+	k.SetWasmdKeeper(permissionedWasmKeeper)
+
 	return k, ctx
 }

wormhole_chain/x/tokenbridge/keeper/msg_server_execute_governance_vaa.go

@@ -1,12 +1,10 @@
 package keeper
 
 import (
-	"bytes"
 	"context"
 	"encoding/binary"
 
 	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
-	"github.com/wormhole-foundation/wormhole/sdk/vaa"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/wormhole-foundation/wormhole-chain/x/tokenbridge/types"
@@ -17,7 +15,7 @@ type GovernanceAction uint8
 
 // TokenBridgeModule is the identifier of the TokenBridge module (which is used for governance messages)
 // TODO(csongor): where's the best place to put this? CoreModule is in the node code, why is TokenBridgeModule not?
-var TokenBridgeModule = []byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65}
+var TokenBridgeModule = [32]byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65}
 
 var (
 	ActionRegisterChain GovernanceAction = 1
@@ -33,7 +31,7 @@ func (k msgServer) ExecuteGovernanceVAA(goCtx context.Context, msg *types.MsgExe
 	}
 
 	// Verify VAA
-	err = k.wormholeKeeper.VerifyVAA(ctx, v)
+	action, payload, err := k.wormholeKeeper.VerifyGovernanceVAA(ctx, v, TokenBridgeModule)
 	if err != nil {
 		return nil, err
 	}
@@ -43,39 +41,8 @@ func (k msgServer) ExecuteGovernanceVAA(goCtx context.Context, msg *types.MsgExe
 		return nil, whtypes.ErrNoConfig
 	}
 
-	_, known := k.GetReplayProtection(ctx, v.HexDigest())
-	if known {
-		return nil, types.ErrVAAAlreadyExecuted
-	}
-
-	// Check governance emitter
-	if !bytes.Equal(v.EmitterAddress[:], wormholeConfig.GovernanceEmitter) {
-		return nil, types.ErrInvalidGovernanceEmitter
-	}
-	if v.EmitterChain != vaa.ChainID(wormholeConfig.GovernanceChain) {
-		return nil, types.ErrInvalidGovernanceEmitter
-	}
-
-	if len(v.Payload) < 35 {
-		return nil, types.ErrGovernanceHeaderTooShort
-	}
-
-	// Check governance header
-	if !bytes.Equal(v.Payload[:32], TokenBridgeModule) {
-		return nil, types.ErrUnknownGovernanceModule
-	}
-
-	// Decode header
-	action := GovernanceAction(v.Payload[32])
-	chain := binary.BigEndian.Uint16(v.Payload[33:35])
-	payload := v.Payload[35:]
-
-	if chain != 0 && chain != uint16(wormholeConfig.ChainId) {
-		return nil, types.ErrInvalidGovernanceTargetChain
-	}
-
 	// Execute action
-	switch action {
+	switch GovernanceAction(action) {
 	case ActionRegisterChain:
 		if len(payload) != 34 {
 			return nil, types.ErrInvalidGovernancePayloadLength
@@ -111,8 +78,5 @@ func (k msgServer) ExecuteGovernanceVAA(goCtx context.Context, msg *types.MsgExe
 
 	}
 
-	// Prevent replay
-	k.SetReplayProtection(ctx, types.ReplayProtection{Index: v.HexDigest()})
-
 	return &types.MsgExecuteGovernanceVAAResponse{}, nil
 }

wormhole_chain/x/tokenbridge/types/chain_registration.pb.go

@@ -1,357 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/chain_registration.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type ChainRegistration struct {
-	ChainID        uint32 `protobuf:"varint,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
-	EmitterAddress []byte `protobuf:"bytes,2,opt,name=emitterAddress,proto3" json:"emitterAddress,omitempty"`
-}
-
-func (m *ChainRegistration) Reset()         { *m = ChainRegistration{} }
-func (m *ChainRegistration) String() string { return proto.CompactTextString(m) }
-func (*ChainRegistration) ProtoMessage()    {}
-func (*ChainRegistration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8f6eeeb0759bdcc8, []int{0}
-}
-func (m *ChainRegistration) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ChainRegistration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ChainRegistration.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 *ChainRegistration) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ChainRegistration.Merge(m, src)
-}
-func (m *ChainRegistration) XXX_Size() int {
-	return m.Size()
-}
-func (m *ChainRegistration) XXX_DiscardUnknown() {
-	xxx_messageInfo_ChainRegistration.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ChainRegistration proto.InternalMessageInfo
-
-func (m *ChainRegistration) GetChainID() uint32 {
-	if m != nil {
-		return m.ChainID
-	}
-	return 0
-}
-
-func (m *ChainRegistration) GetEmitterAddress() []byte {
-	if m != nil {
-		return m.EmitterAddress
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*ChainRegistration)(nil), "certusone.wormholechain.tokenbridge.ChainRegistration")
-}
-
-func init() {
-	proto.RegisterFile("tokenbridge/chain_registration.proto", fileDescriptor_8f6eeeb0759bdcc8)
-}
-
-var fileDescriptor_8f6eeeb0759bdcc8 = []byte{
-	// 206 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x29, 0xc9, 0xcf, 0x4e,
-	0xcd, 0x4b, 0x2a, 0xca, 0x4c, 0x49, 0x4f, 0xd5, 0x4f, 0xce, 0x48, 0xcc, 0xcc, 0x8b, 0x2f, 0x4a,
-	0x4d, 0xcf, 0x2c, 0x2e, 0x29, 0x4a, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9,
-	0x17, 0x52, 0x4e, 0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce, 0xcf, 0x4b, 0xd5, 0x2b, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0x05, 0xab, 0xd5, 0x43, 0xd2, 0xad, 0x14, 0xca, 0x25, 0xe8, 0x0c, 0x12,
-	0x0c, 0x42, 0xd2, 0x2f, 0x24, 0xc1, 0xc5, 0x0e, 0x56, 0xe9, 0xe9, 0x22, 0xc1, 0xa8, 0xc0, 0xa8,
-	0xc1, 0x1b, 0x04, 0xe3, 0x0a, 0xa9, 0x71, 0xf1, 0xa5, 0xe6, 0x66, 0x96, 0x94, 0xa4, 0x16, 0x39,
-	0xa6, 0xa4, 0x14, 0xa5, 0x16, 0x17, 0x4b, 0x30, 0x29, 0x30, 0x6a, 0xf0, 0x04, 0xa1, 0x89, 0x3a,
-	0x05, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e,
-	0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x79, 0x7a, 0x66, 0x49,
-	0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0xdc, 0x81, 0xfa, 0x30, 0x07, 0xea, 0x82, 0x2d,
-	0xd2, 0xaf, 0xd0, 0x47, 0xf6, 0x61, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x57, 0xc6,
-	0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0x39, 0x2f, 0x69, 0xfd, 0x00, 0x00, 0x00,
-}
-
-func (m *ChainRegistration) 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 *ChainRegistration) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ChainRegistration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.EmitterAddress) > 0 {
-		i -= len(m.EmitterAddress)
-		copy(dAtA[i:], m.EmitterAddress)
-		i = encodeVarintChainRegistration(dAtA, i, uint64(len(m.EmitterAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.ChainID != 0 {
-		i = encodeVarintChainRegistration(dAtA, i, uint64(m.ChainID))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintChainRegistration(dAtA []byte, offset int, v uint64) int {
-	offset -= sovChainRegistration(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *ChainRegistration) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.ChainID != 0 {
-		n += 1 + sovChainRegistration(uint64(m.ChainID))
-	}
-	l = len(m.EmitterAddress)
-	if l > 0 {
-		n += 1 + l + sovChainRegistration(uint64(l))
-	}
-	return n
-}
-
-func sovChainRegistration(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozChainRegistration(x uint64) (n int) {
-	return sovChainRegistration(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *ChainRegistration) 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 ErrIntOverflowChainRegistration
-			}
-			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: ChainRegistration: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ChainRegistration: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
-			}
-			m.ChainID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowChainRegistration
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ChainID |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EmitterAddress", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowChainRegistration
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthChainRegistration
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthChainRegistration
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.EmitterAddress = append(m.EmitterAddress[:0], dAtA[iNdEx:postIndex]...)
-			if m.EmitterAddress == nil {
-				m.EmitterAddress = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipChainRegistration(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthChainRegistration
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipChainRegistration(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowChainRegistration
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowChainRegistration
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowChainRegistration
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthChainRegistration
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupChainRegistration
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthChainRegistration
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthChainRegistration        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowChainRegistration          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupChainRegistration = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/coin_meta_rollback_protection.pb.go

@@ -1,357 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/coin_meta_rollback_protection.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type CoinMetaRollbackProtection struct {
-	Index              string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-	LastUpdateSequence uint64 `protobuf:"varint,2,opt,name=lastUpdateSequence,proto3" json:"lastUpdateSequence,omitempty"`
-}
-
-func (m *CoinMetaRollbackProtection) Reset()         { *m = CoinMetaRollbackProtection{} }
-func (m *CoinMetaRollbackProtection) String() string { return proto.CompactTextString(m) }
-func (*CoinMetaRollbackProtection) ProtoMessage()    {}
-func (*CoinMetaRollbackProtection) Descriptor() ([]byte, []int) {
-	return fileDescriptor_23ec5ccab8f2b4ca, []int{0}
-}
-func (m *CoinMetaRollbackProtection) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CoinMetaRollbackProtection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CoinMetaRollbackProtection.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 *CoinMetaRollbackProtection) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CoinMetaRollbackProtection.Merge(m, src)
-}
-func (m *CoinMetaRollbackProtection) XXX_Size() int {
-	return m.Size()
-}
-func (m *CoinMetaRollbackProtection) XXX_DiscardUnknown() {
-	xxx_messageInfo_CoinMetaRollbackProtection.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CoinMetaRollbackProtection proto.InternalMessageInfo
-
-func (m *CoinMetaRollbackProtection) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-func (m *CoinMetaRollbackProtection) GetLastUpdateSequence() uint64 {
-	if m != nil {
-		return m.LastUpdateSequence
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*CoinMetaRollbackProtection)(nil), "certusone.wormholechain.tokenbridge.CoinMetaRollbackProtection")
-}
-
-func init() {
-	proto.RegisterFile("tokenbridge/coin_meta_rollback_protection.proto", fileDescriptor_23ec5ccab8f2b4ca)
-}
-
-var fileDescriptor_23ec5ccab8f2b4ca = []byte{
-	// 229 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x8f, 0xb1, 0x4a, 0xc4, 0x40,
-	0x10, 0x86, 0xb3, 0xa2, 0x82, 0x29, 0x17, 0x8b, 0xc3, 0x62, 0x39, 0xb4, 0xb9, 0xc6, 0xdd, 0xc2,
-	0xc2, 0x5e, 0x6b, 0x41, 0x23, 0x36, 0x36, 0x61, 0x77, 0x33, 0x5c, 0x96, 0xdb, 0xcc, 0xc4, 0xcd,
-	0x04, 0xcf, 0xb7, 0xf0, 0xb1, 0x2c, 0xaf, 0xb4, 0x94, 0xe4, 0x45, 0xc4, 0x53, 0x83, 0xc2, 0x75,
-	0x33, 0xfc, 0xf0, 0xf1, 0x7d, 0xb9, 0x61, 0x5a, 0x01, 0xba, 0x14, 0xaa, 0x25, 0x18, 0x4f, 0x01,
-	0xcb, 0x06, 0xd8, 0x96, 0x89, 0x62, 0x74, 0xd6, 0xaf, 0xca, 0x36, 0x11, 0x83, 0xe7, 0x40, 0xa8,
-	0xbf, 0x4e, 0x92, 0x67, 0x1e, 0x12, 0xf7, 0x1d, 0x21, 0xe8, 0x67, 0x4a, 0x4d, 0x4d, 0x11, 0x7c,
-	0x6d, 0x03, 0xea, 0x3f, 0xa0, 0x53, 0x97, 0x9f, 0x5c, 0x53, 0xc0, 0x1b, 0x60, 0x5b, 0xfc, 0x90,
-	0x6e, 0x27, 0x90, 0x3c, 0xce, 0x0f, 0x02, 0x56, 0xb0, 0x9e, 0x89, 0xb9, 0x58, 0x1c, 0x15, 0xdf,
-	0x8f, 0xd4, 0xb9, 0x8c, 0xb6, 0xe3, 0x87, 0xb6, 0xb2, 0x0c, 0xf7, 0xf0, 0xd4, 0x03, 0x7a, 0x98,
-	0xed, 0xcd, 0xc5, 0x62, 0xbf, 0xd8, 0xb1, 0x5c, 0xdd, 0xbd, 0x0d, 0x4a, 0x6c, 0x06, 0x25, 0x3e,
-	0x06, 0x25, 0x5e, 0x47, 0x95, 0x6d, 0x46, 0x95, 0xbd, 0x8f, 0x2a, 0x7b, 0xbc, 0x5c, 0x06, 0xae,
-	0x7b, 0xa7, 0x3d, 0x35, 0x66, 0xb2, 0x35, 0xbf, 0xb6, 0xe7, 0x5b, 0x5d, 0xb3, 0xfe, 0x57, 0xce,
-	0x2f, 0x2d, 0x74, 0xee, 0x70, 0x9b, 0x78, 0xf1, 0x19, 0x00, 0x00, 0xff, 0xff, 0x05, 0xde, 0xcf,
-	0xef, 0x15, 0x01, 0x00, 0x00,
-}
-
-func (m *CoinMetaRollbackProtection) 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 *CoinMetaRollbackProtection) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CoinMetaRollbackProtection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.LastUpdateSequence != 0 {
-		i = encodeVarintCoinMetaRollbackProtection(dAtA, i, uint64(m.LastUpdateSequence))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintCoinMetaRollbackProtection(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintCoinMetaRollbackProtection(dAtA []byte, offset int, v uint64) int {
-	offset -= sovCoinMetaRollbackProtection(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *CoinMetaRollbackProtection) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovCoinMetaRollbackProtection(uint64(l))
-	}
-	if m.LastUpdateSequence != 0 {
-		n += 1 + sovCoinMetaRollbackProtection(uint64(m.LastUpdateSequence))
-	}
-	return n
-}
-
-func sovCoinMetaRollbackProtection(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozCoinMetaRollbackProtection(x uint64) (n int) {
-	return sovCoinMetaRollbackProtection(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *CoinMetaRollbackProtection) 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 ErrIntOverflowCoinMetaRollbackProtection
-			}
-			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: CoinMetaRollbackProtection: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CoinMetaRollbackProtection: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCoinMetaRollbackProtection
-				}
-				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 ErrInvalidLengthCoinMetaRollbackProtection
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthCoinMetaRollbackProtection
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateSequence", wireType)
-			}
-			m.LastUpdateSequence = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCoinMetaRollbackProtection
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.LastUpdateSequence |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipCoinMetaRollbackProtection(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthCoinMetaRollbackProtection
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipCoinMetaRollbackProtection(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowCoinMetaRollbackProtection
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowCoinMetaRollbackProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowCoinMetaRollbackProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthCoinMetaRollbackProtection
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupCoinMetaRollbackProtection
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthCoinMetaRollbackProtection
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthCoinMetaRollbackProtection        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowCoinMetaRollbackProtection          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupCoinMetaRollbackProtection = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/config.pb.go

@@ -1,266 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/config.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type Config struct {
-}
-
-func (m *Config) Reset()         { *m = Config{} }
-func (m *Config) String() string { return proto.CompactTextString(m) }
-func (*Config) ProtoMessage()    {}
-func (*Config) Descriptor() ([]byte, []int) {
-	return fileDescriptor_b9e113abe6cc1887, []int{0}
-}
-func (m *Config) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Config.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 *Config) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Config.Merge(m, src)
-}
-func (m *Config) XXX_Size() int {
-	return m.Size()
-}
-func (m *Config) XXX_DiscardUnknown() {
-	xxx_messageInfo_Config.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Config proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*Config)(nil), "certusone.wormholechain.tokenbridge.Config")
-}
-
-func init() { proto.RegisterFile("tokenbridge/config.proto", fileDescriptor_b9e113abe6cc1887) }
-
-var fileDescriptor_b9e113abe6cc1887 = []byte{
-	// 162 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0xc9, 0xcf, 0x4e,
-	0xcd, 0x4b, 0x2a, 0xca, 0x4c, 0x49, 0x4f, 0xd5, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b,
-	0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x4e, 0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce, 0xcf, 0x4b, 0xd5,
-	0x2b, 0xcf, 0x2f, 0xca, 0xcd, 0xc8, 0xcf, 0x49, 0x4d, 0xce, 0x48, 0xcc, 0xcc, 0xd3, 0x43, 0xd2,
-	0x21, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xaf, 0x0f, 0x62, 0x41, 0xb4, 0x2a, 0x71, 0x70,
-	0xb1, 0x39, 0x83, 0x8d, 0x72, 0x0a, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07,
-	0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86,
-	0x28, 0xf3, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0xb8, 0x4d, 0xfa,
-	0x30, 0x9b, 0x74, 0xc1, 0x56, 0xe9, 0x57, 0xe8, 0x23, 0x3b, 0xaf, 0xa4, 0xb2, 0x20, 0xb5, 0x38,
-	0x89, 0x0d, 0x6c, 0x87, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x38, 0xe1, 0x04, 0x22, 0xba, 0x00,
-	0x00, 0x00,
-}
-
-func (m *Config) 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 *Config) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
-	offset -= sovConfig(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *Config) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func sovConfig(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozConfig(x uint64) (n int) {
-	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *Config) 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 ErrIntOverflowConfig
-			}
-			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: Config: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipConfig(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthConfig
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipConfig(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowConfig
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthConfig
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupConfig
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthConfig
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthConfig        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowConfig          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/events.pb.go

@@ -1,1172 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/events.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type EventChainRegistered struct {
-	ChainID        uint32 `protobuf:"varint,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
-	EmitterAddress []byte `protobuf:"bytes,2,opt,name=emitterAddress,proto3" json:"emitterAddress,omitempty"`
-}
-
-func (m *EventChainRegistered) Reset()         { *m = EventChainRegistered{} }
-func (m *EventChainRegistered) String() string { return proto.CompactTextString(m) }
-func (*EventChainRegistered) ProtoMessage()    {}
-func (*EventChainRegistered) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2327fbee5f2854e8, []int{0}
-}
-func (m *EventChainRegistered) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventChainRegistered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventChainRegistered.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 *EventChainRegistered) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventChainRegistered.Merge(m, src)
-}
-func (m *EventChainRegistered) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventChainRegistered) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventChainRegistered.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventChainRegistered proto.InternalMessageInfo
-
-func (m *EventChainRegistered) GetChainID() uint32 {
-	if m != nil {
-		return m.ChainID
-	}
-	return 0
-}
-
-func (m *EventChainRegistered) GetEmitterAddress() []byte {
-	if m != nil {
-		return m.EmitterAddress
-	}
-	return nil
-}
-
-type EventAssetRegistrationUpdate struct {
-	TokenChain   uint32 `protobuf:"varint,1,opt,name=tokenChain,proto3" json:"tokenChain,omitempty"`
-	TokenAddress []byte `protobuf:"bytes,2,opt,name=tokenAddress,proto3" json:"tokenAddress,omitempty"`
-	Name         string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
-	Symbol       string `protobuf:"bytes,4,opt,name=symbol,proto3" json:"symbol,omitempty"`
-	Decimals     uint32 `protobuf:"varint,5,opt,name=decimals,proto3" json:"decimals,omitempty"`
-}
-
-func (m *EventAssetRegistrationUpdate) Reset()         { *m = EventAssetRegistrationUpdate{} }
-func (m *EventAssetRegistrationUpdate) String() string { return proto.CompactTextString(m) }
-func (*EventAssetRegistrationUpdate) ProtoMessage()    {}
-func (*EventAssetRegistrationUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2327fbee5f2854e8, []int{1}
-}
-func (m *EventAssetRegistrationUpdate) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventAssetRegistrationUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventAssetRegistrationUpdate.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 *EventAssetRegistrationUpdate) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventAssetRegistrationUpdate.Merge(m, src)
-}
-func (m *EventAssetRegistrationUpdate) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventAssetRegistrationUpdate) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventAssetRegistrationUpdate.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventAssetRegistrationUpdate proto.InternalMessageInfo
-
-func (m *EventAssetRegistrationUpdate) GetTokenChain() uint32 {
-	if m != nil {
-		return m.TokenChain
-	}
-	return 0
-}
-
-func (m *EventAssetRegistrationUpdate) GetTokenAddress() []byte {
-	if m != nil {
-		return m.TokenAddress
-	}
-	return nil
-}
-
-func (m *EventAssetRegistrationUpdate) GetName() string {
-	if m != nil {
-		return m.Name
-	}
-	return ""
-}
-
-func (m *EventAssetRegistrationUpdate) GetSymbol() string {
-	if m != nil {
-		return m.Symbol
-	}
-	return ""
-}
-
-func (m *EventAssetRegistrationUpdate) GetDecimals() uint32 {
-	if m != nil {
-		return m.Decimals
-	}
-	return 0
-}
-
-type EventTransferReceived struct {
-	TokenChain   uint32 `protobuf:"varint,1,opt,name=tokenChain,proto3" json:"tokenChain,omitempty"`
-	TokenAddress []byte `protobuf:"bytes,2,opt,name=tokenAddress,proto3" json:"tokenAddress,omitempty"`
-	To           string `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
-	FeeRecipient string `protobuf:"bytes,4,opt,name=feeRecipient,proto3" json:"feeRecipient,omitempty"`
-	Amount       string `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount,omitempty"`
-	Fee          string `protobuf:"bytes,6,opt,name=fee,proto3" json:"fee,omitempty"`
-	LocalDenom   string `protobuf:"bytes,7,opt,name=localDenom,proto3" json:"localDenom,omitempty"`
-}
-
-func (m *EventTransferReceived) Reset()         { *m = EventTransferReceived{} }
-func (m *EventTransferReceived) String() string { return proto.CompactTextString(m) }
-func (*EventTransferReceived) ProtoMessage()    {}
-func (*EventTransferReceived) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2327fbee5f2854e8, []int{2}
-}
-func (m *EventTransferReceived) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventTransferReceived) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventTransferReceived.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 *EventTransferReceived) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventTransferReceived.Merge(m, src)
-}
-func (m *EventTransferReceived) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventTransferReceived) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventTransferReceived.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventTransferReceived proto.InternalMessageInfo
-
-func (m *EventTransferReceived) GetTokenChain() uint32 {
-	if m != nil {
-		return m.TokenChain
-	}
-	return 0
-}
-
-func (m *EventTransferReceived) GetTokenAddress() []byte {
-	if m != nil {
-		return m.TokenAddress
-	}
-	return nil
-}
-
-func (m *EventTransferReceived) GetTo() string {
-	if m != nil {
-		return m.To
-	}
-	return ""
-}
-
-func (m *EventTransferReceived) GetFeeRecipient() string {
-	if m != nil {
-		return m.FeeRecipient
-	}
-	return ""
-}
-
-func (m *EventTransferReceived) GetAmount() string {
-	if m != nil {
-		return m.Amount
-	}
-	return ""
-}
-
-func (m *EventTransferReceived) GetFee() string {
-	if m != nil {
-		return m.Fee
-	}
-	return ""
-}
-
-func (m *EventTransferReceived) GetLocalDenom() string {
-	if m != nil {
-		return m.LocalDenom
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*EventChainRegistered)(nil), "certusone.wormholechain.tokenbridge.EventChainRegistered")
-	proto.RegisterType((*EventAssetRegistrationUpdate)(nil), "certusone.wormholechain.tokenbridge.EventAssetRegistrationUpdate")
-	proto.RegisterType((*EventTransferReceived)(nil), "certusone.wormholechain.tokenbridge.EventTransferReceived")
-}
-
-func init() { proto.RegisterFile("tokenbridge/events.proto", fileDescriptor_2327fbee5f2854e8) }
-
-var fileDescriptor_2327fbee5f2854e8 = []byte{
-	// 380 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0x41, 0x6f, 0xda, 0x30,
-	0x18, 0x86, 0x31, 0x30, 0x18, 0x16, 0x43, 0x93, 0xb5, 0x4d, 0xd6, 0x34, 0x45, 0x28, 0x93, 0x26,
-	0x2e, 0x4b, 0x0e, 0x3b, 0xec, 0xcc, 0xc6, 0x0e, 0x3b, 0x2e, 0x5a, 0xa5, 0xaa, 0x37, 0x27, 0xf9,
-	0x00, 0xab, 0xb1, 0x1d, 0xd9, 0x1f, 0xb4, 0xfc, 0x8b, 0xfe, 0x8e, 0xfe, 0x92, 0x1e, 0x39, 0xb6,
-	0xb7, 0x0a, 0xfe, 0x48, 0x15, 0x37, 0xa0, 0xd0, 0x73, 0x6f, 0x7e, 0x5f, 0xe7, 0xfb, 0xde, 0x27,
-	0xf2, 0x4b, 0x39, 0x9a, 0x4b, 0xd0, 0xa9, 0x95, 0xf9, 0x02, 0x62, 0x58, 0x83, 0x46, 0x17, 0x95,
-	0xd6, 0xa0, 0x61, 0x5f, 0x33, 0xb0, 0xb8, 0x72, 0x46, 0x43, 0x74, 0x65, 0xac, 0x5a, 0x9a, 0x02,
-	0xb2, 0xa5, 0x90, 0x3a, 0x6a, 0x4c, 0x84, 0xe7, 0xf4, 0xc3, 0x9f, 0x6a, 0xe8, 0x77, 0x75, 0x93,
-	0xc0, 0x42, 0x3a, 0x04, 0x0b, 0x39, 0xe3, 0xb4, 0xef, 0x3f, 0xfe, 0x3b, 0xe3, 0x64, 0x4c, 0x26,
-	0xef, 0x92, 0x83, 0x64, 0xdf, 0xe8, 0x08, 0x94, 0x44, 0x04, 0x3b, 0xcd, 0x73, 0x0b, 0xce, 0xf1,
-	0xf6, 0x98, 0x4c, 0x86, 0xc9, 0x0b, 0x37, 0xbc, 0x25, 0xf4, 0x8b, 0x5f, 0x3d, 0x75, 0x0e, 0xf0,
-	0x79, 0xb5, 0x15, 0x28, 0x8d, 0x3e, 0x2b, 0x73, 0x81, 0xc0, 0x02, 0x4a, 0x3d, 0x89, 0x8f, 0xae,
-	0x53, 0x1a, 0x0e, 0x0b, 0xe9, 0xd0, 0xab, 0xd3, 0x98, 0x13, 0x8f, 0x31, 0xda, 0xd5, 0x42, 0x01,
-	0xef, 0x8c, 0xc9, 0x64, 0x90, 0xf8, 0x33, 0xfb, 0x44, 0x7b, 0x6e, 0xa3, 0x52, 0x53, 0xf0, 0xae,
-	0x77, 0x6b, 0xc5, 0x3e, 0xd3, 0xb7, 0x39, 0x64, 0x52, 0x89, 0xc2, 0xf1, 0x37, 0x3e, 0xed, 0xa8,
-	0xc3, 0x07, 0x42, 0x3f, 0x7a, 0xd8, 0xff, 0x56, 0x68, 0x37, 0x07, 0x9b, 0x40, 0x06, 0x72, 0x0d,
-	0xf9, 0xab, 0x50, 0x8e, 0x68, 0x1b, 0x4d, 0xcd, 0xd8, 0x46, 0x53, 0xcd, 0xcc, 0x01, 0x12, 0xc8,
-	0x64, 0x29, 0x41, 0x63, 0xcd, 0x79, 0xe2, 0x55, 0x7f, 0x21, 0x94, 0x59, 0x69, 0xf4, 0xac, 0x83,
-	0xa4, 0x56, 0xec, 0x3d, 0xed, 0xcc, 0x01, 0x78, 0xcf, 0x9b, 0xd5, 0xb1, 0x22, 0x2c, 0x4c, 0x26,
-	0x8a, 0x19, 0x68, 0xa3, 0x78, 0xdf, 0x5f, 0x34, 0x9c, 0x5f, 0xff, 0xee, 0x76, 0x01, 0xd9, 0xee,
-	0x02, 0xf2, 0xb8, 0x0b, 0xc8, 0xcd, 0x3e, 0x68, 0x6d, 0xf7, 0x41, 0xeb, 0x7e, 0x1f, 0xb4, 0x2e,
-	0x7e, 0x2e, 0x24, 0x2e, 0x57, 0x69, 0x94, 0x19, 0x15, 0x1f, 0xcb, 0x12, 0x1f, 0xca, 0xf2, 0xdd,
-	0xbf, 0x78, 0x7c, 0x1d, 0x37, 0x1b, 0x86, 0x9b, 0x12, 0x5c, 0xda, 0xf3, 0x0d, 0xfb, 0xf1, 0x14,
-	0x00, 0x00, 0xff, 0xff, 0xfe, 0xe7, 0xc2, 0xae, 0x7d, 0x02, 0x00, 0x00,
-}
-
-func (m *EventChainRegistered) 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 *EventChainRegistered) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventChainRegistered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.EmitterAddress) > 0 {
-		i -= len(m.EmitterAddress)
-		copy(dAtA[i:], m.EmitterAddress)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.EmitterAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.ChainID != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.ChainID))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventAssetRegistrationUpdate) 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 *EventAssetRegistrationUpdate) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventAssetRegistrationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Decimals != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.Decimals))
-		i--
-		dAtA[i] = 0x28
-	}
-	if len(m.Symbol) > 0 {
-		i -= len(m.Symbol)
-		copy(dAtA[i:], m.Symbol)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Symbol)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.TokenAddress) > 0 {
-		i -= len(m.TokenAddress)
-		copy(dAtA[i:], m.TokenAddress)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.TokenAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.TokenChain != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.TokenChain))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventTransferReceived) 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 *EventTransferReceived) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventTransferReceived) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.LocalDenom) > 0 {
-		i -= len(m.LocalDenom)
-		copy(dAtA[i:], m.LocalDenom)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.LocalDenom)))
-		i--
-		dAtA[i] = 0x3a
-	}
-	if len(m.Fee) > 0 {
-		i -= len(m.Fee)
-		copy(dAtA[i:], m.Fee)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Fee)))
-		i--
-		dAtA[i] = 0x32
-	}
-	if len(m.Amount) > 0 {
-		i -= len(m.Amount)
-		copy(dAtA[i:], m.Amount)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Amount)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if len(m.FeeRecipient) > 0 {
-		i -= len(m.FeeRecipient)
-		copy(dAtA[i:], m.FeeRecipient)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.FeeRecipient)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.To) > 0 {
-		i -= len(m.To)
-		copy(dAtA[i:], m.To)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.To)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.TokenAddress) > 0 {
-		i -= len(m.TokenAddress)
-		copy(dAtA[i:], m.TokenAddress)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.TokenAddress)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.TokenChain != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.TokenChain))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
-	offset -= sovEvents(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *EventChainRegistered) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.ChainID != 0 {
-		n += 1 + sovEvents(uint64(m.ChainID))
-	}
-	l = len(m.EmitterAddress)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func (m *EventAssetRegistrationUpdate) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.TokenChain != 0 {
-		n += 1 + sovEvents(uint64(m.TokenChain))
-	}
-	l = len(m.TokenAddress)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.Name)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.Symbol)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	if m.Decimals != 0 {
-		n += 1 + sovEvents(uint64(m.Decimals))
-	}
-	return n
-}
-
-func (m *EventTransferReceived) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.TokenChain != 0 {
-		n += 1 + sovEvents(uint64(m.TokenChain))
-	}
-	l = len(m.TokenAddress)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.To)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.FeeRecipient)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.Amount)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.Fee)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.LocalDenom)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func sovEvents(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozEvents(x uint64) (n int) {
-	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *EventChainRegistered) 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 ErrIntOverflowEvents
-			}
-			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: EventChainRegistered: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventChainRegistered: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
-			}
-			m.ChainID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ChainID |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EmitterAddress", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.EmitterAddress = append(m.EmitterAddress[:0], dAtA[iNdEx:postIndex]...)
-			if m.EmitterAddress == nil {
-				m.EmitterAddress = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventAssetRegistrationUpdate) 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 ErrIntOverflowEvents
-			}
-			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: EventAssetRegistrationUpdate: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventAssetRegistrationUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenChain", wireType)
-			}
-			m.TokenChain = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.TokenChain |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenAddress", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.TokenAddress = append(m.TokenAddress[:0], dAtA[iNdEx:postIndex]...)
-			if m.TokenAddress == nil {
-				m.TokenAddress = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Name = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Symbol = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
-			}
-			m.Decimals = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Decimals |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventTransferReceived) 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 ErrIntOverflowEvents
-			}
-			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: EventTransferReceived: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventTransferReceived: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenChain", wireType)
-			}
-			m.TokenChain = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.TokenChain |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenAddress", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.TokenAddress = append(m.TokenAddress[:0], dAtA[iNdEx:postIndex]...)
-			if m.TokenAddress == nil {
-				m.TokenAddress = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.To = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FeeRecipient", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.FeeRecipient = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Amount = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Fee = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LocalDenom", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				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 ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.LocalDenom = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipEvents(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowEvents
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthEvents
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupEvents
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthEvents
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/expected_keepers.go

@@ -25,6 +25,7 @@ type BankKeeper interface {
 type WormholeKeeper interface {
 	// Methods imported from wormhole should be defined here
 	VerifyVAA(ctx sdk.Context, vaa *vaa.VAA) error
+	VerifyGovernanceVAA(ctx sdk.Context, v *vaa.VAA, module [32]byte) (action byte, payload []byte, err error)
 	GetConfig(ctx sdk.Context) (val types.Config, found bool)
 	PostMessage(ctx sdk.Context, emitter types.EmitterAddress, nonce uint32, data []byte) error
 }

wormhole_chain/x/tokenbridge/types/genesis.pb.go

@@ -1,524 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/genesis.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-// GenesisState defines the tokenbridge module's genesis state.
-type GenesisState struct {
-	Config                         *Config                      `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
-	ReplayProtectionList           []ReplayProtection           `protobuf:"bytes,2,rep,name=replayProtectionList,proto3" json:"replayProtectionList"`
-	ChainRegistrationList          []ChainRegistration          `protobuf:"bytes,3,rep,name=chainRegistrationList,proto3" json:"chainRegistrationList"`
-	CoinMetaRollbackProtectionList []CoinMetaRollbackProtection `protobuf:"bytes,4,rep,name=coinMetaRollbackProtectionList,proto3" json:"coinMetaRollbackProtectionList"`
-}
-
-func (m *GenesisState) Reset()         { *m = GenesisState{} }
-func (m *GenesisState) String() string { return proto.CompactTextString(m) }
-func (*GenesisState) ProtoMessage()    {}
-func (*GenesisState) Descriptor() ([]byte, []int) {
-	return fileDescriptor_7868cbe02d959350, []int{0}
-}
-func (m *GenesisState) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GenesisState.Merge(m, src)
-}
-func (m *GenesisState) XXX_Size() int {
-	return m.Size()
-}
-func (m *GenesisState) XXX_DiscardUnknown() {
-	xxx_messageInfo_GenesisState.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenesisState proto.InternalMessageInfo
-
-func (m *GenesisState) GetConfig() *Config {
-	if m != nil {
-		return m.Config
-	}
-	return nil
-}
-
-func (m *GenesisState) GetReplayProtectionList() []ReplayProtection {
-	if m != nil {
-		return m.ReplayProtectionList
-	}
-	return nil
-}
-
-func (m *GenesisState) GetChainRegistrationList() []ChainRegistration {
-	if m != nil {
-		return m.ChainRegistrationList
-	}
-	return nil
-}
-
-func (m *GenesisState) GetCoinMetaRollbackProtectionList() []CoinMetaRollbackProtection {
-	if m != nil {
-		return m.CoinMetaRollbackProtectionList
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*GenesisState)(nil), "certusone.wormholechain.tokenbridge.GenesisState")
-}
-
-func init() { proto.RegisterFile("tokenbridge/genesis.proto", fileDescriptor_7868cbe02d959350) }
-
-var fileDescriptor_7868cbe02d959350 = []byte{
-	// 352 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x4a, 0xf3, 0x40,
-	0x14, 0x85, 0x93, 0xbf, 0xa5, 0x8b, 0xf4, 0x5f, 0x85, 0x0a, 0xb5, 0x8b, 0xb1, 0x58, 0x17, 0x05,
-	0x31, 0x81, 0x8a, 0xba, 0x14, 0xda, 0x85, 0x1b, 0x05, 0x8d, 0x3b, 0x37, 0x61, 0x12, 0xaf, 0xd3,
-	0xa1, 0xe9, 0xdc, 0x32, 0x33, 0x45, 0xfb, 0x10, 0x82, 0x8f, 0xd5, 0x65, 0x97, 0xae, 0x44, 0xda,
-	0x17, 0x91, 0x4c, 0x62, 0x49, 0x6b, 0xc5, 0xec, 0x86, 0x99, 0x39, 0xdf, 0x39, 0xe7, 0x72, 0x9d,
-	0x7d, 0x8d, 0x23, 0x10, 0x91, 0xe4, 0x8f, 0x0c, 0x7c, 0x06, 0x02, 0x14, 0x57, 0xde, 0x44, 0xa2,
-	0x46, 0xb7, 0x13, 0x83, 0xd4, 0x53, 0x85, 0x02, 0xbc, 0x67, 0x94, 0xe3, 0x21, 0x26, 0x10, 0x0f,
-	0x29, 0x17, 0x5e, 0x41, 0xd2, 0x6a, 0x16, 0xf5, 0x31, 0x8a, 0x27, 0xce, 0x32, 0x79, 0xab, 0x53,
-	0x7c, 0x91, 0x30, 0x49, 0xe8, 0x2c, 0x4c, 0x5f, 0x20, 0xd6, 0x1c, 0x45, 0xfe, 0xe9, 0x68, 0x43,
-	0x9e, 0xd2, 0x43, 0x09, 0x8c, 0x2b, 0x2d, 0x69, 0xe1, 0x97, 0xbf, 0x69, 0xc2, 0x45, 0x38, 0x06,
-	0x4d, 0x43, 0x89, 0x49, 0x12, 0xd1, 0x78, 0xf4, 0x13, 0xdb, 0x60, 0xc8, 0xd0, 0x1c, 0xfd, 0xf4,
-	0x94, 0xdd, 0x1e, 0xce, 0x2b, 0xce, 0xff, 0xab, 0xac, 0xe2, 0xbd, 0xa6, 0x1a, 0xdc, 0x81, 0x53,
-	0xcb, 0x22, 0x37, 0xed, 0xb6, 0xdd, 0xad, 0xf7, 0x8e, 0xbd, 0x12, 0x95, 0xbd, 0x81, 0x91, 0x04,
-	0xb9, 0xd4, 0x45, 0xa7, 0x91, 0xb5, 0xbb, 0x5d, 0xa7, 0xb8, 0xe6, 0x4a, 0x37, 0xff, 0xb5, 0x2b,
-	0xdd, 0x7a, 0xef, 0xac, 0x14, 0x32, 0xd8, 0x02, 0xf4, 0xab, 0xf3, 0x8f, 0x03, 0x2b, 0xd8, 0x09,
-	0x76, 0xa5, 0xb3, 0x67, 0x08, 0x41, 0x61, 0x50, 0xc6, 0xb1, 0x62, 0x1c, 0xcf, 0xcb, 0x95, 0xd8,
-	0x26, 0xe4, 0x96, 0xbb, 0xd1, 0xee, 0xab, 0xed, 0x90, 0x74, 0xf0, 0x37, 0xa0, 0x69, 0x90, 0x8f,
-	0x7d, 0xab, 0x6f, 0xd5, 0xb8, 0x5f, 0x96, 0x1c, 0xe1, 0x6f, 0xa8, 0x3c, 0xc6, 0x1f, 0x66, 0xfd,
-	0xbb, 0xf9, 0x92, 0xd8, 0x8b, 0x25, 0xb1, 0x3f, 0x97, 0xc4, 0x7e, 0x5b, 0x11, 0x6b, 0xb1, 0x22,
-	0xd6, 0xfb, 0x8a, 0x58, 0x0f, 0x17, 0x8c, 0xeb, 0xe1, 0x34, 0xf2, 0x62, 0x1c, 0xfb, 0xeb, 0x28,
-	0xfe, 0x77, 0x94, 0x13, 0x93, 0xc5, 0x7f, 0xd9, 0xd8, 0x28, 0x3d, 0x9b, 0x80, 0x8a, 0x6a, 0x66,
-	0x49, 0x4e, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd5, 0x3e, 0xd3, 0x7d, 0x12, 0x03, 0x00, 0x00,
-}
-
-func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.CoinMetaRollbackProtectionList) > 0 {
-		for iNdEx := len(m.CoinMetaRollbackProtectionList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.CoinMetaRollbackProtectionList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
-	}
-	if len(m.ChainRegistrationList) > 0 {
-		for iNdEx := len(m.ChainRegistrationList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ChainRegistrationList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	if len(m.ReplayProtectionList) > 0 {
-		for iNdEx := len(m.ReplayProtectionList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ReplayProtectionList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
-		}
-	}
-	if m.Config != nil {
-		{
-			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenesis(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGenesis(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GenesisState) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Config != nil {
-		l = m.Config.Size()
-		n += 1 + l + sovGenesis(uint64(l))
-	}
-	if len(m.ReplayProtectionList) > 0 {
-		for _, e := range m.ReplayProtectionList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.ChainRegistrationList) > 0 {
-		for _, e := range m.ChainRegistrationList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.CoinMetaRollbackProtectionList) > 0 {
-		for _, e := range m.CoinMetaRollbackProtectionList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	return n
-}
-
-func sovGenesis(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGenesis(x uint64) (n int) {
-	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GenesisState) 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 ErrIntOverflowGenesis
-			}
-			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: GenesisState: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Config", 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
-			}
-			if m.Config == nil {
-				m.Config = &Config{}
-			}
-			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtectionList", 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.ReplayProtectionList = append(m.ReplayProtectionList, ReplayProtection{})
-			if err := m.ReplayProtectionList[len(m.ReplayProtectionList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainRegistrationList", 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.ChainRegistrationList = append(m.ChainRegistrationList, ChainRegistration{})
-			if err := m.ChainRegistrationList[len(m.ChainRegistrationList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CoinMetaRollbackProtectionList", 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.CoinMetaRollbackProtectionList = append(m.CoinMetaRollbackProtectionList, CoinMetaRollbackProtection{})
-			if err := m.CoinMetaRollbackProtectionList[len(m.CoinMetaRollbackProtectionList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenesis(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGenesis(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGenesis
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGenesis
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGenesis
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGenesis
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/query.pb.go

@@ -1,3083 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/query.proto
-
-package types
-
-import (
-	context "context"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	query "github.com/cosmos/cosmos-sdk/types/query"
-	_ "github.com/gogo/protobuf/gogoproto"
-	grpc1 "github.com/gogo/protobuf/grpc"
-	proto "github.com/gogo/protobuf/proto"
-	_ "google.golang.org/genproto/googleapis/api/annotations"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type QueryGetConfigRequest struct {
-}
-
-func (m *QueryGetConfigRequest) Reset()         { *m = QueryGetConfigRequest{} }
-func (m *QueryGetConfigRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetConfigRequest) ProtoMessage()    {}
-func (*QueryGetConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{0}
-}
-func (m *QueryGetConfigRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConfigRequest.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 *QueryGetConfigRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConfigRequest.Merge(m, src)
-}
-func (m *QueryGetConfigRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConfigRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConfigRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConfigRequest proto.InternalMessageInfo
-
-type QueryGetConfigResponse struct {
-	Config Config `protobuf:"bytes,1,opt,name=Config,proto3" json:"Config"`
-}
-
-func (m *QueryGetConfigResponse) Reset()         { *m = QueryGetConfigResponse{} }
-func (m *QueryGetConfigResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetConfigResponse) ProtoMessage()    {}
-func (*QueryGetConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{1}
-}
-func (m *QueryGetConfigResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConfigResponse.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 *QueryGetConfigResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConfigResponse.Merge(m, src)
-}
-func (m *QueryGetConfigResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConfigResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConfigResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConfigResponse proto.InternalMessageInfo
-
-func (m *QueryGetConfigResponse) GetConfig() Config {
-	if m != nil {
-		return m.Config
-	}
-	return Config{}
-}
-
-type QueryGetReplayProtectionRequest struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *QueryGetReplayProtectionRequest) Reset()         { *m = QueryGetReplayProtectionRequest{} }
-func (m *QueryGetReplayProtectionRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetReplayProtectionRequest) ProtoMessage()    {}
-func (*QueryGetReplayProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{2}
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetReplayProtectionRequest.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 *QueryGetReplayProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetReplayProtectionRequest.Merge(m, src)
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetReplayProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetReplayProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetReplayProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryGetReplayProtectionRequest) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-type QueryGetReplayProtectionResponse struct {
-	ReplayProtection ReplayProtection `protobuf:"bytes,1,opt,name=replayProtection,proto3" json:"replayProtection"`
-}
-
-func (m *QueryGetReplayProtectionResponse) Reset()         { *m = QueryGetReplayProtectionResponse{} }
-func (m *QueryGetReplayProtectionResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetReplayProtectionResponse) ProtoMessage()    {}
-func (*QueryGetReplayProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{3}
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetReplayProtectionResponse.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 *QueryGetReplayProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetReplayProtectionResponse.Merge(m, src)
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetReplayProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetReplayProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetReplayProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryGetReplayProtectionResponse) GetReplayProtection() ReplayProtection {
-	if m != nil {
-		return m.ReplayProtection
-	}
-	return ReplayProtection{}
-}
-
-type QueryAllReplayProtectionRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllReplayProtectionRequest) Reset()         { *m = QueryAllReplayProtectionRequest{} }
-func (m *QueryAllReplayProtectionRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllReplayProtectionRequest) ProtoMessage()    {}
-func (*QueryAllReplayProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{4}
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllReplayProtectionRequest.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 *QueryAllReplayProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllReplayProtectionRequest.Merge(m, src)
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllReplayProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllReplayProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllReplayProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryAllReplayProtectionRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllReplayProtectionResponse struct {
-	ReplayProtection []ReplayProtection  `protobuf:"bytes,1,rep,name=replayProtection,proto3" json:"replayProtection"`
-	Pagination       *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllReplayProtectionResponse) Reset()         { *m = QueryAllReplayProtectionResponse{} }
-func (m *QueryAllReplayProtectionResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllReplayProtectionResponse) ProtoMessage()    {}
-func (*QueryAllReplayProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{5}
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllReplayProtectionResponse.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 *QueryAllReplayProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllReplayProtectionResponse.Merge(m, src)
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllReplayProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllReplayProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllReplayProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryAllReplayProtectionResponse) GetReplayProtection() []ReplayProtection {
-	if m != nil {
-		return m.ReplayProtection
-	}
-	return nil
-}
-
-func (m *QueryAllReplayProtectionResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryGetChainRegistrationRequest struct {
-	ChainID uint32 `protobuf:"varint,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
-}
-
-func (m *QueryGetChainRegistrationRequest) Reset()         { *m = QueryGetChainRegistrationRequest{} }
-func (m *QueryGetChainRegistrationRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetChainRegistrationRequest) ProtoMessage()    {}
-func (*QueryGetChainRegistrationRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{6}
-}
-func (m *QueryGetChainRegistrationRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetChainRegistrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetChainRegistrationRequest.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 *QueryGetChainRegistrationRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetChainRegistrationRequest.Merge(m, src)
-}
-func (m *QueryGetChainRegistrationRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetChainRegistrationRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetChainRegistrationRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetChainRegistrationRequest proto.InternalMessageInfo
-
-func (m *QueryGetChainRegistrationRequest) GetChainID() uint32 {
-	if m != nil {
-		return m.ChainID
-	}
-	return 0
-}
-
-type QueryGetChainRegistrationResponse struct {
-	ChainRegistration ChainRegistration `protobuf:"bytes,1,opt,name=chainRegistration,proto3" json:"chainRegistration"`
-}
-
-func (m *QueryGetChainRegistrationResponse) Reset()         { *m = QueryGetChainRegistrationResponse{} }
-func (m *QueryGetChainRegistrationResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetChainRegistrationResponse) ProtoMessage()    {}
-func (*QueryGetChainRegistrationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{7}
-}
-func (m *QueryGetChainRegistrationResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetChainRegistrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetChainRegistrationResponse.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 *QueryGetChainRegistrationResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetChainRegistrationResponse.Merge(m, src)
-}
-func (m *QueryGetChainRegistrationResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetChainRegistrationResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetChainRegistrationResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetChainRegistrationResponse proto.InternalMessageInfo
-
-func (m *QueryGetChainRegistrationResponse) GetChainRegistration() ChainRegistration {
-	if m != nil {
-		return m.ChainRegistration
-	}
-	return ChainRegistration{}
-}
-
-type QueryAllChainRegistrationRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllChainRegistrationRequest) Reset()         { *m = QueryAllChainRegistrationRequest{} }
-func (m *QueryAllChainRegistrationRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllChainRegistrationRequest) ProtoMessage()    {}
-func (*QueryAllChainRegistrationRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{8}
-}
-func (m *QueryAllChainRegistrationRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllChainRegistrationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllChainRegistrationRequest.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 *QueryAllChainRegistrationRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllChainRegistrationRequest.Merge(m, src)
-}
-func (m *QueryAllChainRegistrationRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllChainRegistrationRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllChainRegistrationRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllChainRegistrationRequest proto.InternalMessageInfo
-
-func (m *QueryAllChainRegistrationRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllChainRegistrationResponse struct {
-	ChainRegistration []ChainRegistration `protobuf:"bytes,1,rep,name=chainRegistration,proto3" json:"chainRegistration"`
-	Pagination        *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllChainRegistrationResponse) Reset()         { *m = QueryAllChainRegistrationResponse{} }
-func (m *QueryAllChainRegistrationResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllChainRegistrationResponse) ProtoMessage()    {}
-func (*QueryAllChainRegistrationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{9}
-}
-func (m *QueryAllChainRegistrationResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllChainRegistrationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllChainRegistrationResponse.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 *QueryAllChainRegistrationResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllChainRegistrationResponse.Merge(m, src)
-}
-func (m *QueryAllChainRegistrationResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllChainRegistrationResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllChainRegistrationResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllChainRegistrationResponse proto.InternalMessageInfo
-
-func (m *QueryAllChainRegistrationResponse) GetChainRegistration() []ChainRegistration {
-	if m != nil {
-		return m.ChainRegistration
-	}
-	return nil
-}
-
-func (m *QueryAllChainRegistrationResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryGetCoinMetaRollbackProtectionRequest struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionRequest) Reset() {
-	*m = QueryGetCoinMetaRollbackProtectionRequest{}
-}
-func (m *QueryGetCoinMetaRollbackProtectionRequest) String() string {
-	return proto.CompactTextString(m)
-}
-func (*QueryGetCoinMetaRollbackProtectionRequest) ProtoMessage() {}
-func (*QueryGetCoinMetaRollbackProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{10}
-}
-func (m *QueryGetCoinMetaRollbackProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetCoinMetaRollbackProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetCoinMetaRollbackProtectionRequest.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 *QueryGetCoinMetaRollbackProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetCoinMetaRollbackProtectionRequest.Merge(m, src)
-}
-func (m *QueryGetCoinMetaRollbackProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetCoinMetaRollbackProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetCoinMetaRollbackProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetCoinMetaRollbackProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryGetCoinMetaRollbackProtectionRequest) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-type QueryGetCoinMetaRollbackProtectionResponse struct {
-	CoinMetaRollbackProtection CoinMetaRollbackProtection `protobuf:"bytes,1,opt,name=coinMetaRollbackProtection,proto3" json:"coinMetaRollbackProtection"`
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionResponse) Reset() {
-	*m = QueryGetCoinMetaRollbackProtectionResponse{}
-}
-func (m *QueryGetCoinMetaRollbackProtectionResponse) String() string {
-	return proto.CompactTextString(m)
-}
-func (*QueryGetCoinMetaRollbackProtectionResponse) ProtoMessage() {}
-func (*QueryGetCoinMetaRollbackProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{11}
-}
-func (m *QueryGetCoinMetaRollbackProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetCoinMetaRollbackProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetCoinMetaRollbackProtectionResponse.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 *QueryGetCoinMetaRollbackProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetCoinMetaRollbackProtectionResponse.Merge(m, src)
-}
-func (m *QueryGetCoinMetaRollbackProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetCoinMetaRollbackProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetCoinMetaRollbackProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetCoinMetaRollbackProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryGetCoinMetaRollbackProtectionResponse) GetCoinMetaRollbackProtection() CoinMetaRollbackProtection {
-	if m != nil {
-		return m.CoinMetaRollbackProtection
-	}
-	return CoinMetaRollbackProtection{}
-}
-
-type QueryAllCoinMetaRollbackProtectionRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionRequest) Reset() {
-	*m = QueryAllCoinMetaRollbackProtectionRequest{}
-}
-func (m *QueryAllCoinMetaRollbackProtectionRequest) String() string {
-	return proto.CompactTextString(m)
-}
-func (*QueryAllCoinMetaRollbackProtectionRequest) ProtoMessage() {}
-func (*QueryAllCoinMetaRollbackProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{12}
-}
-func (m *QueryAllCoinMetaRollbackProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllCoinMetaRollbackProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllCoinMetaRollbackProtectionRequest.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 *QueryAllCoinMetaRollbackProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllCoinMetaRollbackProtectionRequest.Merge(m, src)
-}
-func (m *QueryAllCoinMetaRollbackProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllCoinMetaRollbackProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllCoinMetaRollbackProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllCoinMetaRollbackProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryAllCoinMetaRollbackProtectionRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllCoinMetaRollbackProtectionResponse struct {
-	CoinMetaRollbackProtection []CoinMetaRollbackProtection `protobuf:"bytes,1,rep,name=coinMetaRollbackProtection,proto3" json:"coinMetaRollbackProtection"`
-	Pagination                 *query.PageResponse          `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionResponse) Reset() {
-	*m = QueryAllCoinMetaRollbackProtectionResponse{}
-}
-func (m *QueryAllCoinMetaRollbackProtectionResponse) String() string {
-	return proto.CompactTextString(m)
-}
-func (*QueryAllCoinMetaRollbackProtectionResponse) ProtoMessage() {}
-func (*QueryAllCoinMetaRollbackProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_132b8bb15c7c6368, []int{13}
-}
-func (m *QueryAllCoinMetaRollbackProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllCoinMetaRollbackProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllCoinMetaRollbackProtectionResponse.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 *QueryAllCoinMetaRollbackProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllCoinMetaRollbackProtectionResponse.Merge(m, src)
-}
-func (m *QueryAllCoinMetaRollbackProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllCoinMetaRollbackProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllCoinMetaRollbackProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllCoinMetaRollbackProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryAllCoinMetaRollbackProtectionResponse) GetCoinMetaRollbackProtection() []CoinMetaRollbackProtection {
-	if m != nil {
-		return m.CoinMetaRollbackProtection
-	}
-	return nil
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*QueryGetConfigRequest)(nil), "certusone.wormholechain.tokenbridge.QueryGetConfigRequest")
-	proto.RegisterType((*QueryGetConfigResponse)(nil), "certusone.wormholechain.tokenbridge.QueryGetConfigResponse")
-	proto.RegisterType((*QueryGetReplayProtectionRequest)(nil), "certusone.wormholechain.tokenbridge.QueryGetReplayProtectionRequest")
-	proto.RegisterType((*QueryGetReplayProtectionResponse)(nil), "certusone.wormholechain.tokenbridge.QueryGetReplayProtectionResponse")
-	proto.RegisterType((*QueryAllReplayProtectionRequest)(nil), "certusone.wormholechain.tokenbridge.QueryAllReplayProtectionRequest")
-	proto.RegisterType((*QueryAllReplayProtectionResponse)(nil), "certusone.wormholechain.tokenbridge.QueryAllReplayProtectionResponse")
-	proto.RegisterType((*QueryGetChainRegistrationRequest)(nil), "certusone.wormholechain.tokenbridge.QueryGetChainRegistrationRequest")
-	proto.RegisterType((*QueryGetChainRegistrationResponse)(nil), "certusone.wormholechain.tokenbridge.QueryGetChainRegistrationResponse")
-	proto.RegisterType((*QueryAllChainRegistrationRequest)(nil), "certusone.wormholechain.tokenbridge.QueryAllChainRegistrationRequest")
-	proto.RegisterType((*QueryAllChainRegistrationResponse)(nil), "certusone.wormholechain.tokenbridge.QueryAllChainRegistrationResponse")
-	proto.RegisterType((*QueryGetCoinMetaRollbackProtectionRequest)(nil), "certusone.wormholechain.tokenbridge.QueryGetCoinMetaRollbackProtectionRequest")
-	proto.RegisterType((*QueryGetCoinMetaRollbackProtectionResponse)(nil), "certusone.wormholechain.tokenbridge.QueryGetCoinMetaRollbackProtectionResponse")
-	proto.RegisterType((*QueryAllCoinMetaRollbackProtectionRequest)(nil), "certusone.wormholechain.tokenbridge.QueryAllCoinMetaRollbackProtectionRequest")
-	proto.RegisterType((*QueryAllCoinMetaRollbackProtectionResponse)(nil), "certusone.wormholechain.tokenbridge.QueryAllCoinMetaRollbackProtectionResponse")
-}
-
-func init() { proto.RegisterFile("tokenbridge/query.proto", fileDescriptor_132b8bb15c7c6368) }
-
-var fileDescriptor_132b8bb15c7c6368 = []byte{
-	// 835 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x97, 0x4d, 0x4f, 0xd4, 0x5c,
-	0x14, 0xc7, 0xe7, 0x0e, 0x0f, 0x3c, 0xf1, 0x1a, 0x12, 0xb8, 0xa2, 0x90, 0x46, 0x07, 0x2c, 0xc6,
-	0x17, 0x08, 0x6d, 0x80, 0x00, 0x46, 0x45, 0x1c, 0xde, 0x46, 0x16, 0xf2, 0xd2, 0xa5, 0x9b, 0x49,
-	0xa7, 0x5c, 0x4b, 0xa1, 0xd3, 0x3b, 0xb4, 0x1d, 0x85, 0x10, 0x16, 0x9a, 0xb8, 0x30, 0x26, 0x6a,
-	0xe2, 0x57, 0x31, 0x7e, 0x06, 0x96, 0x24, 0xba, 0x60, 0x65, 0x14, 0xd4, 0x95, 0x5f, 0xc1, 0xc4,
-	0xf4, 0xf6, 0x96, 0xe9, 0x74, 0xa6, 0x33, 0x2d, 0x53, 0xdd, 0xb5, 0xbd, 0x3d, 0xff, 0x73, 0x7e,
-	0xe7, 0x9c, 0x9e, 0x33, 0x03, 0x7b, 0x6d, 0xb2, 0x85, 0x8d, 0x82, 0xa9, 0xad, 0xab, 0x58, 0xdc,
-	0x2e, 0x63, 0x73, 0x57, 0x28, 0x99, 0xc4, 0x26, 0x68, 0x50, 0xc1, 0xa6, 0x5d, 0xb6, 0x88, 0x81,
-	0x85, 0x67, 0xc4, 0x2c, 0x6e, 0x10, 0x1d, 0x2b, 0x1b, 0xb2, 0x66, 0x08, 0x3e, 0x03, 0xee, 0xb2,
-	0x4a, 0x88, 0xaa, 0x63, 0x51, 0x2e, 0x69, 0xa2, 0x6c, 0x18, 0xc4, 0x96, 0x6d, 0x8d, 0x18, 0x96,
-	0x2b, 0xc1, 0x0d, 0x29, 0xc4, 0x2a, 0x12, 0x4b, 0x2c, 0xc8, 0x16, 0xd3, 0x16, 0x9f, 0x8e, 0x16,
-	0xb0, 0x2d, 0x8f, 0x8a, 0x25, 0x59, 0xd5, 0x0c, 0xfa, 0x32, 0x7b, 0xb7, 0xcf, 0x1f, 0x87, 0x42,
-	0x8c, 0x27, 0x9a, 0xca, 0x4e, 0x06, 0xfd, 0x27, 0x26, 0x2e, 0xe9, 0xf2, 0x6e, 0xde, 0x39, 0xc1,
-	0x8a, 0xcf, 0xfc, 0x5a, 0x95, 0xb9, 0x13, 0x67, 0xde, 0xc4, 0xaa, 0x66, 0xd9, 0xa6, 0xdf, 0x89,
-	0x58, 0xed, 0x44, 0x33, 0xf2, 0x45, 0x6c, 0xcb, 0x79, 0x93, 0xe8, 0x7a, 0x41, 0x56, 0xb6, 0x6a,
-	0x65, 0x7b, 0x54, 0xa2, 0x12, 0x7a, 0x29, 0x3a, 0x57, 0xee, 0x53, 0xbe, 0x17, 0x5e, 0x5c, 0x73,
-	0x68, 0x72, 0xd8, 0x9e, 0xa3, 0x91, 0x4a, 0x78, 0xbb, 0x8c, 0x2d, 0x9b, 0x57, 0xe0, 0xa5, 0xe0,
-	0x81, 0x55, 0x22, 0x86, 0x85, 0xd1, 0x12, 0xec, 0x70, 0x9f, 0xf4, 0x81, 0x01, 0x70, 0xf3, 0xfc,
-	0xd8, 0xb0, 0x10, 0x21, 0xbd, 0x82, 0x6b, 0x32, 0xfb, 0xdf, 0xc1, 0x97, 0xfe, 0x94, 0xc4, 0x04,
-	0xf8, 0x29, 0xd8, 0xef, 0x39, 0x91, 0x68, 0x36, 0x56, 0x4f, 0xa3, 0x66, 0x71, 0xa0, 0x1e, 0xd8,
-	0xae, 0x19, 0xeb, 0x78, 0x87, 0x3a, 0x3b, 0x27, 0xb9, 0x37, 0xfc, 0x6b, 0x00, 0x07, 0xc2, 0x2d,
-	0x59, 0xa0, 0x2a, 0xec, 0x32, 0x03, 0x67, 0x2c, 0xe4, 0x89, 0x48, 0x21, 0x07, 0x85, 0x59, 0xf0,
-	0x35, 0xa2, 0xbc, 0xc6, 0x30, 0xb2, 0xba, 0x1e, 0x86, 0xb1, 0x08, 0x61, 0xa5, 0x4f, 0x58, 0x14,
-	0xd7, 0x05, 0xb7, 0xa9, 0x04, 0xa7, 0xa9, 0x04, 0xb7, 0x61, 0x59, 0x53, 0x09, 0xab, 0xb2, 0x8a,
-	0x99, 0xad, 0xe4, 0xb3, 0xe4, 0x3f, 0x7b, 0xe0, 0x75, 0x7d, 0x35, 0x04, 0x6f, 0x4b, 0x1c, 0x1c,
-	0xe5, 0xaa, 0xa8, 0xd2, 0x94, 0xea, 0x46, 0x53, 0x2a, 0x37, 0xca, 0x2a, 0xac, 0x7b, 0x95, 0x72,
-	0xce, 0x39, 0xe1, 0x48, 0xbe, 0x86, 0xf7, 0x52, 0xd8, 0x07, 0xff, 0xa7, 0xa1, 0x2e, 0xcd, 0xd3,
-	0xfc, 0x75, 0x4a, 0xde, 0x2d, 0xff, 0x16, 0xc0, 0xab, 0x0d, 0xcc, 0x59, 0x56, 0x36, 0x61, 0xb7,
-	0x12, 0x3c, 0x64, 0x95, 0x98, 0x8c, 0xd6, 0xc2, 0x41, 0x6b, 0x96, 0x97, 0x5a, 0x59, 0x7e, 0xb3,
-	0x52, 0xa5, 0x50, 0x9e, 0xa4, 0x5a, 0xe2, 0xc8, 0xa3, 0xaf, 0xef, 0xac, 0x31, 0x7d, 0xdb, 0x5f,
-	0xa0, 0x4f, 0xae, 0x2d, 0xb2, 0xf0, 0x56, 0x65, 0x08, 0x69, 0xc6, 0x23, 0x6c, 0xcb, 0x12, 0x1b,
-	0x70, 0x51, 0x27, 0xc5, 0x07, 0x00, 0x87, 0xa2, 0x68, 0xb0, 0x34, 0xbd, 0x04, 0x90, 0x53, 0x42,
-	0x5f, 0x63, 0x55, 0x9a, 0x89, 0x38, 0xf1, 0xc2, 0x64, 0x58, 0xe6, 0x1a, 0x38, 0xe2, 0x2d, 0x46,
-	0xee, 0xd4, 0xb4, 0x29, 0x79, 0x52, 0x9d, 0xf4, 0xdb, 0xcb, 0x55, 0x13, 0xaf, 0x51, 0x73, 0xd5,
-	0xf6, 0x4f, 0x72, 0x95, 0x58, 0xbb, 0x8d, 0x3d, 0xef, 0x84, 0xed, 0x94, 0x1f, 0x7d, 0x04, 0xde,
-	0x92, 0x43, 0x77, 0x22, 0x01, 0xd4, 0x5d, 0xa2, 0xdc, 0xdd, 0x33, 0xd9, 0xba, 0x91, 0xf1, 0xe3,
-	0x2f, 0x3e, 0x7d, 0x7f, 0x9f, 0x1e, 0x41, 0xc3, 0xe2, 0xa9, 0x88, 0x58, 0x25, 0x22, 0xd6, 0xfe,
-	0xce, 0x40, 0x3f, 0x01, 0xec, 0x0a, 0x8e, 0x6f, 0x34, 0x1f, 0x2b, 0x8c, 0x90, 0x15, 0xc6, 0x2d,
-	0xb4, 0xa8, 0xc2, 0xb0, 0x16, 0x28, 0xd6, 0x0c, 0x9a, 0x8e, 0x84, 0x15, 0x5c, 0x39, 0xe2, 0x1e,
-	0xfd, 0xac, 0xf7, 0xd1, 0x37, 0x00, 0x2f, 0x04, 0x7d, 0x64, 0x75, 0x3d, 0x0e, 0x6b, 0xf8, 0xba,
-	0x8e, 0xc3, 0xda, 0x60, 0x11, 0xf3, 0xd3, 0x94, 0x75, 0x0a, 0x4d, 0x9c, 0x89, 0x15, 0xfd, 0x02,
-	0xb0, 0xbb, 0x66, 0xec, 0xa2, 0x78, 0x75, 0x08, 0x5b, 0x3f, 0xdc, 0x62, 0xab, 0x32, 0x8c, 0xf1,
-	0x21, 0x65, 0x9c, 0x45, 0x0f, 0xa2, 0xb5, 0x69, 0x50, 0x47, 0xdc, 0x63, 0x5b, 0x7c, 0x1f, 0xfd,
-	0x00, 0xb0, 0xa7, 0xc6, 0x8f, 0x53, 0xd3, 0x78, 0xd5, 0x48, 0x82, 0xb8, 0xd1, 0x2a, 0xe5, 0xef,
-	0x53, 0xe2, 0xdb, 0x68, 0xf2, 0x6c, 0xc4, 0xe8, 0x4d, 0x1a, 0x72, 0xe1, 0x03, 0x0f, 0x2d, 0xc7,
-	0x1c, 0x1a, 0x4d, 0xb6, 0x03, 0xb7, 0x92, 0x98, 0x1e, 0xe3, 0x5f, 0xa1, 0xfc, 0x4b, 0x28, 0x17,
-	0x71, 0x30, 0x85, 0x09, 0x9e, 0x7e, 0xcb, 0xaf, 0xd2, 0xf0, 0x4a, 0xb8, 0x5f, 0xa7, 0x03, 0x96,
-	0xe3, 0x95, 0x2e, 0xc9, 0x9c, 0x44, 0xda, 0x85, 0x7c, 0x8e, 0xe6, 0x24, 0x8b, 0x66, 0x5a, 0xcc,
-	0xc9, 0xec, 0xda, 0xc1, 0x71, 0x06, 0x1c, 0x1e, 0x67, 0xc0, 0xd7, 0xe3, 0x0c, 0x78, 0x77, 0x92,
-	0x49, 0x1d, 0x9e, 0x64, 0x52, 0x47, 0x27, 0x99, 0xd4, 0xe3, 0x29, 0x55, 0xb3, 0x37, 0xca, 0x05,
-	0x41, 0x21, 0xc5, 0x3a, 0x4e, 0x46, 0x5c, 0x2f, 0x3b, 0x55, 0x7e, 0xec, 0xdd, 0x12, 0xb6, 0x0a,
-	0x1d, 0xf4, 0xaf, 0xde, 0xf8, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0x00, 0xf8, 0x00, 0x20,
-	0x0f, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// QueryClient is the client API for Query service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type QueryClient interface {
-	// Queries a config by index.
-	Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error)
-	// Queries a replayProtection by index.
-	ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error)
-	// Queries a list of replayProtection items.
-	ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error)
-	// Queries a chainRegistration by index.
-	ChainRegistration(ctx context.Context, in *QueryGetChainRegistrationRequest, opts ...grpc.CallOption) (*QueryGetChainRegistrationResponse, error)
-	// Queries a list of chainRegistration items.
-	ChainRegistrationAll(ctx context.Context, in *QueryAllChainRegistrationRequest, opts ...grpc.CallOption) (*QueryAllChainRegistrationResponse, error)
-	// Queries a coinMetaRollbackProtection by index.
-	CoinMetaRollbackProtection(ctx context.Context, in *QueryGetCoinMetaRollbackProtectionRequest, opts ...grpc.CallOption) (*QueryGetCoinMetaRollbackProtectionResponse, error)
-	// Queries a list of coinMetaRollbackProtection items.
-	CoinMetaRollbackProtectionAll(ctx context.Context, in *QueryAllCoinMetaRollbackProtectionRequest, opts ...grpc.CallOption) (*QueryAllCoinMetaRollbackProtectionResponse, error)
-}
-
-type queryClient struct {
-	cc grpc1.ClientConn
-}
-
-func NewQueryClient(cc grpc1.ClientConn) QueryClient {
-	return &queryClient{cc}
-}
-
-func (c *queryClient) Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error) {
-	out := new(QueryGetConfigResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/Config", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error) {
-	out := new(QueryGetReplayProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/ReplayProtection", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error) {
-	out := new(QueryAllReplayProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/ReplayProtectionAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ChainRegistration(ctx context.Context, in *QueryGetChainRegistrationRequest, opts ...grpc.CallOption) (*QueryGetChainRegistrationResponse, error) {
-	out := new(QueryGetChainRegistrationResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/ChainRegistration", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ChainRegistrationAll(ctx context.Context, in *QueryAllChainRegistrationRequest, opts ...grpc.CallOption) (*QueryAllChainRegistrationResponse, error) {
-	out := new(QueryAllChainRegistrationResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/ChainRegistrationAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) CoinMetaRollbackProtection(ctx context.Context, in *QueryGetCoinMetaRollbackProtectionRequest, opts ...grpc.CallOption) (*QueryGetCoinMetaRollbackProtectionResponse, error) {
-	out := new(QueryGetCoinMetaRollbackProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/CoinMetaRollbackProtection", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) CoinMetaRollbackProtectionAll(ctx context.Context, in *QueryAllCoinMetaRollbackProtectionRequest, opts ...grpc.CallOption) (*QueryAllCoinMetaRollbackProtectionResponse, error) {
-	out := new(QueryAllCoinMetaRollbackProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Query/CoinMetaRollbackProtectionAll", 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 config by index.
-	Config(context.Context, *QueryGetConfigRequest) (*QueryGetConfigResponse, error)
-	// Queries a replayProtection by index.
-	ReplayProtection(context.Context, *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error)
-	// Queries a list of replayProtection items.
-	ReplayProtectionAll(context.Context, *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error)
-	// Queries a chainRegistration by index.
-	ChainRegistration(context.Context, *QueryGetChainRegistrationRequest) (*QueryGetChainRegistrationResponse, error)
-	// Queries a list of chainRegistration items.
-	ChainRegistrationAll(context.Context, *QueryAllChainRegistrationRequest) (*QueryAllChainRegistrationResponse, error)
-	// Queries a coinMetaRollbackProtection by index.
-	CoinMetaRollbackProtection(context.Context, *QueryGetCoinMetaRollbackProtectionRequest) (*QueryGetCoinMetaRollbackProtectionResponse, error)
-	// Queries a list of coinMetaRollbackProtection items.
-	CoinMetaRollbackProtectionAll(context.Context, *QueryAllCoinMetaRollbackProtectionRequest) (*QueryAllCoinMetaRollbackProtectionResponse, error)
-}
-
-// UnimplementedQueryServer can be embedded to have forward compatible implementations.
-type UnimplementedQueryServer struct {
-}
-
-func (*UnimplementedQueryServer) Config(ctx context.Context, req *QueryGetConfigRequest) (*QueryGetConfigResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Config not implemented")
-}
-func (*UnimplementedQueryServer) ReplayProtection(ctx context.Context, req *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ReplayProtection not implemented")
-}
-func (*UnimplementedQueryServer) ReplayProtectionAll(ctx context.Context, req *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ReplayProtectionAll not implemented")
-}
-func (*UnimplementedQueryServer) ChainRegistration(ctx context.Context, req *QueryGetChainRegistrationRequest) (*QueryGetChainRegistrationResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ChainRegistration not implemented")
-}
-func (*UnimplementedQueryServer) ChainRegistrationAll(ctx context.Context, req *QueryAllChainRegistrationRequest) (*QueryAllChainRegistrationResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ChainRegistrationAll not implemented")
-}
-func (*UnimplementedQueryServer) CoinMetaRollbackProtection(ctx context.Context, req *QueryGetCoinMetaRollbackProtectionRequest) (*QueryGetCoinMetaRollbackProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CoinMetaRollbackProtection not implemented")
-}
-func (*UnimplementedQueryServer) CoinMetaRollbackProtectionAll(ctx context.Context, req *QueryAllCoinMetaRollbackProtectionRequest) (*QueryAllCoinMetaRollbackProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CoinMetaRollbackProtectionAll not implemented")
-}
-
-func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
-	s.RegisterService(&_Query_serviceDesc, srv)
-}
-
-func _Query_Config_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetConfigRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).Config(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/Config",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).Config(ctx, req.(*QueryGetConfigRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ReplayProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetReplayProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ReplayProtection(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/ReplayProtection",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ReplayProtection(ctx, req.(*QueryGetReplayProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ReplayProtectionAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllReplayProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ReplayProtectionAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/ReplayProtectionAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ReplayProtectionAll(ctx, req.(*QueryAllReplayProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ChainRegistration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetChainRegistrationRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ChainRegistration(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/ChainRegistration",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ChainRegistration(ctx, req.(*QueryGetChainRegistrationRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ChainRegistrationAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllChainRegistrationRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ChainRegistrationAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/ChainRegistrationAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ChainRegistrationAll(ctx, req.(*QueryAllChainRegistrationRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_CoinMetaRollbackProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetCoinMetaRollbackProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).CoinMetaRollbackProtection(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/CoinMetaRollbackProtection",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).CoinMetaRollbackProtection(ctx, req.(*QueryGetCoinMetaRollbackProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_CoinMetaRollbackProtectionAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllCoinMetaRollbackProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).CoinMetaRollbackProtectionAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Query/CoinMetaRollbackProtectionAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).CoinMetaRollbackProtectionAll(ctx, req.(*QueryAllCoinMetaRollbackProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Query_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "certusone.wormholechain.tokenbridge.Query",
-	HandlerType: (*QueryServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Config",
-			Handler:    _Query_Config_Handler,
-		},
-		{
-			MethodName: "ReplayProtection",
-			Handler:    _Query_ReplayProtection_Handler,
-		},
-		{
-			MethodName: "ReplayProtectionAll",
-			Handler:    _Query_ReplayProtectionAll_Handler,
-		},
-		{
-			MethodName: "ChainRegistration",
-			Handler:    _Query_ChainRegistration_Handler,
-		},
-		{
-			MethodName: "ChainRegistrationAll",
-			Handler:    _Query_ChainRegistrationAll_Handler,
-		},
-		{
-			MethodName: "CoinMetaRollbackProtection",
-			Handler:    _Query_CoinMetaRollbackProtection_Handler,
-		},
-		{
-			MethodName: "CoinMetaRollbackProtectionAll",
-			Handler:    _Query_CoinMetaRollbackProtectionAll_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "tokenbridge/query.proto",
-}
-
-func (m *QueryGetConfigRequest) 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 *QueryGetConfigRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetConfigResponse) 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 *QueryGetConfigResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.Config.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 *QueryGetReplayProtectionRequest) 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 *QueryGetReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetReplayProtectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetReplayProtectionResponse) 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 *QueryGetReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetReplayProtectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.ReplayProtection.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 *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionResponse) 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 *QueryAllReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllReplayProtectionResponse) 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.ReplayProtection) > 0 {
-		for iNdEx := len(m.ReplayProtection) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ReplayProtection[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 (m *QueryGetChainRegistrationRequest) 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 *QueryGetChainRegistrationRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetChainRegistrationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.ChainID != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.ChainID))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetChainRegistrationResponse) 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 *QueryGetChainRegistrationResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetChainRegistrationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.ChainRegistration.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 *QueryAllChainRegistrationRequest) 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 *QueryAllChainRegistrationRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllChainRegistrationRequest) 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 *QueryAllChainRegistrationResponse) 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 *QueryAllChainRegistrationResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllChainRegistrationResponse) 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.ChainRegistration) > 0 {
-		for iNdEx := len(m.ChainRegistration) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ChainRegistration[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 (m *QueryGetCoinMetaRollbackProtectionRequest) 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 *QueryGetCoinMetaRollbackProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionResponse) 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 *QueryGetCoinMetaRollbackProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.CoinMetaRollbackProtection.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 *QueryAllCoinMetaRollbackProtectionRequest) 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 *QueryAllCoinMetaRollbackProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionRequest) 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 *QueryAllCoinMetaRollbackProtectionResponse) 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 *QueryAllCoinMetaRollbackProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionResponse) 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.CoinMetaRollbackProtection) > 0 {
-		for iNdEx := len(m.CoinMetaRollbackProtection) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.CoinMetaRollbackProtection[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
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *QueryGetConfigRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *QueryGetConfigResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Config.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryGetReplayProtectionRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryGetReplayProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.ReplayProtection.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.ReplayProtection) > 0 {
-		for _, e := range m.ReplayProtection {
-			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 (m *QueryGetChainRegistrationRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.ChainID != 0 {
-		n += 1 + sovQuery(uint64(m.ChainID))
-	}
-	return n
-}
-
-func (m *QueryGetChainRegistrationResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.ChainRegistration.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllChainRegistrationRequest) 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 *QueryAllChainRegistrationResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.ChainRegistration) > 0 {
-		for _, e := range m.ChainRegistration {
-			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 (m *QueryGetCoinMetaRollbackProtectionRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryGetCoinMetaRollbackProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.CoinMetaRollbackProtection.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllCoinMetaRollbackProtectionRequest) 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 *QueryAllCoinMetaRollbackProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.CoinMetaRollbackProtection) > 0 {
-		for _, e := range m.CoinMetaRollbackProtection {
-			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
-}
-func sozQuery(x uint64) (n int) {
-	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *QueryGetConfigRequest) 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: QueryGetConfigRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		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 *QueryGetConfigResponse) 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: QueryGetConfigResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Config", 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 err := m.Config.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 *QueryGetReplayProtectionRequest) 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: QueryGetReplayProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetReplayProtectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				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 ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			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 *QueryGetReplayProtectionResponse) 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: QueryGetReplayProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", 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 err := m.ReplayProtection.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 *QueryAllReplayProtectionRequest) 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: QueryAllReplayProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllReplayProtectionRequest: 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 *QueryAllReplayProtectionResponse) 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: QueryAllReplayProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", 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.ReplayProtection = append(m.ReplayProtection, ReplayProtection{})
-			if err := m.ReplayProtection[len(m.ReplayProtection)-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 (m *QueryGetChainRegistrationRequest) 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: QueryGetChainRegistrationRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetChainRegistrationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
-			}
-			m.ChainID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ChainID |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		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 *QueryGetChainRegistrationResponse) 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: QueryGetChainRegistrationResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetChainRegistrationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainRegistration", 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 err := m.ChainRegistration.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 *QueryAllChainRegistrationRequest) 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: QueryAllChainRegistrationRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllChainRegistrationRequest: 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 *QueryAllChainRegistrationResponse) 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: QueryAllChainRegistrationResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllChainRegistrationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainRegistration", 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.ChainRegistration = append(m.ChainRegistration, ChainRegistration{})
-			if err := m.ChainRegistration[len(m.ChainRegistration)-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 (m *QueryGetCoinMetaRollbackProtectionRequest) 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: QueryGetCoinMetaRollbackProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetCoinMetaRollbackProtectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				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 ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			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 *QueryGetCoinMetaRollbackProtectionResponse) 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: QueryGetCoinMetaRollbackProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetCoinMetaRollbackProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CoinMetaRollbackProtection", 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 err := m.CoinMetaRollbackProtection.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 *QueryAllCoinMetaRollbackProtectionRequest) 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: QueryAllCoinMetaRollbackProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllCoinMetaRollbackProtectionRequest: 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 *QueryAllCoinMetaRollbackProtectionResponse) 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: QueryAllCoinMetaRollbackProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllCoinMetaRollbackProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CoinMetaRollbackProtection", 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.CoinMetaRollbackProtection = append(m.CoinMetaRollbackProtection, CoinMetaRollbackProtection{})
-			if err := m.CoinMetaRollbackProtection[len(m.CoinMetaRollbackProtection)-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
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowQuery
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthQuery
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupQuery
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthQuery
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/query.pb.gw.go

@@ -673,19 +673,19 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 }
 
 var (
-	pattern_Query_Config_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "tokenbridge", "config"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_Config_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "config"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ReplayProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "tokenbridge", "replayProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ReplayProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "replayProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ReplayProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "tokenbridge", "replayProtection"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ReplayProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "replayProtection"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ChainRegistration_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "tokenbridge", "chainRegistration", "chainID"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ChainRegistration_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "chainRegistration", "chainID"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ChainRegistrationAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "tokenbridge", "chainRegistration"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ChainRegistrationAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "chainRegistration"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_CoinMetaRollbackProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "tokenbridge", "coinMetaRollbackProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_CoinMetaRollbackProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "coinMetaRollbackProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_CoinMetaRollbackProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "tokenbridge", "coinMetaRollbackProtection"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_CoinMetaRollbackProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "tokenbridge", "coinMetaRollbackProtection"}, "", runtime.AssumeColonVerbOpt(true)))
 )
 
 var (

wormhole_chain/x/tokenbridge/types/replay_protection.pb.go

@@ -1,319 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/replay_protection.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type ReplayProtection struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *ReplayProtection) Reset()         { *m = ReplayProtection{} }
-func (m *ReplayProtection) String() string { return proto.CompactTextString(m) }
-func (*ReplayProtection) ProtoMessage()    {}
-func (*ReplayProtection) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26423141334c99f9, []int{0}
-}
-func (m *ReplayProtection) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ReplayProtection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ReplayProtection.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 *ReplayProtection) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplayProtection.Merge(m, src)
-}
-func (m *ReplayProtection) XXX_Size() int {
-	return m.Size()
-}
-func (m *ReplayProtection) XXX_DiscardUnknown() {
-	xxx_messageInfo_ReplayProtection.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ReplayProtection proto.InternalMessageInfo
-
-func (m *ReplayProtection) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*ReplayProtection)(nil), "certusone.wormholechain.tokenbridge.ReplayProtection")
-}
-
-func init() {
-	proto.RegisterFile("tokenbridge/replay_protection.proto", fileDescriptor_26423141334c99f9)
-}
-
-var fileDescriptor_26423141334c99f9 = []byte{
-	// 179 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2e, 0xc9, 0xcf, 0x4e,
-	0xcd, 0x4b, 0x2a, 0xca, 0x4c, 0x49, 0x4f, 0xd5, 0x2f, 0x4a, 0x2d, 0xc8, 0x49, 0xac, 0x8c, 0x2f,
-	0x28, 0xca, 0x2f, 0x49, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x31, 0xf3, 0x85, 0x94, 0x93,
-	0x53, 0x8b, 0x4a, 0x4a, 0x8b, 0xf3, 0xf3, 0x52, 0xf5, 0xca, 0xf3, 0x8b, 0x72, 0x33, 0xf2, 0x73,
-	0x52, 0x93, 0x33, 0x12, 0x33, 0xf3, 0xf4, 0x90, 0x34, 0x2b, 0x69, 0x70, 0x09, 0x04, 0x81, 0xf5,
-	0x07, 0xc0, 0xb5, 0x0b, 0x89, 0x70, 0xb1, 0x66, 0xe6, 0xa5, 0xa4, 0x56, 0x48, 0x30, 0x2a, 0x30,
-	0x6a, 0x70, 0x06, 0x41, 0x38, 0x4e, 0x81, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8,
-	0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7,
-	0x10, 0x65, 0x9e, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f, 0xb7, 0x53,
-	0x1f, 0x66, 0xa7, 0x2e, 0xd8, 0x52, 0xfd, 0x0a, 0x7d, 0x64, 0x37, 0x97, 0x54, 0x16, 0xa4, 0x16,
-	0x27, 0xb1, 0x81, 0x1d, 0x6a, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x31, 0xc6, 0x02, 0xec, 0xcf,
-	0x00, 0x00, 0x00,
-}
-
-func (m *ReplayProtection) 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 *ReplayProtection) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ReplayProtection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintReplayProtection(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintReplayProtection(dAtA []byte, offset int, v uint64) int {
-	offset -= sovReplayProtection(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *ReplayProtection) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovReplayProtection(uint64(l))
-	}
-	return n
-}
-
-func sovReplayProtection(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozReplayProtection(x uint64) (n int) {
-	return sovReplayProtection(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *ReplayProtection) 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 ErrIntOverflowReplayProtection
-			}
-			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: ReplayProtection: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ReplayProtection: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowReplayProtection
-				}
-				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 ErrInvalidLengthReplayProtection
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthReplayProtection
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipReplayProtection(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthReplayProtection
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipReplayProtection(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowReplayProtection
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowReplayProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowReplayProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthReplayProtection
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupReplayProtection
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthReplayProtection
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthReplayProtection        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowReplayProtection          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupReplayProtection = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/tokenbridge/types/tx.pb.go

@@ -1,1870 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tokenbridge/tx.proto
-
-package types
-
-import (
-	context "context"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	types "github.com/cosmos/cosmos-sdk/types"
-	_ "github.com/gogo/protobuf/gogoproto"
-	grpc1 "github.com/gogo/protobuf/grpc"
-	proto "github.com/gogo/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type MsgExecuteGovernanceVAA struct {
-	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Vaa     []byte `protobuf:"bytes,2,opt,name=vaa,proto3" json:"vaa,omitempty"`
-}
-
-func (m *MsgExecuteGovernanceVAA) Reset()         { *m = MsgExecuteGovernanceVAA{} }
-func (m *MsgExecuteGovernanceVAA) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteGovernanceVAA) ProtoMessage()    {}
-func (*MsgExecuteGovernanceVAA) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{0}
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteGovernanceVAA.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 *MsgExecuteGovernanceVAA) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteGovernanceVAA.Merge(m, src)
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteGovernanceVAA) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteGovernanceVAA.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteGovernanceVAA proto.InternalMessageInfo
-
-func (m *MsgExecuteGovernanceVAA) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *MsgExecuteGovernanceVAA) GetVaa() []byte {
-	if m != nil {
-		return m.Vaa
-	}
-	return nil
-}
-
-type MsgExecuteGovernanceVAAResponse struct {
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) Reset()         { *m = MsgExecuteGovernanceVAAResponse{} }
-func (m *MsgExecuteGovernanceVAAResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteGovernanceVAAResponse) ProtoMessage()    {}
-func (*MsgExecuteGovernanceVAAResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{1}
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteGovernanceVAAResponse.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 *MsgExecuteGovernanceVAAResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteGovernanceVAAResponse.Merge(m, src)
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteGovernanceVAAResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteGovernanceVAAResponse proto.InternalMessageInfo
-
-type MsgExecuteVAA struct {
-	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Vaa     []byte `protobuf:"bytes,2,opt,name=vaa,proto3" json:"vaa,omitempty"`
-}
-
-func (m *MsgExecuteVAA) Reset()         { *m = MsgExecuteVAA{} }
-func (m *MsgExecuteVAA) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteVAA) ProtoMessage()    {}
-func (*MsgExecuteVAA) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{2}
-}
-func (m *MsgExecuteVAA) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteVAA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteVAA.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 *MsgExecuteVAA) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteVAA.Merge(m, src)
-}
-func (m *MsgExecuteVAA) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteVAA) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteVAA.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteVAA proto.InternalMessageInfo
-
-func (m *MsgExecuteVAA) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *MsgExecuteVAA) GetVaa() []byte {
-	if m != nil {
-		return m.Vaa
-	}
-	return nil
-}
-
-type MsgExecuteVAAResponse struct {
-}
-
-func (m *MsgExecuteVAAResponse) Reset()         { *m = MsgExecuteVAAResponse{} }
-func (m *MsgExecuteVAAResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteVAAResponse) ProtoMessage()    {}
-func (*MsgExecuteVAAResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{3}
-}
-func (m *MsgExecuteVAAResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteVAAResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteVAAResponse.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 *MsgExecuteVAAResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteVAAResponse.Merge(m, src)
-}
-func (m *MsgExecuteVAAResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteVAAResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteVAAResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteVAAResponse proto.InternalMessageInfo
-
-type MsgAttestToken struct {
-	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Denom   string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
-}
-
-func (m *MsgAttestToken) Reset()         { *m = MsgAttestToken{} }
-func (m *MsgAttestToken) String() string { return proto.CompactTextString(m) }
-func (*MsgAttestToken) ProtoMessage()    {}
-func (*MsgAttestToken) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{4}
-}
-func (m *MsgAttestToken) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgAttestToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgAttestToken.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 *MsgAttestToken) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgAttestToken.Merge(m, src)
-}
-func (m *MsgAttestToken) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgAttestToken) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgAttestToken.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgAttestToken proto.InternalMessageInfo
-
-func (m *MsgAttestToken) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *MsgAttestToken) GetDenom() string {
-	if m != nil {
-		return m.Denom
-	}
-	return ""
-}
-
-type MsgAttestTokenResponse struct {
-}
-
-func (m *MsgAttestTokenResponse) Reset()         { *m = MsgAttestTokenResponse{} }
-func (m *MsgAttestTokenResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgAttestTokenResponse) ProtoMessage()    {}
-func (*MsgAttestTokenResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{5}
-}
-func (m *MsgAttestTokenResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgAttestTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgAttestTokenResponse.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 *MsgAttestTokenResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgAttestTokenResponse.Merge(m, src)
-}
-func (m *MsgAttestTokenResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgAttestTokenResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgAttestTokenResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgAttestTokenResponse proto.InternalMessageInfo
-
-type MsgTransfer struct {
-	Creator   string     `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Amount    types.Coin `protobuf:"bytes,2,opt,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
-	ToChain   uint32     `protobuf:"varint,3,opt,name=toChain,proto3" json:"toChain,omitempty"`
-	ToAddress []byte     `protobuf:"bytes,4,opt,name=toAddress,proto3" json:"toAddress,omitempty"`
-	Fee       types.Coin `protobuf:"bytes,5,opt,name=fee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fee"`
-}
-
-func (m *MsgTransfer) Reset()         { *m = MsgTransfer{} }
-func (m *MsgTransfer) String() string { return proto.CompactTextString(m) }
-func (*MsgTransfer) ProtoMessage()    {}
-func (*MsgTransfer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{6}
-}
-func (m *MsgTransfer) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgTransfer.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 *MsgTransfer) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgTransfer.Merge(m, src)
-}
-func (m *MsgTransfer) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgTransfer) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgTransfer.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgTransfer proto.InternalMessageInfo
-
-func (m *MsgTransfer) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *MsgTransfer) GetAmount() types.Coin {
-	if m != nil {
-		return m.Amount
-	}
-	return types.Coin{}
-}
-
-func (m *MsgTransfer) GetToChain() uint32 {
-	if m != nil {
-		return m.ToChain
-	}
-	return 0
-}
-
-func (m *MsgTransfer) GetToAddress() []byte {
-	if m != nil {
-		return m.ToAddress
-	}
-	return nil
-}
-
-func (m *MsgTransfer) GetFee() types.Coin {
-	if m != nil {
-		return m.Fee
-	}
-	return types.Coin{}
-}
-
-type MsgTransferResponse struct {
-}
-
-func (m *MsgTransferResponse) Reset()         { *m = MsgTransferResponse{} }
-func (m *MsgTransferResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgTransferResponse) ProtoMessage()    {}
-func (*MsgTransferResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0276d64dbbd0bb29, []int{7}
-}
-func (m *MsgTransferResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgTransferResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgTransferResponse.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 *MsgTransferResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgTransferResponse.Merge(m, src)
-}
-func (m *MsgTransferResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgTransferResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgTransferResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgTransferResponse proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*MsgExecuteGovernanceVAA)(nil), "certusone.wormholechain.tokenbridge.MsgExecuteGovernanceVAA")
-	proto.RegisterType((*MsgExecuteGovernanceVAAResponse)(nil), "certusone.wormholechain.tokenbridge.MsgExecuteGovernanceVAAResponse")
-	proto.RegisterType((*MsgExecuteVAA)(nil), "certusone.wormholechain.tokenbridge.MsgExecuteVAA")
-	proto.RegisterType((*MsgExecuteVAAResponse)(nil), "certusone.wormholechain.tokenbridge.MsgExecuteVAAResponse")
-	proto.RegisterType((*MsgAttestToken)(nil), "certusone.wormholechain.tokenbridge.MsgAttestToken")
-	proto.RegisterType((*MsgAttestTokenResponse)(nil), "certusone.wormholechain.tokenbridge.MsgAttestTokenResponse")
-	proto.RegisterType((*MsgTransfer)(nil), "certusone.wormholechain.tokenbridge.MsgTransfer")
-	proto.RegisterType((*MsgTransferResponse)(nil), "certusone.wormholechain.tokenbridge.MsgTransferResponse")
-}
-
-func init() { proto.RegisterFile("tokenbridge/tx.proto", fileDescriptor_0276d64dbbd0bb29) }
-
-var fileDescriptor_0276d64dbbd0bb29 = []byte{
-	// 513 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x31, 0x6f, 0xd3, 0x40,
-	0x14, 0xc7, 0xe3, 0xa6, 0x2d, 0xe4, 0x85, 0x22, 0x64, 0x52, 0x6a, 0x22, 0xe4, 0x84, 0xb0, 0x64,
-	0xe9, 0x5d, 0x9b, 0x0e, 0x20, 0xca, 0x40, 0x5a, 0x2a, 0xa6, 0x0c, 0x58, 0x15, 0x03, 0x12, 0x83,
-	0xe3, 0xbc, 0x3a, 0x56, 0xf1, 0xbd, 0xe8, 0xee, 0x12, 0x82, 0x84, 0xc4, 0x57, 0x60, 0x85, 0x95,
-	0x8d, 0x4f, 0xd2, 0xb1, 0x23, 0x13, 0xa0, 0xe4, 0x8b, 0x20, 0xdb, 0xb1, 0xeb, 0x48, 0xb4, 0x4a,
-	0xa0, 0x53, 0xee, 0xc5, 0xef, 0xff, 0x7b, 0x4f, 0xff, 0xfb, 0xeb, 0xa0, 0xa2, 0xe9, 0x14, 0x45,
-	0x57, 0x06, 0x3d, 0x1f, 0xb9, 0x1e, 0xb3, 0x81, 0x24, 0x4d, 0xe6, 0x23, 0x0f, 0xa5, 0x1e, 0x2a,
-	0x12, 0xc8, 0xde, 0x93, 0x0c, 0xfb, 0xf4, 0x0e, 0xbd, 0xbe, 0x1b, 0x08, 0x96, 0xeb, 0xae, 0x56,
-	0x7c, 0xf2, 0x29, 0xee, 0xe7, 0xd1, 0x29, 0x91, 0x56, 0x6d, 0x8f, 0x54, 0x48, 0x8a, 0x77, 0x5d,
-	0x85, 0x7c, 0xb4, 0xdb, 0x45, 0xed, 0xee, 0x72, 0x8f, 0x02, 0x91, 0x7c, 0x6f, 0x1c, 0xc1, 0x56,
-	0x47, 0xf9, 0x47, 0x63, 0xf4, 0x86, 0x1a, 0x5f, 0xd2, 0x08, 0xa5, 0x70, 0x85, 0x87, 0xaf, 0xdb,
-	0x6d, 0xd3, 0x82, 0x1b, 0x9e, 0x44, 0x57, 0x93, 0xb4, 0x8c, 0xba, 0xd1, 0x2c, 0x39, 0x69, 0x69,
-	0xde, 0x81, 0xe2, 0xc8, 0x75, 0xad, 0x95, 0xba, 0xd1, 0xbc, 0xe5, 0x44, 0xc7, 0xc6, 0x43, 0xa8,
-	0x5d, 0x82, 0x71, 0x50, 0x0d, 0x48, 0x28, 0x6c, 0xec, 0xc3, 0xc6, 0x45, 0xcb, 0xb2, 0xfc, 0x2d,
-	0xd8, 0x9c, 0x13, 0x67, 0xd4, 0xe7, 0x70, 0xbb, 0xa3, 0xfc, 0xb6, 0xd6, 0xa8, 0xf4, 0x71, 0xe4,
-	0xc6, 0x15, 0xd8, 0x0a, 0xac, 0xf5, 0x50, 0x50, 0x18, 0x83, 0x4b, 0x4e, 0x52, 0x34, 0x2c, 0xb8,
-	0x37, 0x4f, 0xc8, 0xd8, 0xdf, 0x56, 0xa0, 0xdc, 0x51, 0xfe, 0xb1, 0x74, 0x85, 0x3a, 0x41, 0x79,
-	0x05, 0xd9, 0x83, 0x75, 0x37, 0xa4, 0xa1, 0xd0, 0x31, 0xba, 0xdc, 0xba, 0xcf, 0x12, 0xdb, 0x59,
-	0x64, 0x3b, 0x9b, 0xd9, 0xce, 0x0e, 0x29, 0x10, 0x07, 0x3b, 0x67, 0x3f, 0x6b, 0x85, 0xef, 0xbf,
-	0x6a, 0x4d, 0x3f, 0xd0, 0xfd, 0x61, 0x97, 0x79, 0x14, 0xf2, 0xd9, 0x1d, 0x25, 0x3f, 0xdb, 0xaa,
-	0x77, 0xca, 0xf5, 0x87, 0x01, 0xaa, 0x58, 0xa0, 0x9c, 0x19, 0x3a, 0x1a, 0xaf, 0xe9, 0x30, 0xba,
-	0x77, 0xab, 0x58, 0x37, 0x9a, 0x1b, 0x4e, 0x5a, 0x9a, 0x0f, 0xa0, 0xa4, 0xa9, 0xdd, 0xeb, 0x49,
-	0x54, 0xca, 0x5a, 0x8d, 0x5d, 0xbb, 0xf8, 0xc3, 0x7c, 0x0b, 0xc5, 0x13, 0x44, 0x6b, 0xed, 0xfa,
-	0x37, 0x8b, 0xb8, 0x8d, 0x4d, 0xb8, 0x9b, 0x33, 0x29, 0x35, 0xaf, 0xf5, 0x65, 0x15, 0x8a, 0x1d,
-	0xe5, 0x9b, 0x5f, 0x0d, 0xa8, 0xfc, 0x35, 0x5e, 0xcf, 0xd8, 0x02, 0xa9, 0x66, 0x97, 0xa4, 0xaa,
-	0xfa, 0xe2, 0x7f, 0xd4, 0xe9, 0x92, 0xe6, 0x47, 0x80, 0x5c, 0x20, 0x5b, 0x4b, 0x32, 0xa3, 0x3d,
-	0x9e, 0x2e, 0xaf, 0xc9, 0xa6, 0x7f, 0x82, 0x72, 0x3e, 0xb8, 0x7b, 0x8b, 0xa2, 0x72, 0xa2, 0xea,
-	0xfe, 0x3f, 0x88, 0xb2, 0x05, 0x46, 0x70, 0x33, 0x0b, 0xf7, 0xce, 0xa2, 0xa0, 0x54, 0x51, 0x7d,
-	0xb2, 0xac, 0x22, 0x9d, 0x7b, 0xf0, 0xea, 0x6c, 0x62, 0x1b, 0xe7, 0x13, 0xdb, 0xf8, 0x3d, 0xb1,
-	0x8d, 0xcf, 0x53, 0xbb, 0x70, 0x3e, 0xb5, 0x0b, 0x3f, 0xa6, 0x76, 0xe1, 0xcd, 0xe3, 0x7c, 0xf6,
-	0x52, 0x3a, 0x4f, 0xe9, 0xdb, 0x31, 0x9e, 0x8f, 0xf9, 0xdc, 0x2b, 0x19, 0x05, 0xb2, 0xbb, 0x1e,
-	0x3f, 0x67, 0x7b, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x8b, 0x37, 0x29, 0x41, 0x05, 0x00,
-	0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// MsgClient is the client API for Msg service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type MsgClient interface {
-	ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error)
-	ExecuteVAA(ctx context.Context, in *MsgExecuteVAA, opts ...grpc.CallOption) (*MsgExecuteVAAResponse, error)
-	AttestToken(ctx context.Context, in *MsgAttestToken, opts ...grpc.CallOption) (*MsgAttestTokenResponse, error)
-	Transfer(ctx context.Context, in *MsgTransfer, opts ...grpc.CallOption) (*MsgTransferResponse, error)
-}
-
-type msgClient struct {
-	cc grpc1.ClientConn
-}
-
-func NewMsgClient(cc grpc1.ClientConn) MsgClient {
-	return &msgClient{cc}
-}
-
-func (c *msgClient) ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error) {
-	out := new(MsgExecuteGovernanceVAAResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Msg/ExecuteGovernanceVAA", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *msgClient) ExecuteVAA(ctx context.Context, in *MsgExecuteVAA, opts ...grpc.CallOption) (*MsgExecuteVAAResponse, error) {
-	out := new(MsgExecuteVAAResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Msg/ExecuteVAA", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *msgClient) AttestToken(ctx context.Context, in *MsgAttestToken, opts ...grpc.CallOption) (*MsgAttestTokenResponse, error) {
-	out := new(MsgAttestTokenResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Msg/AttestToken", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *msgClient) Transfer(ctx context.Context, in *MsgTransfer, opts ...grpc.CallOption) (*MsgTransferResponse, error) {
-	out := new(MsgTransferResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.tokenbridge.Msg/Transfer", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// MsgServer is the server API for Msg service.
-type MsgServer interface {
-	ExecuteGovernanceVAA(context.Context, *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error)
-	ExecuteVAA(context.Context, *MsgExecuteVAA) (*MsgExecuteVAAResponse, error)
-	AttestToken(context.Context, *MsgAttestToken) (*MsgAttestTokenResponse, error)
-	Transfer(context.Context, *MsgTransfer) (*MsgTransferResponse, error)
-}
-
-// UnimplementedMsgServer can be embedded to have forward compatible implementations.
-type UnimplementedMsgServer struct {
-}
-
-func (*UnimplementedMsgServer) ExecuteGovernanceVAA(ctx context.Context, req *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ExecuteGovernanceVAA not implemented")
-}
-func (*UnimplementedMsgServer) ExecuteVAA(ctx context.Context, req *MsgExecuteVAA) (*MsgExecuteVAAResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ExecuteVAA not implemented")
-}
-func (*UnimplementedMsgServer) AttestToken(ctx context.Context, req *MsgAttestToken) (*MsgAttestTokenResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method AttestToken not implemented")
-}
-func (*UnimplementedMsgServer) Transfer(ctx context.Context, req *MsgTransfer) (*MsgTransferResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Transfer not implemented")
-}
-
-func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
-	s.RegisterService(&_Msg_serviceDesc, srv)
-}
-
-func _Msg_ExecuteGovernanceVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgExecuteGovernanceVAA)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).ExecuteGovernanceVAA(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Msg/ExecuteGovernanceVAA",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).ExecuteGovernanceVAA(ctx, req.(*MsgExecuteGovernanceVAA))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Msg_ExecuteVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgExecuteVAA)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).ExecuteVAA(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Msg/ExecuteVAA",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).ExecuteVAA(ctx, req.(*MsgExecuteVAA))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Msg_AttestToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgAttestToken)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).AttestToken(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Msg/AttestToken",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).AttestToken(ctx, req.(*MsgAttestToken))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Msg_Transfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgTransfer)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).Transfer(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.tokenbridge.Msg/Transfer",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).Transfer(ctx, req.(*MsgTransfer))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Msg_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "certusone.wormholechain.tokenbridge.Msg",
-	HandlerType: (*MsgServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "ExecuteGovernanceVAA",
-			Handler:    _Msg_ExecuteGovernanceVAA_Handler,
-		},
-		{
-			MethodName: "ExecuteVAA",
-			Handler:    _Msg_ExecuteVAA_Handler,
-		},
-		{
-			MethodName: "AttestToken",
-			Handler:    _Msg_AttestToken_Handler,
-		},
-		{
-			MethodName: "Transfer",
-			Handler:    _Msg_Transfer_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "tokenbridge/tx.proto",
-}
-
-func (m *MsgExecuteGovernanceVAA) 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 *MsgExecuteGovernanceVAA) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteGovernanceVAA) 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] = 0x12
-	}
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) 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 *MsgExecuteGovernanceVAAResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgExecuteVAA) 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 *MsgExecuteVAA) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteVAA) 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] = 0x12
-	}
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgExecuteVAAResponse) 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 *MsgExecuteVAAResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteVAAResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgAttestToken) 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 *MsgAttestToken) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgAttestToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Denom) > 0 {
-		i -= len(m.Denom)
-		copy(dAtA[i:], m.Denom)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgAttestTokenResponse) 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 *MsgAttestTokenResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgAttestTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgTransfer) 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 *MsgTransfer) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintTx(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x2a
-	if len(m.ToAddress) > 0 {
-		i -= len(m.ToAddress)
-		copy(dAtA[i:], m.ToAddress)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddress)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if m.ToChain != 0 {
-		i = encodeVarintTx(dAtA, i, uint64(m.ToChain))
-		i--
-		dAtA[i] = 0x18
-	}
-	{
-		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintTx(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgTransferResponse) 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 *MsgTransferResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	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 *MsgExecuteGovernanceVAA) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Vaa)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *MsgExecuteVAA) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Vaa)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
-}
-
-func (m *MsgExecuteVAAResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *MsgAttestToken) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Denom)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
-}
-
-func (m *MsgAttestTokenResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *MsgTransfer) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = m.Amount.Size()
-	n += 1 + l + sovTx(uint64(l))
-	if m.ToChain != 0 {
-		n += 1 + sovTx(uint64(m.ToChain))
-	}
-	l = len(m.ToAddress)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = m.Fee.Size()
-	n += 1 + l + sovTx(uint64(l))
-	return n
-}
-
-func (m *MsgTransferResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func sovTx(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozTx(x uint64) (n int) {
-	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *MsgExecuteGovernanceVAA) 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: MsgExecuteGovernanceVAA: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteGovernanceVAA: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			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 *MsgExecuteGovernanceVAAResponse) 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: MsgExecuteGovernanceVAAResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteGovernanceVAAResponse: 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 *MsgExecuteVAA) 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: MsgExecuteVAA: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteVAA: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			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 *MsgExecuteVAAResponse) 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: MsgExecuteVAAResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteVAAResponse: 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 *MsgAttestToken) 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: MsgAttestToken: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgAttestToken: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = string(dAtA[iNdEx:postIndex])
-			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 *MsgAttestTokenResponse) 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: MsgAttestTokenResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgAttestTokenResponse: 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 *MsgTransfer) 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: MsgTransfer: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTx
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTx
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ToChain", wireType)
-			}
-			m.ToChain = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ToChain |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = append(m.ToAddress[:0], dAtA[iNdEx:postIndex]...)
-			if m.ToAddress == nil {
-				m.ToAddress = []byte{}
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTx
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTx
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			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 *MsgTransferResponse) 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: MsgTransferResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgTransferResponse: 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 skipTx(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowTx
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthTx
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupTx
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthTx
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/client/cli/genesis.go

@@ -0,0 +1,444 @@
+package cli
+
+import (
+	"crypto/ecdsa"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"io/ioutil"
+	"math/big"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/spf13/cobra"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	// "github.com/cosmos/cosmos-sdk/client/flags"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+)
+
+// normal vaa flags
+const FLAG_KEY = "key"
+const FLAG_EMITTER_CHAIN = "emitter-chain"
+const FLAG_INDEX = "index"
+const FLAG_SEQUENCE = "sequence"
+const FLAG_NONCE = "nonce"
+const FLAG_PAYLOAD = "payload"
+
+// governance vaa flags
+const FLAG_MODULE = "module"
+const FLAG_ACTION = "action"
+const FLAG_CHAIN = "chain"
+const FLAG_PUBLIC_KEY = "public-key"
+const FLAG_NEXT_INDEX = "next-index"
+
+// GetGenesisCmd returns the genesis related commands for this module
+func GetGenesisCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:                        "genesis",
+		Short:                      fmt.Sprintf("%s genesis subcommands", types.ModuleName),
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	cmd.AddCommand(CmdGenerateTestGuardianKey())
+	cmd.AddCommand(CmdDecodeAddress())
+	cmd.AddCommand(CmdGenerateVaa())
+	cmd.AddCommand(CmdGenerateGovernanceVaa())
+	cmd.AddCommand(CmdGenerateGuardianSetUpdatea())
+	cmd.AddCommand(CmdSignAddress())
+
+	return cmd
+}
+
+func CmdGenerateTestGuardianKey() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "generate-test-guardian-keypair [output-private-key.hex] [address.hex]",
+		Short: "Generate a guardian keypair for testing use",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			outPrivatePath := args[0]
+			outPublicPath := args[1]
+
+			// https://ethereum.org/en/developers/docs/accounts/#account-creation)
+
+			key, err := crypto.GenerateKey()
+			if err != nil {
+				return err
+			}
+			addr := crypto.PubkeyToAddress(key.PublicKey)
+			private_key := [32]byte{}
+			key.D.FillBytes(private_key[:])
+
+			err = ioutil.WriteFile(outPrivatePath, []byte(hex.EncodeToString(private_key[:])), 0644)
+			if err != nil {
+				return err
+			}
+			ioutil.WriteFile(outPublicPath, []byte(hex.EncodeToString(addr.Bytes())), 0644)
+			if err != nil {
+				return err
+			}
+			return nil
+		},
+	}
+
+	return cmd
+}
+
+func CmdDecodeAddress() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "decode-address [address]",
+		Short: "Decode an address from either account, validator, or evm format",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			addrString := args[0]
+			if strings.HasPrefix(addrString, sdk.GetConfig().GetBech32AccountAddrPrefix()) {
+				addr, err := sdk.AccAddressFromBech32(addrString)
+				if err != nil {
+					return nil
+				}
+				fmt.Println(base64.StdEncoding.EncodeToString(addr))
+			} else if strings.HasPrefix(addrString, sdk.GetConfig().GetBech32ValidatorAddrPrefix()) {
+				addr, err := sdk.AccAddressFromBech32(addrString)
+				if err != nil {
+					return nil
+				}
+				fmt.Println(base64.StdEncoding.EncodeToString(addr))
+			} else {
+				// treat as hex
+				addr, err := hex.DecodeString(strings.TrimPrefix(addrString, "0x"))
+				if err != nil {
+					return err
+				}
+				fmt.Println(base64.StdEncoding.EncodeToString(addr))
+			}
+
+			return nil
+		},
+	}
+
+	return cmd
+}
+
+func ImportKeyFromFile(filePath string) (*ecdsa.PrivateKey, error) {
+	priv := ecdsa.PrivateKey{}
+	bz, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return &priv, err
+	}
+	return ImportKeyFromHex(string(bz))
+}
+
+func ImportPublicKeyFromFile(filePath string) ([]byte, error) {
+	hexBz, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return []byte{}, err
+	}
+	hexStr := string(hexBz)
+	bz, err := hex.DecodeString(hexStr)
+	if err != nil {
+		return []byte{}, err
+	}
+	return bz, nil
+}
+
+func ImportKeyFromHex(privHex string) (*ecdsa.PrivateKey, error) {
+	priv := ecdsa.PrivateKey{}
+	priv_bz, err := hex.DecodeString(privHex)
+	if err != nil {
+		return &priv, err
+	}
+	k := big.NewInt(0)
+	k.SetBytes(priv_bz)
+
+	priv.PublicKey.Curve = crypto.S256()
+	priv.D = k
+	priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(k.Bytes())
+	return &priv, nil
+}
+
+func parseVaaFromFlags(cmd *cobra.Command) (vaa.VAA, error) {
+	var GOVERNANCE_EMITTER = [32]byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 04}
+
+	emitterChain, err := cmd.Flags().GetUint16(FLAG_EMITTER_CHAIN)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+	index, err := cmd.Flags().GetUint32(FLAG_INDEX)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+	nonce, err := cmd.Flags().GetUint32(FLAG_NONCE)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+	seq, err := cmd.Flags().GetUint64(FLAG_SEQUENCE)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+	payloadHex, err := cmd.Flags().GetString(FLAG_PAYLOAD)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+	payload, err := hex.DecodeString(payloadHex)
+	if err != nil {
+		return vaa.VAA{}, err
+	}
+
+	v := vaa.VAA{
+		Version:          uint8(1),
+		GuardianSetIndex: index,
+		Signatures:       nil,
+		Timestamp:        time.Now(),
+		Nonce:            nonce,
+		Sequence:         seq,
+		ConsistencyLevel: uint8(32),
+		EmitterChain:     vaa.ChainID(emitterChain),
+		EmitterAddress:   vaa.Address(GOVERNANCE_EMITTER),
+		Payload:          payload,
+	}
+	return v, nil
+
+}
+
+func addVaaFlags(cmd *cobra.Command) {
+	cmd.Flags().StringArray(FLAG_KEY, []string{}, "guardian private key file(s) to sign with (hex format) in order.")
+	cmd.Flags().Uint16(FLAG_EMITTER_CHAIN, 0, "emitter chain")
+	cmd.Flags().Uint32(FLAG_INDEX, 0, "guardian set index")
+	cmd.Flags().Uint64(FLAG_SEQUENCE, 0, "sequence number")
+	cmd.Flags().Uint32(FLAG_NONCE, 0, "nonce")
+	cmd.Flags().String(FLAG_PAYLOAD, "", "payload (hex format)")
+}
+func addGovVaaFlags(cmd *cobra.Command) {
+	cmd.Flags().String(FLAG_MODULE, "", "module (ascii string)")
+	cmd.Flags().Uint8(FLAG_ACTION, 0, "action")
+	cmd.Flags().Uint16(FLAG_CHAIN, 0, "chain")
+}
+
+func CmdGenerateVaa() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "generate-vaa",
+		Short: "generate and sign a vaa with any payload",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+
+			privateKeys := []*ecdsa.PrivateKey{}
+			privateKeysFiles, err := cmd.Flags().GetStringArray(FLAG_KEY)
+			if err != nil {
+				return err
+			}
+			for _, privFile := range privateKeysFiles {
+				priv, err := ImportKeyFromFile(privFile)
+				if err != nil {
+					return err
+				}
+				privateKeys = append(privateKeys, priv)
+			}
+			v, err := parseVaaFromFlags(cmd)
+			if err != nil {
+				return err
+			}
+			for i, key := range privateKeys {
+				v.AddSignature(key, uint8(i))
+			}
+
+			v_bz, err := v.Marshal()
+			if err != nil {
+				return err
+			}
+			fmt.Println(hex.EncodeToString(v_bz))
+
+			return nil
+		},
+	}
+	addVaaFlags(cmd)
+
+	return cmd
+}
+
+func CmdGenerateGovernanceVaa() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "generate-gov-vaa",
+		Short: "generate and sign a governance vaa with any payload",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+
+			privateKeys := []*ecdsa.PrivateKey{}
+			privateKeysFiles, err := cmd.Flags().GetStringArray(FLAG_KEY)
+			if err != nil {
+				return err
+			}
+			for _, privFile := range privateKeysFiles {
+				priv, err := ImportKeyFromFile(privFile)
+				if err != nil {
+					return err
+				}
+				privateKeys = append(privateKeys, priv)
+			}
+			v, err := parseVaaFromFlags(cmd)
+			if err != nil {
+				return err
+			}
+			gov_payload := v.Payload
+			moduleString, err := cmd.Flags().GetString(FLAG_MODULE)
+			if err != nil {
+				return err
+			}
+			action, err := cmd.Flags().GetUint8(FLAG_ACTION)
+			if err != nil {
+				return err
+			}
+			chain, err := cmd.Flags().GetUint16(FLAG_CHAIN)
+			if err != nil {
+				return err
+			}
+			module := [32]byte{}
+			copy(module[len(module)-len(moduleString):], []byte(moduleString))
+			msg := types.NewGovernanceMessage(module, action, chain, gov_payload)
+			v.Payload = msg.MarshalBinary()
+			v.EmitterChain = 1
+
+			for i, key := range privateKeys {
+				v.AddSignature(key, uint8(i))
+				// address := crypto.PubkeyToAddress(privateKeys[0].PublicKey)
+				// fmt.Println("signed using ", hex.EncodeToString(address[:]))
+			}
+
+			v_bz, err := v.Marshal()
+			if err != nil {
+				return err
+			}
+			fmt.Println(hex.EncodeToString(v_bz))
+
+			return nil
+		},
+	}
+
+	addVaaFlags(cmd)
+	addGovVaaFlags(cmd)
+
+	return cmd
+}
+
+func CmdGenerateGuardianSetUpdatea() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "generate-guardian-update-vaa",
+		Short: "generate and sign a governance vaa with any payload",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+
+			privateKeys := []*ecdsa.PrivateKey{}
+			privateKeysFiles, err := cmd.Flags().GetStringArray(FLAG_KEY)
+			if err != nil {
+				return err
+			}
+			for _, privFile := range privateKeysFiles {
+				priv, err := ImportKeyFromFile(privFile)
+				if err != nil {
+					return err
+				}
+				privateKeys = append(privateKeys, priv)
+			}
+			v, err := parseVaaFromFlags(cmd)
+			if err != nil {
+				return err
+			}
+			next_index, err := cmd.Flags().GetUint32(FLAG_NEXT_INDEX)
+			if err != nil {
+				return err
+			}
+
+			publicKeys := [][]byte{}
+			pubKeysFiles, err := cmd.Flags().GetStringArray(FLAG_PUBLIC_KEY)
+			if err != nil {
+				return err
+			}
+			for _, pubFile := range pubKeysFiles {
+				pubBz, err := ImportPublicKeyFromFile(pubFile)
+				if err != nil {
+					return err
+				}
+				publicKeys = append(publicKeys, pubBz)
+			}
+			set_update := make([]byte, 4)
+			binary.BigEndian.PutUint32(set_update, next_index)
+			set_update = append(set_update, uint8(len(pubKeysFiles)))
+			// Add keys to set_update
+			for _, pubkey := range publicKeys {
+				set_update = append(set_update, pubkey...)
+			}
+
+			action := keeper.ActionGuardianSetUpdate
+			chain := 3104
+			module := [32]byte{}
+			copy(module[:], vaa.CoreModule)
+			msg := types.NewGovernanceMessage(module, byte(action), uint16(chain), set_update)
+			v.Payload = msg.MarshalBinary()
+			v.EmitterChain = 1
+
+			for i, key := range privateKeys {
+				v.AddSignature(key, uint8(i))
+			}
+
+			v_bz, err := v.Marshal()
+			if err != nil {
+				return err
+			}
+			fmt.Println(hex.EncodeToString(v_bz))
+
+			return nil
+		},
+	}
+
+	addVaaFlags(cmd)
+	cmd.Flags().StringArray(FLAG_PUBLIC_KEY, []string{}, "guardian public key file(s) to include in new set (hex/evm format) in order.")
+	cmd.Flags().Uint32(FLAG_NEXT_INDEX, 0, "next guardian set index")
+
+	return cmd
+}
+
+func CmdSignAddress() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "sign-address",
+		Short: "sign the validator address to use for registering as a guardian.  read guardian key as hex in $GUARDIAN_KEY env variable. use --from to indicate address to sign.",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			info, err := clientCtx.Keyring.Key(clientCtx.From)
+			if err != nil {
+				return err
+			}
+
+			keyHex := os.Getenv("GUARDIAN_KEY")
+			key, err := ImportKeyFromHex(keyHex)
+			if err != nil {
+				return err
+			}
+			addr := info.GetAddress()
+			addrHash := crypto.Keccak256Hash(addr)
+			sig, err := crypto.Sign(addrHash[:], key)
+			if err != nil {
+				return err
+			}
+			fmt.Println(hex.EncodeToString(sig))
+
+			return nil
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

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

@@ -22,6 +22,8 @@ func GetTxCmd() *cobra.Command {
 
 	cmd.AddCommand(CmdExecuteGovernanceVAA())
 	cmd.AddCommand(CmdRegisterAccountAsGuardian())
+	cmd.AddCommand(CmdStoreCode())
+	cmd.AddCommand(CmdInstantiateContract())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

wormhole_chain/x/wormhole/client/cli/tx_wasmd.go

@@ -0,0 +1,151 @@
+package cli
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strconv"
+
+	"encoding/binary"
+	"encoding/hex"
+
+	"github.com/CosmWasm/wasmd/x/wasm/ioutils"
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/spf13/cast"
+	"github.com/spf13/cobra"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+	"golang.org/x/crypto/sha3"
+)
+
+var _ = strconv.Itoa(0)
+
+func parseStoreCodeArgs(file string, sender sdk.AccAddress, vaa []byte) (types.MsgStoreCode, error) {
+	wasm, err := ioutil.ReadFile(file)
+	if err != nil {
+		return types.MsgStoreCode{}, err
+	}
+
+	// gzip the wasm file
+	if ioutils.IsWasm(wasm) {
+		wasm, err = ioutils.GzipIt(wasm)
+
+		if err != nil {
+			return types.MsgStoreCode{}, err
+		}
+	} else if !ioutils.IsGzip(wasm) {
+		return types.MsgStoreCode{}, fmt.Errorf("invalid input file. Use wasm binary or gzip")
+	}
+	return types.MsgStoreCode{
+		Signer:       sender.String(),
+		WASMByteCode: wasm,
+		Vaa:          vaa,
+	}, nil
+}
+
+// StoreCodeCmd will upload code to be reused.
+func CmdStoreCode() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "store [wasm file] [vaa-hex]",
+		Short:   "Upload a wasm binary with vaa, or just compute the hash for vaa if [vaa-hex] is omitted",
+		Aliases: []string{"upload", "st", "s"},
+		Args:    cobra.RangeArgs(1, 2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			hash_only := len(args) == 1
+			vaaBz := []byte{}
+			if !hash_only {
+				vaaBz, err = hex.DecodeString(args[1])
+				if err != nil {
+					return err
+				}
+			}
+
+			msg, err := parseStoreCodeArgs(args[0], clientCtx.GetFromAddress(), vaaBz)
+			if err != nil {
+				return err
+			}
+
+			if !hash_only {
+				if err = msg.ValidateBasic(); err != nil {
+					return err
+				}
+				return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+			} else {
+				var hashWasm [32]byte
+				keccak := sha3.NewLegacyKeccak256()
+				keccak.Write(msg.WASMByteCode)
+				keccak.Sum(hashWasm[:0])
+				fmt.Println(hex.EncodeToString(hashWasm[:]))
+				return nil
+			}
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}
+
+func CmdInstantiateContract() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "instantiate [label] [code_id_int64] [json_encoded_init_args] [vaa-hex]",
+		Short: "Instantiate a wasmd contract, or just compute the hash for vaa if vaa is omitted",
+		Args:  cobra.RangeArgs(3, 4),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+			hash_only := len(args) == 3
+
+			labelStr := args[0]
+
+			codeId, err := cast.ToUint64E(args[1])
+			if err != nil {
+				return err
+			}
+
+			initMsg := args[2]
+
+			vaaBz := []byte{}
+			if !hash_only {
+				vaaBz, err = hex.DecodeString(args[3])
+				if err != nil {
+					return err
+				}
+			}
+
+			msg := types.MsgInstantiateContract{
+				Signer: clientCtx.GetFromAddress().String(),
+				CodeID: codeId,
+				Label:  labelStr,
+				Msg:    []byte(initMsg),
+				Vaa:    vaaBz,
+			}
+			if !hash_only {
+				if err := msg.ValidateBasic(); err != nil {
+					return err
+				}
+				return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), &msg)
+			} else {
+				var hash [32]byte
+				keccak := sha3.NewLegacyKeccak256()
+				binary.Write(keccak, binary.BigEndian, msg.CodeID)
+				keccak.Write([]byte(msg.Label))
+				keccak.Write([]byte(msg.Msg))
+				keccak.Sum(hash[:0])
+				fmt.Println(hex.EncodeToString(hash[:]))
+				return nil
+			}
+		},
+	}
+
+	cmd.Flags().String("label", "", "A human-readable name for this contract in lists")
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

wormhole_chain/x/wormhole/handler.go

@@ -23,6 +23,12 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgRegisterAccountAsGuardian:
 			res, err := msgServer.RegisterAccountAsGuardian(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgStoreCode:
+			res, err := msgServer.StoreCode(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgInstantiateContract:
+			res, err := msgServer.InstantiateContract(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 			// this line is used by starport scaffolding # 1
 		default:
 			errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)

wormhole_chain/x/wormhole/keeper/grpc_query_guardian_validator_test.go

@@ -21,7 +21,7 @@ var _ = strconv.IntSize
 func TestGuardianValidatorQuerySingle(t *testing.T) {
 	keeper, ctx := keepertest.WormholeKeeper(t)
 	wctx := sdk.WrapSDKContext(ctx)
-	msgs := createNGuardianValidator(keeper, ctx, 2)
+	msgs, _ := createNGuardianValidator(keeper, ctx, 2)
 	for _, tc := range []struct {
 		desc     string
 		request  *types.QueryGetGuardianValidatorRequest
@@ -71,7 +71,7 @@ func TestGuardianValidatorQuerySingle(t *testing.T) {
 func TestGuardianValidatorQueryPaginated(t *testing.T) {
 	keeper, ctx := keepertest.WormholeKeeper(t)
 	wctx := sdk.WrapSDKContext(ctx)
-	msgs := createNGuardianValidator(keeper, ctx, 5)
+	msgs, _ := createNGuardianValidator(keeper, ctx, 5)
 
 	request := func(next []byte, offset, limit uint64, total bool) *types.QueryAllGuardianValidatorRequest {
 		return &types.QueryAllGuardianValidatorRequest{

wormhole_chain/x/wormhole/keeper/guardian_validator_test.go

@@ -1,10 +1,12 @@
 package keeper_test
 
 import (
-	"strconv"
+	"crypto/ecdsa"
+	"crypto/rand"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/require"
 	keepertest "github.com/wormhole-foundation/wormhole-chain/testutil/keeper"
 	"github.com/wormhole-foundation/wormhole-chain/testutil/nullify"
@@ -12,22 +14,43 @@ import (
 	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
 )
 
-// Prevent strconv unused error
-var _ = strconv.IntSize
-
-func createNGuardianValidator(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.GuardianValidator {
+// Create N guardians and return both their public and private keys
+func createNGuardianValidator(keeper *keeper.Keeper, ctx sdk.Context, n int) ([]types.GuardianValidator, []*ecdsa.PrivateKey) {
 	items := make([]types.GuardianValidator, n)
+	privKeys := []*ecdsa.PrivateKey{}
 	for i := range items {
-		items[i].GuardianKey = []byte(strconv.Itoa(i))
+		privKey, err := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
+		if err != nil {
+			panic(err)
+		}
+		addr := crypto.PubkeyToAddress(privKey.PublicKey)
+		items[i].GuardianKey = addr[:]
+		privKeys = append(privKeys, privKey)
 
 		keeper.SetGuardianValidator(ctx, items[i])
 	}
-	return items
+	return items, privKeys
+}
+
+func createNewGuardianSet(keeper *keeper.Keeper, ctx sdk.Context, guardians []types.GuardianValidator) *types.GuardianSet {
+	next_index := keeper.GetGuardianSetCount(ctx)
+
+	guardianSet := &types.GuardianSet{
+		Index:          next_index,
+		Keys:           [][]byte{},
+		ExpirationTime: 0,
+	}
+	for _, guardian := range guardians {
+		guardianSet.Keys = append(guardianSet.Keys, guardian.GuardianKey)
+	}
+
+	keeper.AppendGuardianSet(ctx, *guardianSet)
+	return guardianSet
 }
 
 func TestGuardianValidatorGet(t *testing.T) {
 	keeper, ctx := keepertest.WormholeKeeper(t)
-	items := createNGuardianValidator(keeper, ctx, 10)
+	items, _ := createNGuardianValidator(keeper, ctx, 10)
 	for _, item := range items {
 		rst, found := keeper.GetGuardianValidator(ctx,
 			item.GuardianKey,
@@ -41,7 +64,7 @@ func TestGuardianValidatorGet(t *testing.T) {
 }
 func TestGuardianValidatorRemove(t *testing.T) {
 	keeper, ctx := keepertest.WormholeKeeper(t)
-	items := createNGuardianValidator(keeper, ctx, 10)
+	items, _ := createNGuardianValidator(keeper, ctx, 10)
 	for _, item := range items {
 		keeper.RemoveGuardianValidator(ctx,
 			item.GuardianKey,
@@ -55,7 +78,7 @@ func TestGuardianValidatorRemove(t *testing.T) {
 
 func TestGuardianValidatorGetAll(t *testing.T) {
 	keeper, ctx := keepertest.WormholeKeeper(t)
-	items := createNGuardianValidator(keeper, ctx, 10)
+	items, _ := createNGuardianValidator(keeper, ctx, 10)
 	require.ElementsMatch(t,
 		nullify.Fill(items),
 		nullify.Fill(keeper.GetAllGuardianValidator(ctx)),

wormhole_chain/x/wormhole/keeper/keeper.go

@@ -18,6 +18,8 @@ type (
 
 		accountKeeper types.AccountKeeper
 		bankKeeper    types.BankKeeper
+		wasmdKeeper   types.WasmdKeeper
+		setWasmd      bool
 	}
 )
 
@@ -37,6 +39,17 @@ func NewKeeper(
 	}
 }
 
+// This is necessary because x/staking relies on x/wormhole and x/wasmd relies on x/staking,
+// So we must either:
+// 1. make wormhole depend on staking and replace the modified functions from here.
+// 2. add a new module that wraps x/wasmd instead of using x/wormhole.
+// 3. (current) set wasmdKeeper late in init and use guards whenever it's referenced.
+// Opted for (3) as we only reference in two places.
+func (k *Keeper) SetWasmdKeeper(keeper types.WasmdKeeper) {
+	k.wasmdKeeper = keeper
+	k.setWasmd = true
+}
+
 func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 }

wormhole_chain/x/wormhole/keeper/msg_server_execute_governance_vaa.go

@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"bytes"
 	"context"
 	"encoding/binary"
 
@@ -13,6 +12,7 @@ import (
 type GovernanceAction uint8
 
 var (
+	ActionContractUpgrade   GovernanceAction = 1
 	ActionGuardianSetUpdate GovernanceAction = 2
 )
 
@@ -25,50 +25,16 @@ func (k msgServer) ExecuteGovernanceVAA(goCtx context.Context, msg *types.MsgExe
 		return nil, err
 	}
 
+	coreModule := [32]byte{}
+	copy(coreModule[:], vaa.CoreModule)
 	// Verify VAA
-	err = k.VerifyVAA(ctx, v)
+	action, payload, err := k.VerifyGovernanceVAA(ctx, v, coreModule)
 	if err != nil {
 		return nil, err
 	}
 
-	config, ok := k.GetConfig(ctx)
-	if !ok {
-		return nil, types.ErrNoConfig
-	}
-
-	_, known := k.GetReplayProtection(ctx, v.HexDigest())
-	if known {
-		return nil, types.ErrVAAAlreadyExecuted
-	}
-
-	// Check governance emitter
-	if !bytes.Equal(v.EmitterAddress[:], config.GovernanceEmitter) {
-		return nil, types.ErrInvalidGovernanceEmitter
-	}
-	if v.EmitterChain != vaa.ChainID(config.GovernanceChain) {
-		return nil, types.ErrInvalidGovernanceEmitter
-	}
-
-	if len(v.Payload) < 35 {
-		return nil, types.ErrGovernanceHeaderTooShort
-	}
-
-	// Check governance header
-	if !bytes.Equal(v.Payload[:32], vaa.CoreModule) {
-		return nil, types.ErrUnknownGovernanceModule
-	}
-
-	// Decode header
-	action := GovernanceAction(v.Payload[32])
-	chain := binary.BigEndian.Uint16(v.Payload[33:35])
-	payload := v.Payload[35:]
-
-	if chain != 0 && chain != uint16(config.ChainId) {
-		return nil, types.ErrInvalidGovernanceTargetChain
-	}
-
 	// Execute action
-	switch action {
+	switch GovernanceAction(action) {
 	case ActionGuardianSetUpdate:
 		if len(payload) < 5 {
 			return nil, types.ErrInvalidGovernancePayloadLength
@@ -105,8 +71,5 @@ func (k msgServer) ExecuteGovernanceVAA(goCtx context.Context, msg *types.MsgExe
 
 	}
 
-	// Prevent replay
-	k.SetReplayProtection(ctx, types.ReplayProtection{Index: v.HexDigest()})
-
 	return &types.MsgExecuteGovernanceVAAResponse{}, nil
 }

wormhole_chain/x/wormhole/keeper/msg_server_execute_governance_vaa_test.go

@@ -0,0 +1,109 @@
+package keeper_test
+
+import (
+	"crypto/ecdsa"
+	"encoding/binary"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
+	keepertest "github.com/wormhole-foundation/wormhole-chain/testutil/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+)
+
+func createExecuteGovernanceVaaPayload(k *keeper.Keeper, ctx sdk.Context, num_guardians byte) ([]byte, []*ecdsa.PrivateKey) {
+	guardians, privateKeys := createNGuardianValidator(k, ctx, int(num_guardians))
+	next_index := k.GetGuardianSetCount(ctx)
+	set_update := make([]byte, 4)
+	binary.BigEndian.PutUint32(set_update, next_index)
+	set_update = append(set_update, num_guardians)
+	// Add keys to set_update
+	for _, guardian := range guardians {
+		set_update = append(set_update, guardian.GuardianKey...)
+	}
+	// governance message with sha3 of wasmBytes as the payload
+	module := [32]byte{}
+	copy(module[:], vaa.CoreModule)
+	gov_msg := types.NewGovernanceMessage(module, byte(keeper.ActionGuardianSetUpdate), uint16(vaa.ChainIDWormchain), set_update)
+
+	return gov_msg.MarshalBinary(), privateKeys
+}
+
+func TestExecuteGovernanceVAA(t *testing.T) {
+	k, ctx := keepertest.WormholeKeeper(t)
+	guardians, privateKeys := createNGuardianValidator(k, ctx, 10)
+	_ = privateKeys
+	k.SetConfig(ctx, types.Config{
+		GovernanceEmitter:     vaa.GovernanceEmitter[:],
+		GovernanceChain:       uint32(vaa.GovernanceChain),
+		ChainId:               uint32(vaa.ChainIDWormchain),
+		GuardianSetExpiration: 86400,
+	})
+	signer_bz := [20]byte{}
+	signer := sdk.AccAddress(signer_bz[:])
+
+	set := createNewGuardianSet(k, ctx, guardians)
+	k.SetConsensusGuardianSetIndex(ctx, types.ConsensusGuardianSetIndex{Index: set.Index})
+
+	context := sdk.WrapSDKContext(ctx)
+	msgServer := keeper.NewMsgServerImpl(*k)
+
+	// create governance to update guardian set with extra guardian
+	payload, newPrivateKeys := createExecuteGovernanceVaaPayload(k, ctx, 11)
+	v := generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ := v.Marshal()
+	_, err := msgServer.ExecuteGovernanceVAA(context, &types.MsgExecuteGovernanceVAA{
+		Signer: signer.String(),
+		Vaa:    vBz,
+	})
+	assert.NoError(t, err)
+
+	// we should have a new set with 11 guardians now
+	new_index := k.GetLatestGuardianSetIndex(ctx)
+	assert.Equal(t, set.Index+1, new_index)
+	new_set, _ := k.GetGuardianSet(ctx, new_index)
+	assert.Len(t, new_set.Keys, 11)
+
+	// Submitting another change with the old set doesn't work
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.ExecuteGovernanceVAA(context, &types.MsgExecuteGovernanceVAA{
+		Signer: signer.String(),
+		Vaa:    vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrGuardianSetNotSequential)
+
+	// Invalid length
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload[:len(payload)-1])
+	vBz, _ = v.Marshal()
+	_, err = msgServer.ExecuteGovernanceVAA(context, &types.MsgExecuteGovernanceVAA{
+		Signer: signer.String(),
+		Vaa:    vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrInvalidGovernancePayloadLength)
+
+	// Include a guardian address twice in an update
+	payload_bad, _ := createExecuteGovernanceVaaPayload(k, ctx, 11)
+	copy(payload_bad[len(payload_bad)-20:], payload_bad[len(payload_bad)-40:len(payload_bad)-20])
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload_bad)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.ExecuteGovernanceVAA(context, &types.MsgExecuteGovernanceVAA{
+		Signer: signer.String(),
+		Vaa:    vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrDuplicateGuardianAddress)
+
+	// Change set again with new set update
+	payload, _ = createExecuteGovernanceVaaPayload(k, ctx, 12)
+	v = generateVaa(new_set.Index, newPrivateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.ExecuteGovernanceVAA(context, &types.MsgExecuteGovernanceVAA{
+		Signer: signer.String(),
+		Vaa:    vBz,
+	})
+	assert.NoError(t, err)
+	new_index2 := k.GetLatestGuardianSetIndex(ctx)
+	assert.Equal(t, new_set.Index+1, new_index2)
+}

wormhole_chain/x/wormhole/keeper/msg_server_wasmd.go

@@ -0,0 +1,127 @@
+package keeper
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+
+	wasmdtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+	"golang.org/x/crypto/sha3"
+)
+
+// WasmdModule is the identifier of the Wasmd module (which is used for governance messages)
+var WasmdModule = [32]byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0x57, 0x61, 0x73, 0x6D, 0x64, 0x4D, 0x6F, 0x64, 0x75, 0x6C, 0x65}
+
+var (
+	ActionStoreCode           GovernanceAction = 1
+	ActionInstantiateContract GovernanceAction = 2
+)
+
+// Simple wrapper of x/wasmd StoreCode that requires a VAA
+func (k msgServer) StoreCode(goCtx context.Context, msg *types.MsgStoreCode) (*types.MsgStoreCodeResponse, error) {
+	if !k.setWasmd {
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrNotSupported, "x/wasmd not set")
+	}
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// Parse VAA
+	v, err := ParseVAA(msg.Vaa)
+	if err != nil {
+		return nil, err
+	}
+	// Verify VAA
+	action, payload, err := k.VerifyGovernanceVAA(ctx, v, WasmdModule)
+	if err != nil {
+		return nil, err
+	}
+
+	if GovernanceAction(action) != ActionStoreCode {
+		return nil, types.ErrUnknownGovernanceAction
+	}
+
+	// verify payload is the sha3 256 hash of the wasm binary being uploaded
+	var expected_hash [32]byte
+	keccak := sha3.NewLegacyKeccak256()
+	keccak.Write(msg.WASMByteCode)
+	keccak.Sum(expected_hash[:0])
+	if !bytes.Equal(payload, expected_hash[:]) {
+		return nil, types.ErrInvalidHash
+	}
+	// Execute StoreCode normally
+	senderAddr, err := sdk.AccAddressFromBech32(msg.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, msg.Signer),
+	))
+	codeID, err := k.wasmdKeeper.Create(ctx, senderAddr, msg.WASMByteCode, &wasmdtypes.DefaultUploadAccess)
+	if err != nil {
+		return nil, err
+	}
+	return &types.MsgStoreCodeResponse{
+		CodeID: codeID,
+	}, nil
+}
+
+// Simple wrapper of x/wasmd InstantiateContract that requires a VAA
+func (k msgServer) InstantiateContract(goCtx context.Context, msg *types.MsgInstantiateContract) (*types.MsgInstantiateContractResponse, error) {
+	if !k.setWasmd {
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrNotSupported, "x/wasmd not set")
+	}
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// Parse VAA
+	v, err := ParseVAA(msg.Vaa)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify VAA
+	action, payload, err := k.VerifyGovernanceVAA(ctx, v, WasmdModule)
+	if err != nil {
+		return nil, err
+	}
+
+	if GovernanceAction(action) != ActionInstantiateContract {
+		return nil, types.ErrUnknownGovernanceAction
+	}
+
+	// Need to verify the msg contents by checking sha3.Sum(BigEndian(CodeID) || Label || Msg)
+	// The vaa governance payload must contain this hash.
+
+	var expected_hash [32]byte
+	keccak := sha3.NewLegacyKeccak256()
+	binary.Write(keccak, binary.BigEndian, msg.CodeID)
+	keccak.Write([]byte(msg.Label))
+	keccak.Write([]byte(msg.Msg))
+	keccak.Sum(expected_hash[:0])
+
+	if !bytes.Equal(payload, expected_hash[:]) {
+		return nil, types.ErrInvalidHash
+	}
+
+	// Execute Instantiate normally
+	senderAddr, err := sdk.AccAddressFromBech32(msg.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, msg.Signer),
+	))
+	contract_addr, data, err := k.wasmdKeeper.Instantiate(ctx, msg.CodeID, senderAddr, sdk.AccAddress{}, msg.Msg, msg.Label, sdk.Coins{})
+	if err != nil {
+		return nil, err
+	}
+	return &types.MsgInstantiateContractResponse{
+		Address: contract_addr.String(),
+		Data:    data,
+	}, nil
+}

wormhole_chain/x/wormhole/keeper/msg_server_wasmd_test.go

@@ -0,0 +1,229 @@
+package keeper_test
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/crypto/sha3"
+	keepertest "github.com/wormhole-foundation/wormhole-chain/testutil/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/keeper"
+	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
+	"github.com/wormhole-foundation/wormhole/sdk/vaa"
+)
+
+func createWasmStoreCodePayload(wasmBytes []byte) []byte {
+	// governance message with sha3 of wasmBytes as the payload
+	var hashWasm [32]byte
+	keccak := sha3.NewLegacyKeccak256()
+	keccak.Write(wasmBytes)
+	keccak.Sum(hashWasm[:0])
+
+	gov_msg := types.NewGovernanceMessage(keeper.WasmdModule, byte(keeper.ActionStoreCode), uint16(vaa.ChainIDWormchain), hashWasm[:])
+	return gov_msg.MarshalBinary()
+}
+
+func createWasmInstantiatePayload(code_id uint64, label string, json_msg string) []byte {
+	// governance message with sha3 of arguments to instantiate
+	// - code_id (big endian)
+	// - label
+	// - json_msg
+	var expected_hash [32]byte
+	keccak := sha3.NewLegacyKeccak256()
+	binary.Write(keccak, binary.BigEndian, code_id)
+	keccak.Write([]byte(label))
+	keccak.Write([]byte(json_msg))
+	keccak.Sum(expected_hash[:0])
+
+	var payload bytes.Buffer
+	payload.Write(keeper.WasmdModule[:])
+	payload.Write([]byte{byte(keeper.ActionInstantiateContract)})
+	binary.Write(&payload, binary.BigEndian, uint16(vaa.ChainIDWormchain))
+	// custom payload
+	payload.Write(expected_hash[:])
+	return payload.Bytes()
+}
+
+func TestWasmdStoreCode(t *testing.T) {
+	k, ctx := keepertest.WormholeKeeper(t)
+	guardians, privateKeys := createNGuardianValidator(k, ctx, 10)
+	_ = privateKeys
+	k.SetConfig(ctx, types.Config{
+		GovernanceEmitter:     vaa.GovernanceEmitter[:],
+		GovernanceChain:       uint32(vaa.GovernanceChain),
+		ChainId:               uint32(vaa.ChainIDWormchain),
+		GuardianSetExpiration: 86400,
+	})
+	signer_bz := [20]byte{}
+	signer := sdk.AccAddress(signer_bz[:])
+
+	set := createNewGuardianSet(k, ctx, guardians)
+
+	context := sdk.WrapSDKContext(ctx)
+	msgServer := keeper.NewMsgServerImpl(*k)
+
+	// create governance to store code
+	payload := createWasmStoreCodePayload(keepertest.EXAMPLE_WASM_CONTRACT_GZIP)
+	v := generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, err := v.Marshal()
+	assert.NoError(t, err)
+
+	// store code should work
+	res, err := msgServer.StoreCode(context, &types.MsgStoreCode{
+		Signer:       signer.String(),
+		WASMByteCode: keepertest.EXAMPLE_WASM_CONTRACT_GZIP,
+		Vaa:          vBz,
+	})
+	_ = res
+	assert.NoError(t, err)
+
+	// replay attack does not work.
+	_, err = msgServer.StoreCode(context, &types.MsgStoreCode{
+		Signer:       signer.String(),
+		WASMByteCode: keepertest.EXAMPLE_WASM_CONTRACT_GZIP,
+		Vaa:          vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrVAAAlreadyExecuted)
+
+	// modified wasm byte code does not verify
+	bad_wasm := make([]byte, len(keepertest.EXAMPLE_WASM_CONTRACT_GZIP))
+	copy(bad_wasm, keepertest.EXAMPLE_WASM_CONTRACT_GZIP)
+	bad_wasm[100] = bad_wasm[100] ^ 0x40
+	// create vaa with the hash of the "valid" wasm
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.StoreCode(context, &types.MsgStoreCode{
+		Signer:       signer.String(),
+		WASMByteCode: bad_wasm,
+		Vaa:          vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrInvalidHash)
+
+	// Sending to wrong module is error
+	payload_wrong_module := createWasmStoreCodePayload(keepertest.EXAMPLE_WASM_CONTRACT_GZIP)
+	// tamper with the module id
+	payload_wrong_module[16] = 0xff
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload_wrong_module)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.StoreCode(context, &types.MsgStoreCode{
+		Signer:       signer.String(),
+		WASMByteCode: bad_wasm,
+		Vaa:          vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrUnknownGovernanceModule)
+}
+
+func TestWasmdInstantiateContract(t *testing.T) {
+	k, ctx := keepertest.WormholeKeeper(t)
+	guardians, privateKeys := createNGuardianValidator(k, ctx, 10)
+	_ = privateKeys
+	k.SetConfig(ctx, types.Config{
+		GovernanceEmitter:     vaa.GovernanceEmitter[:],
+		GovernanceChain:       uint32(vaa.GovernanceChain),
+		ChainId:               uint32(vaa.ChainIDWormchain),
+		GuardianSetExpiration: 86400,
+	})
+	signer_bz := [20]byte{}
+	signer := sdk.AccAddress(signer_bz[:])
+
+	set := createNewGuardianSet(k, ctx, guardians)
+
+	context := sdk.WrapSDKContext(ctx)
+	msgServer := keeper.NewMsgServerImpl(*k)
+
+	// First we need to upload code that we can instantiate.
+	payload := createWasmStoreCodePayload(keepertest.EXAMPLE_WASM_CONTRACT_GZIP)
+	v := generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, err := v.Marshal()
+	assert.NoError(t, err)
+	res, err := msgServer.StoreCode(context, &types.MsgStoreCode{
+		Signer:       signer.String(),
+		WASMByteCode: keepertest.EXAMPLE_WASM_CONTRACT_GZIP,
+		Vaa:          vBz,
+	})
+	assert.NoError(t, err)
+
+	code_id := res.CodeID
+
+	// Now that we have a code_id, we can test instantiating it.
+	payload = createWasmInstantiatePayload(code_id, "btc", "{}")
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id,
+		Label:  "btc",
+		Msg:    []byte("{}"),
+		Vaa:    vBz,
+	})
+	require.NoError(t, err)
+
+	// Test instantiating with invalid json fails
+	payload = createWasmInstantiatePayload(code_id, "btc", "{")
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id,
+		Label:  "btc",
+		Msg:    []byte("{"),
+		Vaa:    vBz,
+	})
+	require.Error(t, err)
+
+	// Test that tampering with either code_id, label, or msg fails vaa check
+	payload = createWasmInstantiatePayload(code_id, "btc", "{}")
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id + 1,
+		Label:  "btc",
+		Msg:    []byte("{}"),
+		Vaa:    vBz,
+	})
+	// Bad code_id
+	assert.ErrorIs(t, err, types.ErrInvalidHash)
+
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id,
+		Label:  "btc_bad",
+		Msg:    []byte("{}"),
+		Vaa:    vBz,
+	})
+	// Bad label
+	assert.ErrorIs(t, err, types.ErrInvalidHash)
+
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id,
+		Label:  "btc",
+		Msg:    []byte("{\"arg\":\"bad\"}"),
+		Vaa:    vBz,
+	})
+	// Bad msg
+	assert.ErrorIs(t, err, types.ErrInvalidHash)
+
+	// Sending to wrong module is error
+	payload_wrong_module := createWasmInstantiatePayload(code_id, "btc", "{}")
+	// tamper with the module id
+	payload_wrong_module[16] = 0xff
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload_wrong_module)
+	vBz, _ = v.Marshal()
+	_, err = msgServer.InstantiateContract(context, &types.MsgInstantiateContract{
+		Signer: signer.String(),
+		CodeID: code_id,
+		Label:  "btc",
+		Msg:    []byte("{\"arg\":\"bad\"}"),
+		Vaa:    vBz,
+	})
+	assert.ErrorIs(t, err, types.ErrUnknownGovernanceModule)
+}

wormhole_chain/x/wormhole/keeper/vaa.go

@@ -1,6 +1,9 @@
 package keeper
 
 import (
+	"bytes"
+	"encoding/binary"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/wormhole-foundation/wormhole-chain/x/wormhole/types"
 	"github.com/wormhole-foundation/wormhole/sdk/vaa"
@@ -47,3 +50,59 @@ func (k Keeper) VerifyVAA(ctx sdk.Context, vaa *vaa.VAA) error {
 
 	return nil
 }
+
+// Verify a governance VAA:
+// - Check signatures
+// - Replay protection
+// - Check the source chain and address is governance
+// - Check the governance payload is for wormchain and the specified module
+// - return the parsed action and governance payload
+func (k Keeper) VerifyGovernanceVAA(ctx sdk.Context, v *vaa.VAA, module [32]byte) (action byte, payload []byte, err error) {
+	if err = k.VerifyVAA(ctx, v); err != nil {
+		return
+	}
+	_, known := k.GetReplayProtection(ctx, v.HexDigest())
+	if known {
+		err = types.ErrVAAAlreadyExecuted
+		return
+	}
+	// Prevent replay
+	k.SetReplayProtection(ctx, types.ReplayProtection{Index: v.HexDigest()})
+
+	config, ok := k.GetConfig(ctx)
+	if !ok {
+		err = types.ErrNoConfig
+		return
+	}
+
+	if !bytes.Equal(v.EmitterAddress[:], config.GovernanceEmitter) {
+		err = types.ErrInvalidGovernanceEmitter
+		return
+	}
+	if v.EmitterChain != vaa.ChainID(config.GovernanceChain) {
+		err = types.ErrInvalidGovernanceEmitter
+		return
+	}
+	if len(v.Payload) < 35 {
+		err = types.ErrGovernanceHeaderTooShort
+		return
+	}
+
+	// Check governance header
+	if !bytes.Equal(v.Payload[:32], module[:]) {
+		err = types.ErrUnknownGovernanceModule
+		return
+	}
+
+	// Decode header
+	action = v.Payload[32]
+	chain := binary.BigEndian.Uint16(v.Payload[33:35])
+	payload = v.Payload[35:]
+
+	if chain != 0 && chain != uint16(config.ChainId) {
+		err = types.ErrInvalidGovernanceTargetChain
+		return
+	}
+
+	return
+}

wormhole_chain/x/wormhole/keeper/vaa_test.go

@@ -3,6 +3,7 @@ package keeper_test
 import (
 	"crypto/ecdsa"
 	"crypto/rand"
+	"encoding/binary"
 	"fmt"
 	"testing"
 	"time"
@@ -43,26 +44,38 @@ func TestCalculateQuorum(t *testing.T) {
 	}
 }
 
-func getVaa() vaa.VAA {
-	var payload = []byte{97, 97, 97, 97, 97, 97}
-	var governanceEmitter = vaa.Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}
+var lastestSequence = 1
 
-	return vaa.VAA{
+func generateVaa(index uint32, signers []*ecdsa.PrivateKey, emitterChain vaa.ChainID, payload []byte) vaa.VAA {
+	v := vaa.VAA{
 		Version:          uint8(1),
-		GuardianSetIndex: uint32(0),
+		GuardianSetIndex: index,
 		Signatures:       nil,
 		Timestamp:        time.Unix(0, 0),
 		Nonce:            uint32(1),
-		Sequence:         uint64(1),
+		Sequence:         uint64(lastestSequence),
 		ConsistencyLevel: uint8(32),
 		EmitterChain:     vaa.ChainIDSolana,
-		EmitterAddress:   governanceEmitter,
+		EmitterAddress:   vaa.Address(vaa.GovernanceEmitter),
 		Payload:          payload,
 	}
+	lastestSequence = lastestSequence + 1
+	for i, key := range signers {
+		v.AddSignature(key, uint8(i))
+	}
+	return v
+}
+func resignVaa(v vaa.VAA, signers []*ecdsa.PrivateKey) vaa.VAA {
+	v.Signatures = []*vaa.Signature{}
+	for i, key := range signers {
+		v.AddSignature(key, uint8(i))
+	}
+	return v
 }
 
 func TestVerifyVAA(t *testing.T) {
 
+	payload := []byte{97, 97, 97, 97, 97, 97}
 	privKey1, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
 	privKey2, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
 
@@ -95,11 +108,7 @@ func TestVerifyVAA(t *testing.T) {
 	for _, tc := range tests {
 		t.Run(tc.label, func(t *testing.T) {
 			keeper, ctx := keepertest.WormholeKeeper(t)
-			vaa := getVaa()
-
-			for i, key := range tc.signers {
-				vaa.AddSignature(key, uint8(i))
-			}
+			vaa := generateVaa(tc.guardianSet.Index, tc.signers, vaa.ChainIDSolana, payload)
 
 			keeper.AppendGuardianSet(ctx, tc.guardianSet)
 			err := keeper.VerifyVAA(ctx, &vaa)
@@ -112,3 +121,97 @@ func TestVerifyVAA(t *testing.T) {
 		})
 	}
 }
+
+func TestVerifyVAA2(t *testing.T) {
+	keeper, ctx := keepertest.WormholeKeeper(t)
+	guardians, privateKeys := createNGuardianValidator(keeper, ctx, 25)
+	set := createNewGuardianSet(keeper, ctx, guardians)
+
+	// check verify works
+	payload := []byte{97, 97, 97, 97, 97, 97}
+	v := generateVaa(set.Index, privateKeys, vaa.ChainIDSolana, payload)
+	err := keeper.VerifyVAA(ctx, &v)
+	assert.NoError(t, err)
+
+	// flip a bit in one of the signatures
+	v = generateVaa(set.Index, privateKeys, vaa.ChainIDSolana, payload)
+	v.Signatures[20].Signature[1] = v.Signatures[20].Signature[1] ^ 0x40
+	err = keeper.VerifyVAA(ctx, &v)
+	assert.Error(t, err)
+
+	// generate for a non existing guardian set
+	v = generateVaa(set.Index+1, privateKeys, vaa.ChainIDSolana, payload)
+	err = keeper.VerifyVAA(ctx, &v)
+	assert.Error(t, err)
+}
+
+func TestVerifyVAAGovernance(t *testing.T) {
+	keeper, ctx := keepertest.WormholeKeeper(t)
+	guardians, privateKeys := createNGuardianValidator(keeper, ctx, 25)
+	set := createNewGuardianSet(keeper, ctx, guardians)
+	config := types.Config{
+		GovernanceEmitter:     vaa.GovernanceEmitter[:],
+		GovernanceChain:       uint32(vaa.GovernanceChain),
+		ChainId:               uint32(vaa.ChainIDWormchain),
+		GuardianSetExpiration: 86400,
+	}
+	keeper.SetConfig(ctx, config)
+
+	action := byte(0x12)
+	our_module := [32]byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 01}
+	payload := []byte{}
+	// governance payload is {module_id, action, chain, payload}
+	payload = append(payload, our_module[:]...)
+	payload = append(payload, action)
+	chain_bz := [2]byte{}
+	binary.BigEndian.PutUint16(chain_bz[:], uint16(vaa.ChainIDWormchain))
+	payload = append(payload, chain_bz[:]...)
+	// custom payload
+	custom_payload := []byte{1, 2, 3, 4, 5}
+	payload = append(payload, custom_payload...)
+
+	v := generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	err := keeper.VerifyVAA(ctx, &v)
+	assert.NoError(t, err)
+	parsed_action, parsed_payload, err := keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.NoError(t, err)
+	assert.Equal(t, action, parsed_action)
+	assert.Equal(t, custom_payload, parsed_payload)
+
+	// verifying a second time will return error because of replay protection
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.ErrorIs(t, err, types.ErrVAAAlreadyExecuted)
+
+	// Expect error if module-id is different
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	bad_module := [32]byte{}
+	bad_module[31] = 0xff
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, bad_module)
+	assert.ErrorIs(t, err, types.ErrUnknownGovernanceModule)
+
+	// Expect error if we're not using the right governance emitter address
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	v.EmitterAddress[5] = 0xff
+	v = resignVaa(v, privateKeys)
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.ErrorIs(t, err, types.ErrInvalidGovernanceEmitter)
+
+	// Expect error if we're not using the right governance emitter chain
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	v.EmitterChain = vaa.ChainIDEthereum
+	v = resignVaa(v, privateKeys)
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.ErrorIs(t, err, types.ErrInvalidGovernanceEmitter)
+
+	// Expect error if we're using a small payload
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload[:34])
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.ErrorIs(t, err, types.ErrGovernanceHeaderTooShort)
+
+	// Expect error if we're using a different target chain
+	payload[33] = 0xff
+	payload[34] = 0xff
+	v = generateVaa(set.Index, privateKeys, vaa.ChainID(vaa.GovernanceChain), payload)
+	_, _, err = keeper.VerifyGovernanceVAA(ctx, &v, our_module)
+	assert.ErrorIs(t, err, types.ErrInvalidGovernanceTargetChain)
+}

wormhole_chain/x/wormhole/types/codec.go

@@ -11,12 +11,16 @@ import (
 func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgExecuteGovernanceVAA{}, "wormhole/ExecuteGovernanceVAA", nil)
 	cdc.RegisterConcrete(&MsgRegisterAccountAsGuardian{}, "wormhole/RegisterAccountAsGuardian", nil)
+	cdc.RegisterConcrete(&MsgStoreCode{}, "wormhole/StoreCode", nil)
+	cdc.RegisterConcrete(&MsgInstantiateContract{}, "wormhole/InstantiateContract", nil)
 	// this line is used by starport scaffolding # 2
 }
 
 func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 	registry.RegisterImplementations((*sdk.Msg)(nil),
 		&MsgExecuteGovernanceVAA{},
+		&MsgStoreCode{},
+		&MsgInstantiateContract{},
 	)
 	registry.RegisterImplementations((*gov.Content)(nil),
 		&GovernanceWormholeMessageProposal{},

wormhole_chain/x/wormhole/types/config.pb.go

@@ -1,430 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/config.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type Config struct {
-	GuardianSetExpiration uint64 `protobuf:"varint,1,opt,name=guardian_set_expiration,json=guardianSetExpiration,proto3" json:"guardian_set_expiration,omitempty"`
-	GovernanceEmitter     []byte `protobuf:"bytes,2,opt,name=governance_emitter,json=governanceEmitter,proto3" json:"governance_emitter,omitempty"`
-	GovernanceChain       uint32 `protobuf:"varint,3,opt,name=governance_chain,json=governanceChain,proto3" json:"governance_chain,omitempty"`
-	ChainId               uint32 `protobuf:"varint,4,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
-}
-
-func (m *Config) Reset()         { *m = Config{} }
-func (m *Config) String() string { return proto.CompactTextString(m) }
-func (*Config) ProtoMessage()    {}
-func (*Config) Descriptor() ([]byte, []int) {
-	return fileDescriptor_14d08d38823c924a, []int{0}
-}
-func (m *Config) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Config.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 *Config) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Config.Merge(m, src)
-}
-func (m *Config) XXX_Size() int {
-	return m.Size()
-}
-func (m *Config) XXX_DiscardUnknown() {
-	xxx_messageInfo_Config.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Config proto.InternalMessageInfo
-
-func (m *Config) GetGuardianSetExpiration() uint64 {
-	if m != nil {
-		return m.GuardianSetExpiration
-	}
-	return 0
-}
-
-func (m *Config) GetGovernanceEmitter() []byte {
-	if m != nil {
-		return m.GovernanceEmitter
-	}
-	return nil
-}
-
-func (m *Config) GetGovernanceChain() uint32 {
-	if m != nil {
-		return m.GovernanceChain
-	}
-	return 0
-}
-
-func (m *Config) GetChainId() uint32 {
-	if m != nil {
-		return m.ChainId
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*Config)(nil), "certusone.wormholechain.wormhole.Config")
-}
-
-func init() { proto.RegisterFile("wormhole/config.proto", fileDescriptor_14d08d38823c924a) }
-
-var fileDescriptor_14d08d38823c924a = []byte{
-	// 269 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0x31, 0x4e, 0xc3, 0x30,
-	0x14, 0x86, 0x63, 0xa8, 0x0a, 0xb2, 0x40, 0x80, 0x45, 0x45, 0x60, 0xb0, 0x22, 0xa6, 0x30, 0x34,
-	0x1e, 0x40, 0x1c, 0x80, 0xaa, 0x03, 0x0b, 0x43, 0xd8, 0x58, 0xa2, 0x34, 0x79, 0x38, 0x96, 0x88,
-	0x5f, 0xe4, 0x38, 0x50, 0x6e, 0xc1, 0x65, 0xb8, 0x03, 0x63, 0x47, 0x46, 0x94, 0x5c, 0x04, 0xd5,
-	0x55, 0xd2, 0x6e, 0x7e, 0xff, 0xf7, 0xf9, 0xe9, 0xe9, 0xa7, 0x93, 0x0f, 0x34, 0x65, 0x81, 0x6f,
-	0x20, 0x32, 0xd4, 0xaf, 0x4a, 0x46, 0x95, 0x41, 0x8b, 0x2c, 0xc8, 0xc0, 0xd8, 0xa6, 0x46, 0x0d,
-	0x51, 0x2f, 0x64, 0x45, 0xaa, 0xf4, 0x30, 0x5d, 0x9d, 0x4b, 0x94, 0xe8, 0x64, 0xb1, 0x7e, 0x6d,
-	0xfe, 0x5d, 0x7f, 0x13, 0x3a, 0x9e, 0xb9, 0x45, 0xec, 0x9e, 0x5e, 0xc8, 0x26, 0x35, 0xb9, 0x4a,
-	0x75, 0x52, 0x83, 0x4d, 0x60, 0x59, 0x29, 0x93, 0x5a, 0x85, 0xda, 0x27, 0x01, 0x09, 0x47, 0xf1,
-	0xa4, 0xc7, 0xcf, 0x60, 0xe7, 0x03, 0x64, 0x53, 0xca, 0x24, 0xbe, 0x83, 0xd1, 0xa9, 0xce, 0x20,
-	0x81, 0x52, 0x59, 0x0b, 0xc6, 0xdf, 0x0b, 0x48, 0x78, 0x14, 0x9f, 0x6d, 0xc9, 0x7c, 0x03, 0xd8,
-	0x0d, 0x3d, 0xdd, 0xd1, 0xdd, 0x91, 0xfe, 0x7e, 0x40, 0xc2, 0xe3, 0xf8, 0x64, 0x9b, 0xcf, 0xd6,
-	0x31, 0xbb, 0xa4, 0x87, 0x8e, 0x27, 0x2a, 0xf7, 0x47, 0x4e, 0x39, 0x70, 0xf3, 0x63, 0xfe, 0xf0,
-	0xf4, 0xd3, 0x72, 0xb2, 0x6a, 0x39, 0xf9, 0x6b, 0x39, 0xf9, 0xea, 0xb8, 0xb7, 0xea, 0xb8, 0xf7,
-	0xdb, 0x71, 0xef, 0xe5, 0x4e, 0x2a, 0x5b, 0x34, 0x8b, 0x28, 0xc3, 0x52, 0x0c, 0xa5, 0x88, 0xbe,
-	0x86, 0xa9, 0x5b, 0x20, 0x96, 0x43, 0x20, 0xec, 0x67, 0x05, 0xf5, 0x62, 0xec, 0xea, 0xb8, 0xfd,
-	0x0f, 0x00, 0x00, 0xff, 0xff, 0x61, 0xcb, 0x83, 0x1f, 0x5f, 0x01, 0x00, 0x00,
-}
-
-func (m *Config) 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 *Config) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.ChainId != 0 {
-		i = encodeVarintConfig(dAtA, i, uint64(m.ChainId))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.GovernanceChain != 0 {
-		i = encodeVarintConfig(dAtA, i, uint64(m.GovernanceChain))
-		i--
-		dAtA[i] = 0x18
-	}
-	if len(m.GovernanceEmitter) > 0 {
-		i -= len(m.GovernanceEmitter)
-		copy(dAtA[i:], m.GovernanceEmitter)
-		i = encodeVarintConfig(dAtA, i, uint64(len(m.GovernanceEmitter)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.GuardianSetExpiration != 0 {
-		i = encodeVarintConfig(dAtA, i, uint64(m.GuardianSetExpiration))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
-	offset -= sovConfig(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *Config) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.GuardianSetExpiration != 0 {
-		n += 1 + sovConfig(uint64(m.GuardianSetExpiration))
-	}
-	l = len(m.GovernanceEmitter)
-	if l > 0 {
-		n += 1 + l + sovConfig(uint64(l))
-	}
-	if m.GovernanceChain != 0 {
-		n += 1 + sovConfig(uint64(m.GovernanceChain))
-	}
-	if m.ChainId != 0 {
-		n += 1 + sovConfig(uint64(m.ChainId))
-	}
-	return n
-}
-
-func sovConfig(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozConfig(x uint64) (n int) {
-	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *Config) 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 ErrIntOverflowConfig
-			}
-			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: Config: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianSetExpiration", wireType)
-			}
-			m.GuardianSetExpiration = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.GuardianSetExpiration |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GovernanceEmitter", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthConfig
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthConfig
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.GovernanceEmitter = append(m.GovernanceEmitter[:0], dAtA[iNdEx:postIndex]...)
-			if m.GovernanceEmitter == nil {
-				m.GovernanceEmitter = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GovernanceChain", wireType)
-			}
-			m.GovernanceChain = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.GovernanceChain |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
-			}
-			m.ChainId = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ChainId |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipConfig(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthConfig
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipConfig(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowConfig
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConfig
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthConfig
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupConfig
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthConfig
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthConfig        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowConfig          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/consensus_guardian_set_index.pb.go

@@ -1,303 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/consensus_guardian_set_index.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type ConsensusGuardianSetIndex struct {
-	Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *ConsensusGuardianSetIndex) Reset()         { *m = ConsensusGuardianSetIndex{} }
-func (m *ConsensusGuardianSetIndex) String() string { return proto.CompactTextString(m) }
-func (*ConsensusGuardianSetIndex) ProtoMessage()    {}
-func (*ConsensusGuardianSetIndex) Descriptor() ([]byte, []int) {
-	return fileDescriptor_18e45d0c16ad5fce, []int{0}
-}
-func (m *ConsensusGuardianSetIndex) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ConsensusGuardianSetIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ConsensusGuardianSetIndex.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 *ConsensusGuardianSetIndex) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ConsensusGuardianSetIndex.Merge(m, src)
-}
-func (m *ConsensusGuardianSetIndex) XXX_Size() int {
-	return m.Size()
-}
-func (m *ConsensusGuardianSetIndex) XXX_DiscardUnknown() {
-	xxx_messageInfo_ConsensusGuardianSetIndex.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ConsensusGuardianSetIndex proto.InternalMessageInfo
-
-func (m *ConsensusGuardianSetIndex) GetIndex() uint32 {
-	if m != nil {
-		return m.Index
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*ConsensusGuardianSetIndex)(nil), "certusone.wormholechain.wormhole.ConsensusGuardianSetIndex")
-}
-
-func init() {
-	proto.RegisterFile("wormhole/consensus_guardian_set_index.proto", fileDescriptor_18e45d0c16ad5fce)
-}
-
-var fileDescriptor_18e45d0c16ad5fce = []byte{
-	// 185 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2e, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x4e, 0xcd, 0x2b, 0x2e, 0x2d, 0x8e, 0x4f,
-	0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4e, 0x2d, 0x89, 0xcf, 0xcc, 0x4b, 0x49,
-	0xad, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48, 0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce,
-	0xcf, 0x4b, 0xd5, 0x83, 0x69, 0x4b, 0xce, 0x48, 0xcc, 0xcc, 0x83, 0xf3, 0x94, 0x0c, 0xb9, 0x24,
-	0x9d, 0x61, 0xe6, 0xb8, 0x43, 0x8d, 0x09, 0x4e, 0x2d, 0xf1, 0x04, 0x19, 0x22, 0x24, 0xc2, 0xc5,
-	0x0a, 0x36, 0x4d, 0x82, 0x51, 0x81, 0x51, 0x83, 0x37, 0x08, 0xc2, 0x71, 0xf2, 0x3b, 0xf1, 0x48,
-	0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0,
-	0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x93, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd,
-	0xe4, 0xfc, 0x5c, 0x7d, 0xb8, 0xcd, 0xfa, 0x30, 0xbb, 0x74, 0xc1, 0x56, 0xeb, 0x57, 0xc0, 0x05,
-	0xf4, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x6e, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
-	0xff, 0x06, 0xd1, 0x4d, 0x03, 0xda, 0x00, 0x00, 0x00,
-}
-
-func (m *ConsensusGuardianSetIndex) 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 *ConsensusGuardianSetIndex) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ConsensusGuardianSetIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Index != 0 {
-		i = encodeVarintConsensusGuardianSetIndex(dAtA, i, uint64(m.Index))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintConsensusGuardianSetIndex(dAtA []byte, offset int, v uint64) int {
-	offset -= sovConsensusGuardianSetIndex(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *ConsensusGuardianSetIndex) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Index != 0 {
-		n += 1 + sovConsensusGuardianSetIndex(uint64(m.Index))
-	}
-	return n
-}
-
-func sovConsensusGuardianSetIndex(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozConsensusGuardianSetIndex(x uint64) (n int) {
-	return sovConsensusGuardianSetIndex(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *ConsensusGuardianSetIndex) 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 ErrIntOverflowConsensusGuardianSetIndex
-			}
-			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: ConsensusGuardianSetIndex: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ConsensusGuardianSetIndex: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			m.Index = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConsensusGuardianSetIndex
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Index |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipConsensusGuardianSetIndex(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthConsensusGuardianSetIndex
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipConsensusGuardianSetIndex(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowConsensusGuardianSetIndex
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConsensusGuardianSetIndex
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowConsensusGuardianSetIndex
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthConsensusGuardianSetIndex
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupConsensusGuardianSetIndex
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthConsensusGuardianSetIndex
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthConsensusGuardianSetIndex        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowConsensusGuardianSetIndex          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupConsensusGuardianSetIndex = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/errors.go

@@ -29,4 +29,5 @@ var (
 	ErrDuplicateGuardianAddress       = sdkerrors.Register(ModuleName, 1120, "guardian set has duplicate addresses")
 	ErrSignerAlreadyRegistered        = sdkerrors.Register(ModuleName, 1121, "transaction signer already registered as a guardian validator")
 	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")
 )

wormhole_chain/x/wormhole/types/events.pb.go

@@ -1,1090 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/events.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type EventGuardianSetUpdate struct {
-	OldIndex uint32 `protobuf:"varint,1,opt,name=old_index,json=oldIndex,proto3" json:"old_index,omitempty"`
-	NewIndex uint32 `protobuf:"varint,2,opt,name=new_index,json=newIndex,proto3" json:"new_index,omitempty"`
-}
-
-func (m *EventGuardianSetUpdate) Reset()         { *m = EventGuardianSetUpdate{} }
-func (m *EventGuardianSetUpdate) String() string { return proto.CompactTextString(m) }
-func (*EventGuardianSetUpdate) ProtoMessage()    {}
-func (*EventGuardianSetUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_486bfc4df1202b88, []int{0}
-}
-func (m *EventGuardianSetUpdate) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventGuardianSetUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventGuardianSetUpdate.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 *EventGuardianSetUpdate) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventGuardianSetUpdate.Merge(m, src)
-}
-func (m *EventGuardianSetUpdate) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventGuardianSetUpdate) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventGuardianSetUpdate.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventGuardianSetUpdate proto.InternalMessageInfo
-
-func (m *EventGuardianSetUpdate) GetOldIndex() uint32 {
-	if m != nil {
-		return m.OldIndex
-	}
-	return 0
-}
-
-func (m *EventGuardianSetUpdate) GetNewIndex() uint32 {
-	if m != nil {
-		return m.NewIndex
-	}
-	return 0
-}
-
-type EventPostedMessage struct {
-	Emitter  []byte `protobuf:"bytes,1,opt,name=emitter,proto3" json:"emitter,omitempty"`
-	Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
-	Nonce    uint32 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
-	Time     uint64 `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"`
-	Payload  []byte `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"`
-}
-
-func (m *EventPostedMessage) Reset()         { *m = EventPostedMessage{} }
-func (m *EventPostedMessage) String() string { return proto.CompactTextString(m) }
-func (*EventPostedMessage) ProtoMessage()    {}
-func (*EventPostedMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_486bfc4df1202b88, []int{1}
-}
-func (m *EventPostedMessage) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventPostedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventPostedMessage.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 *EventPostedMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventPostedMessage.Merge(m, src)
-}
-func (m *EventPostedMessage) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventPostedMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventPostedMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventPostedMessage proto.InternalMessageInfo
-
-func (m *EventPostedMessage) GetEmitter() []byte {
-	if m != nil {
-		return m.Emitter
-	}
-	return nil
-}
-
-func (m *EventPostedMessage) GetSequence() uint64 {
-	if m != nil {
-		return m.Sequence
-	}
-	return 0
-}
-
-func (m *EventPostedMessage) GetNonce() uint32 {
-	if m != nil {
-		return m.Nonce
-	}
-	return 0
-}
-
-func (m *EventPostedMessage) GetTime() uint64 {
-	if m != nil {
-		return m.Time
-	}
-	return 0
-}
-
-func (m *EventPostedMessage) GetPayload() []byte {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
-type EventGuardianRegistered struct {
-	GuardianKey  []byte `protobuf:"bytes,1,opt,name=guardian_key,json=guardianKey,proto3" json:"guardian_key,omitempty"`
-	ValidatorKey []byte `protobuf:"bytes,2,opt,name=validator_key,json=validatorKey,proto3" json:"validator_key,omitempty"`
-}
-
-func (m *EventGuardianRegistered) Reset()         { *m = EventGuardianRegistered{} }
-func (m *EventGuardianRegistered) String() string { return proto.CompactTextString(m) }
-func (*EventGuardianRegistered) ProtoMessage()    {}
-func (*EventGuardianRegistered) Descriptor() ([]byte, []int) {
-	return fileDescriptor_486bfc4df1202b88, []int{2}
-}
-func (m *EventGuardianRegistered) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventGuardianRegistered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventGuardianRegistered.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 *EventGuardianRegistered) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventGuardianRegistered.Merge(m, src)
-}
-func (m *EventGuardianRegistered) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventGuardianRegistered) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventGuardianRegistered.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventGuardianRegistered proto.InternalMessageInfo
-
-func (m *EventGuardianRegistered) GetGuardianKey() []byte {
-	if m != nil {
-		return m.GuardianKey
-	}
-	return nil
-}
-
-func (m *EventGuardianRegistered) GetValidatorKey() []byte {
-	if m != nil {
-		return m.ValidatorKey
-	}
-	return nil
-}
-
-type EventConsensusSetUpdate struct {
-	OldIndex uint32 `protobuf:"varint,1,opt,name=old_index,json=oldIndex,proto3" json:"old_index,omitempty"`
-	NewIndex uint32 `protobuf:"varint,2,opt,name=new_index,json=newIndex,proto3" json:"new_index,omitempty"`
-}
-
-func (m *EventConsensusSetUpdate) Reset()         { *m = EventConsensusSetUpdate{} }
-func (m *EventConsensusSetUpdate) String() string { return proto.CompactTextString(m) }
-func (*EventConsensusSetUpdate) ProtoMessage()    {}
-func (*EventConsensusSetUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_486bfc4df1202b88, []int{3}
-}
-func (m *EventConsensusSetUpdate) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EventConsensusSetUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EventConsensusSetUpdate.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 *EventConsensusSetUpdate) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EventConsensusSetUpdate.Merge(m, src)
-}
-func (m *EventConsensusSetUpdate) XXX_Size() int {
-	return m.Size()
-}
-func (m *EventConsensusSetUpdate) XXX_DiscardUnknown() {
-	xxx_messageInfo_EventConsensusSetUpdate.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventConsensusSetUpdate proto.InternalMessageInfo
-
-func (m *EventConsensusSetUpdate) GetOldIndex() uint32 {
-	if m != nil {
-		return m.OldIndex
-	}
-	return 0
-}
-
-func (m *EventConsensusSetUpdate) GetNewIndex() uint32 {
-	if m != nil {
-		return m.NewIndex
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*EventGuardianSetUpdate)(nil), "certusone.wormholechain.wormhole.EventGuardianSetUpdate")
-	proto.RegisterType((*EventPostedMessage)(nil), "certusone.wormholechain.wormhole.EventPostedMessage")
-	proto.RegisterType((*EventGuardianRegistered)(nil), "certusone.wormholechain.wormhole.EventGuardianRegistered")
-	proto.RegisterType((*EventConsensusSetUpdate)(nil), "certusone.wormholechain.wormhole.EventConsensusSetUpdate")
-}
-
-func init() { proto.RegisterFile("wormhole/events.proto", fileDescriptor_486bfc4df1202b88) }
-
-var fileDescriptor_486bfc4df1202b88 = []byte{
-	// 348 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0xbd, 0x4e, 0xeb, 0x30,
-	0x14, 0x6e, 0x7a, 0xdb, 0x7b, 0x7b, 0x7d, 0xdb, 0xc5, 0xba, 0x40, 0x04, 0x52, 0x54, 0xc2, 0xc2,
-	0x42, 0x33, 0xc0, 0x13, 0x80, 0x10, 0x42, 0x15, 0x08, 0xa5, 0x62, 0x61, 0xa9, 0xdc, 0xf8, 0x28,
-	0xb5, 0x48, 0xec, 0x60, 0x9f, 0xb4, 0xcd, 0x4b, 0x20, 0x1e, 0x8b, 0xb1, 0x23, 0x23, 0x6a, 0x5f,
-	0x04, 0xc5, 0x4d, 0x22, 0xb1, 0xb3, 0xf9, 0xfb, 0xf1, 0x77, 0x6c, 0x7f, 0x26, 0x7b, 0x4b, 0xa5,
-	0xd3, 0xb9, 0x4a, 0x20, 0x80, 0x05, 0x48, 0x34, 0xa3, 0x4c, 0x2b, 0x54, 0x74, 0x18, 0x81, 0xc6,
-	0xdc, 0x28, 0x09, 0xa3, 0xda, 0x10, 0xcd, 0x99, 0x90, 0x0d, 0xf2, 0x43, 0xb2, 0x7f, 0x5d, 0xee,
-	0xb8, 0xc9, 0x99, 0xe6, 0x82, 0xc9, 0x09, 0xe0, 0x63, 0xc6, 0x19, 0x02, 0x3d, 0x22, 0x7f, 0x55,
-	0xc2, 0xa7, 0x42, 0x72, 0x58, 0xb9, 0xce, 0xd0, 0x39, 0x1d, 0x84, 0x3d, 0x95, 0xf0, 0xdb, 0x12,
-	0x97, 0xa2, 0x84, 0x65, 0x25, 0xb6, 0x77, 0xa2, 0x84, 0xa5, 0x15, 0xfd, 0x57, 0x87, 0x50, 0x1b,
-	0xfa, 0xa0, 0x0c, 0x02, 0xbf, 0x03, 0x63, 0x58, 0x0c, 0xd4, 0x25, 0x7f, 0x20, 0x15, 0x88, 0xa0,
-	0x6d, 0x5c, 0x3f, 0xac, 0x21, 0x3d, 0x24, 0x3d, 0x03, 0x2f, 0x39, 0xc8, 0x08, 0x6c, 0x58, 0x27,
-	0x6c, 0x30, 0xfd, 0x4f, 0xba, 0x52, 0x95, 0xc2, 0x2f, 0x3b, 0x65, 0x07, 0x28, 0x25, 0x1d, 0x14,
-	0x29, 0xb8, 0x1d, 0xeb, 0xb6, 0xeb, 0x32, 0x3f, 0x63, 0x45, 0xa2, 0x18, 0x77, 0xbb, 0xbb, 0xfc,
-	0x0a, 0xfa, 0x8c, 0x1c, 0x7c, 0xbb, 0x64, 0x08, 0xb1, 0x30, 0x08, 0x1a, 0x38, 0x3d, 0x26, 0xfd,
-	0xb8, 0x62, 0xa7, 0xcf, 0x50, 0x54, 0x27, 0xfb, 0x57, 0x73, 0x63, 0x28, 0xe8, 0x09, 0x19, 0x2c,
-	0x58, 0x22, 0x38, 0x43, 0xa5, 0xad, 0xa7, 0x6d, 0x3d, 0xfd, 0x86, 0x1c, 0x43, 0xe1, 0x4f, 0xaa,
-	0x11, 0x57, 0x4a, 0x1a, 0x90, 0x26, 0x37, 0x3f, 0xf0, 0x90, 0x97, 0xf7, 0xef, 0x1b, 0xcf, 0x59,
-	0x6f, 0x3c, 0xe7, 0x73, 0xe3, 0x39, 0x6f, 0x5b, 0xaf, 0xb5, 0xde, 0x7a, 0xad, 0x8f, 0xad, 0xd7,
-	0x7a, 0xba, 0x88, 0x05, 0xce, 0xf3, 0xd9, 0x28, 0x52, 0x69, 0xd0, 0x74, 0x1c, 0xd4, 0xad, 0x9e,
-	0xd9, 0x92, 0x83, 0x55, 0x43, 0x04, 0x58, 0x64, 0x60, 0x66, 0xbf, 0xed, 0xaf, 0x38, 0xff, 0x0a,
-	0x00, 0x00, 0xff, 0xff, 0x1e, 0x16, 0xf1, 0x8c, 0x2e, 0x02, 0x00, 0x00,
-}
-
-func (m *EventGuardianSetUpdate) 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 *EventGuardianSetUpdate) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventGuardianSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.NewIndex != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.NewIndex))
-		i--
-		dAtA[i] = 0x10
-	}
-	if m.OldIndex != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.OldIndex))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventPostedMessage) 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 *EventPostedMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventPostedMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Payload) > 0 {
-		i -= len(m.Payload)
-		copy(dAtA[i:], m.Payload)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Payload)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.Time != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.Time))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.Nonce != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.Nonce))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.Sequence != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.Sequence))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Emitter) > 0 {
-		i -= len(m.Emitter)
-		copy(dAtA[i:], m.Emitter)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.Emitter)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventGuardianRegistered) 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 *EventGuardianRegistered) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventGuardianRegistered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.ValidatorKey) > 0 {
-		i -= len(m.ValidatorKey)
-		copy(dAtA[i:], m.ValidatorKey)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.ValidatorKey)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.GuardianKey) > 0 {
-		i -= len(m.GuardianKey)
-		copy(dAtA[i:], m.GuardianKey)
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.GuardianKey)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *EventConsensusSetUpdate) 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 *EventConsensusSetUpdate) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EventConsensusSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.NewIndex != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.NewIndex))
-		i--
-		dAtA[i] = 0x10
-	}
-	if m.OldIndex != 0 {
-		i = encodeVarintEvents(dAtA, i, uint64(m.OldIndex))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
-	offset -= sovEvents(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *EventGuardianSetUpdate) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.OldIndex != 0 {
-		n += 1 + sovEvents(uint64(m.OldIndex))
-	}
-	if m.NewIndex != 0 {
-		n += 1 + sovEvents(uint64(m.NewIndex))
-	}
-	return n
-}
-
-func (m *EventPostedMessage) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Emitter)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	if m.Sequence != 0 {
-		n += 1 + sovEvents(uint64(m.Sequence))
-	}
-	if m.Nonce != 0 {
-		n += 1 + sovEvents(uint64(m.Nonce))
-	}
-	if m.Time != 0 {
-		n += 1 + sovEvents(uint64(m.Time))
-	}
-	l = len(m.Payload)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func (m *EventGuardianRegistered) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.GuardianKey)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	l = len(m.ValidatorKey)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	return n
-}
-
-func (m *EventConsensusSetUpdate) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.OldIndex != 0 {
-		n += 1 + sovEvents(uint64(m.OldIndex))
-	}
-	if m.NewIndex != 0 {
-		n += 1 + sovEvents(uint64(m.NewIndex))
-	}
-	return n
-}
-
-func sovEvents(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozEvents(x uint64) (n int) {
-	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *EventGuardianSetUpdate) 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 ErrIntOverflowEvents
-			}
-			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: EventGuardianSetUpdate: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventGuardianSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OldIndex", wireType)
-			}
-			m.OldIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.OldIndex |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NewIndex", wireType)
-			}
-			m.NewIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.NewIndex |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventPostedMessage) 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 ErrIntOverflowEvents
-			}
-			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: EventPostedMessage: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventPostedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Emitter", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Emitter = append(m.Emitter[:0], dAtA[iNdEx:postIndex]...)
-			if m.Emitter == nil {
-				m.Emitter = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
-			}
-			m.Sequence = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Sequence |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
-			}
-			m.Nonce = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Nonce |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
-			}
-			m.Time = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Time |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
-			if m.Payload == nil {
-				m.Payload = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventGuardianRegistered) 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 ErrIntOverflowEvents
-			}
-			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: EventGuardianRegistered: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventGuardianRegistered: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.GuardianKey == nil {
-				m.GuardianKey = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKey", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorKey = append(m.ValidatorKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.ValidatorKey == nil {
-				m.ValidatorKey = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *EventConsensusSetUpdate) 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 ErrIntOverflowEvents
-			}
-			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: EventConsensusSetUpdate: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventConsensusSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OldIndex", wireType)
-			}
-			m.OldIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.OldIndex |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NewIndex", wireType)
-			}
-			m.NewIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.NewIndex |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipEvents(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowEvents
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthEvents
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupEvents
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthEvents
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/expected_keepers.go

@@ -1,5 +1,10 @@
 package types
 
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
 type AccountKeeper interface {
 	// Methods imported from account should be defined here
 }
@@ -7,3 +12,9 @@ type AccountKeeper interface {
 type BankKeeper interface {
 	// Methods imported from bank should be defined here
 }
+
+type WasmdKeeper interface {
+	// For StoreCode
+	Create(ctx sdk.Context, creator sdk.AccAddress, wasmCode []byte, instantiateAccess *wasmtypes.AccessConfig) (codeID uint64, err error)
+	Instantiate(ctx sdk.Context, codeID uint64, creator, admin sdk.AccAddress, initMsg []byte, label string, deposit sdk.Coins) (sdk.AccAddress, []byte, error)
+}

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

@@ -1,651 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/genesis.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-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"`
-}
-
-func (m *GenesisState) Reset()         { *m = GenesisState{} }
-func (m *GenesisState) String() string { return proto.CompactTextString(m) }
-func (*GenesisState) ProtoMessage()    {}
-func (*GenesisState) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9a7ced3fe0304831, []int{0}
-}
-func (m *GenesisState) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GenesisState.Merge(m, src)
-}
-func (m *GenesisState) XXX_Size() int {
-	return m.Size()
-}
-func (m *GenesisState) XXX_DiscardUnknown() {
-	xxx_messageInfo_GenesisState.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenesisState proto.InternalMessageInfo
-
-func (m *GenesisState) GetGuardianSetList() []GuardianSet {
-	if m != nil {
-		return m.GuardianSetList
-	}
-	return nil
-}
-
-func (m *GenesisState) GetConfig() *Config {
-	if m != nil {
-		return m.Config
-	}
-	return nil
-}
-
-func (m *GenesisState) GetReplayProtectionList() []ReplayProtection {
-	if m != nil {
-		return m.ReplayProtectionList
-	}
-	return nil
-}
-
-func (m *GenesisState) GetSequenceCounterList() []SequenceCounter {
-	if m != nil {
-		return m.SequenceCounterList
-	}
-	return nil
-}
-
-func (m *GenesisState) GetConsensusGuardianSetIndex() *ConsensusGuardianSetIndex {
-	if m != nil {
-		return m.ConsensusGuardianSetIndex
-	}
-	return nil
-}
-
-func (m *GenesisState) GetGuardianValidatorList() []GuardianValidator {
-	if m != nil {
-		return m.GuardianValidatorList
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*GenesisState)(nil), "certusone.wormholechain.wormhole.GenesisState")
-}
-
-func init() { proto.RegisterFile("wormhole/genesis.proto", fileDescriptor_9a7ced3fe0304831) }
-
-var fileDescriptor_9a7ced3fe0304831 = []byte{
-	// 418 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xcf, 0x8a, 0xda, 0x40,
-	0x18, 0x4f, 0xaa, 0xf5, 0x30, 0x16, 0x0a, 0xa9, 0x16, 0x6b, 0x21, 0xa6, 0x3d, 0x09, 0xc5, 0x84,
-	0x6a, 0x6f, 0xbd, 0x14, 0x3d, 0x48, 0xa1, 0x94, 0x25, 0xc2, 0x1e, 0x16, 0x96, 0x10, 0xe3, 0xb7,
-	0x71, 0x20, 0xce, 0xb8, 0x99, 0xc9, 0xae, 0xbe, 0xc5, 0x3e, 0x96, 0x47, 0x8f, 0x7b, 0x5a, 0x16,
-	0x7d, 0x85, 0x7d, 0x80, 0xc5, 0xc9, 0x64, 0x74, 0xdd, 0x2c, 0xf1, 0x36, 0xf9, 0xf2, 0xfb, 0xf3,
-	0xcd, 0xef, 0x37, 0xe8, 0xf3, 0x2d, 0x8d, 0x67, 0x53, 0x1a, 0x81, 0x13, 0x02, 0x01, 0x86, 0x99,
-	0x3d, 0x8f, 0x29, 0xa7, 0x86, 0x15, 0x40, 0xcc, 0x13, 0x46, 0x09, 0xd8, 0x19, 0x22, 0x98, 0xfa,
-	0x98, 0xa8, 0xaf, 0xe6, 0xd7, 0x3d, 0x33, 0xf1, 0xe3, 0x09, 0xf6, 0x89, 0xc7, 0x80, 0xa7, 0xf4,
-	0x66, 0x5d, 0xfd, 0x0c, 0x28, 0xb9, 0xc2, 0xa1, 0x1c, 0x5b, 0x6a, 0x1c, 0xc3, 0x3c, 0xf2, 0x97,
-	0xde, 0x6e, 0x0c, 0x01, 0xc7, 0x94, 0x48, 0x44, 0x4b, 0x21, 0x18, 0x5c, 0x27, 0x40, 0x02, 0xf0,
-	0x02, 0x9a, 0x10, 0x0e, 0xb1, 0x04, 0xfc, 0x38, 0x54, 0x66, 0x40, 0x58, 0xc2, 0xbc, 0xc3, 0x05,
-	0x3c, 0x4c, 0x26, 0xb0, 0x90, 0xe0, 0x6f, 0xaf, 0x77, 0xbc, 0xf1, 0x23, 0x3c, 0xf1, 0x39, 0xcd,
-	0xf4, 0x6a, 0x21, 0x0d, 0xa9, 0x38, 0x3a, 0xbb, 0x53, 0x3a, 0xfd, 0xfe, 0x54, 0x46, 0x1f, 0x86,
-	0x69, 0x20, 0x23, 0xee, 0x73, 0x30, 0x2e, 0xd1, 0xc7, 0x4c, 0x62, 0x04, 0xfc, 0x1f, 0x66, 0xbc,
-	0xa1, 0x5b, 0xa5, 0x76, 0xb5, 0xdb, 0xb1, 0x8b, 0x92, 0xb2, 0x87, 0x7b, 0x62, 0xbf, 0xbc, 0x7a,
-	0x68, 0x69, 0xee, 0xb1, 0x96, 0xf1, 0x07, 0x55, 0xd2, 0xa0, 0x1a, 0xef, 0x2c, 0xbd, 0x5d, 0xed,
-	0xb6, 0x8b, 0x55, 0x07, 0x02, 0xef, 0x4a, 0x9e, 0x11, 0xa1, 0x5a, 0x9a, 0xe9, 0x99, 0x8a, 0x54,
-	0x6c, 0x59, 0x12, 0x5b, 0x76, 0x8b, 0xf5, 0xdc, 0x23, 0xb6, 0x5c, 0x35, 0x57, 0xd5, 0xc0, 0xe8,
-	0x53, 0xd6, 0xcf, 0x20, 0xad, 0x47, 0x98, 0x95, 0x85, 0xd9, 0xcf, 0x62, 0xb3, 0xd1, 0x4b, 0xb2,
-	0xf4, 0xca, 0xd3, 0x34, 0x96, 0xe8, 0x8b, 0x6a, 0xfa, 0x20, 0xc9, 0xbf, 0xbb, 0x9a, 0x1b, 0xef,
-	0x45, 0x5a, 0xbf, 0x4f, 0x4a, 0x2b, 0x5f, 0xc2, 0x7d, 0x5b, 0xdd, 0xa0, 0xa8, 0x9e, 0x15, 0x75,
-	0x9e, 0x3d, 0x1b, 0x71, 0xcf, 0x8a, 0xb8, 0x67, 0xef, 0xf4, 0xea, 0x15, 0x5d, 0xde, 0x34, 0x5f,
-	0xb7, 0xff, 0x7f, 0xb5, 0x31, 0xf5, 0xf5, 0xc6, 0xd4, 0x1f, 0x37, 0xa6, 0x7e, 0xb7, 0x35, 0xb5,
-	0xf5, 0xd6, 0xd4, 0xee, 0xb7, 0xa6, 0x76, 0xf1, 0x2b, 0xc4, 0x7c, 0x9a, 0x8c, 0xed, 0x80, 0xce,
-	0x1c, 0xe5, 0xea, 0x64, 0x3e, 0x1d, 0x61, 0xeb, 0x2c, 0xd4, 0xc0, 0xe1, 0xcb, 0x39, 0xb0, 0x71,
-	0x45, 0xbc, 0xe6, 0xde, 0x73, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x90, 0x08, 0x30, 0xe6, 0x03,
-	0x00, 0x00,
-}
-
-func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.GuardianValidatorList) > 0 {
-		for iNdEx := len(m.GuardianValidatorList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.GuardianValidatorList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x32
-		}
-	}
-	if m.ConsensusGuardianSetIndex != nil {
-		{
-			size, err := m.ConsensusGuardianSetIndex.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenesis(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
-	}
-	if len(m.SequenceCounterList) > 0 {
-		for iNdEx := len(m.SequenceCounterList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.SequenceCounterList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
-	}
-	if len(m.ReplayProtectionList) > 0 {
-		for iNdEx := len(m.ReplayProtectionList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ReplayProtectionList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	if m.Config != nil {
-		{
-			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintGenesis(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.GuardianSetList) > 0 {
-		for iNdEx := len(m.GuardianSetList) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.GuardianSetList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintGenesis(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0xa
-		}
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGenesis(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GenesisState) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.GuardianSetList) > 0 {
-		for _, e := range m.GuardianSetList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if m.Config != nil {
-		l = m.Config.Size()
-		n += 1 + l + sovGenesis(uint64(l))
-	}
-	if len(m.ReplayProtectionList) > 0 {
-		for _, e := range m.ReplayProtectionList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if len(m.SequenceCounterList) > 0 {
-		for _, e := range m.SequenceCounterList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	if m.ConsensusGuardianSetIndex != nil {
-		l = m.ConsensusGuardianSetIndex.Size()
-		n += 1 + l + sovGenesis(uint64(l))
-	}
-	if len(m.GuardianValidatorList) > 0 {
-		for _, e := range m.GuardianValidatorList {
-			l = e.Size()
-			n += 1 + l + sovGenesis(uint64(l))
-		}
-	}
-	return n
-}
-
-func sovGenesis(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGenesis(x uint64) (n int) {
-	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GenesisState) 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 ErrIntOverflowGenesis
-			}
-			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: GenesisState: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianSetList", 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.GuardianSetList = append(m.GuardianSetList, GuardianSet{})
-			if err := m.GuardianSetList[len(m.GuardianSetList)-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 Config", 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
-			}
-			if m.Config == nil {
-				m.Config = &Config{}
-			}
-			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtectionList", 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.ReplayProtectionList = append(m.ReplayProtectionList, ReplayProtection{})
-			if err := m.ReplayProtectionList[len(m.ReplayProtectionList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounterList", 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.SequenceCounterList = append(m.SequenceCounterList, SequenceCounter{})
-			if err := m.SequenceCounterList[len(m.SequenceCounterList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusGuardianSetIndex", 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
-			}
-			if m.ConsensusGuardianSetIndex == nil {
-				m.ConsensusGuardianSetIndex = &ConsensusGuardianSetIndex{}
-			}
-			if err := m.ConsensusGuardianSetIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidatorList", 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.GuardianValidatorList = append(m.GuardianValidatorList, GuardianValidator{})
-			if err := m.GuardianValidatorList[len(m.GuardianValidatorList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenesis(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenesis
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGenesis(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGenesis
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenesis
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGenesis
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGenesis
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGenesis
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/governance.pb.go

@@ -1,901 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/governance.proto
-
-package types
-
-import (
-	bytes "bytes"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-// GuardianSetUpdateProposal defines a guardian set update governance proposal
-type GuardianSetUpdateProposal struct {
-	Title          string      `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
-	Description    string      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
-	NewGuardianSet GuardianSet `protobuf:"bytes,3,opt,name=newGuardianSet,proto3" json:"newGuardianSet"`
-}
-
-func (m *GuardianSetUpdateProposal) Reset()      { *m = GuardianSetUpdateProposal{} }
-func (*GuardianSetUpdateProposal) ProtoMessage() {}
-func (*GuardianSetUpdateProposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ceebda8f8c3f5f74, []int{0}
-}
-func (m *GuardianSetUpdateProposal) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GuardianSetUpdateProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GuardianSetUpdateProposal.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 *GuardianSetUpdateProposal) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GuardianSetUpdateProposal.Merge(m, src)
-}
-func (m *GuardianSetUpdateProposal) XXX_Size() int {
-	return m.Size()
-}
-func (m *GuardianSetUpdateProposal) XXX_DiscardUnknown() {
-	xxx_messageInfo_GuardianSetUpdateProposal.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GuardianSetUpdateProposal proto.InternalMessageInfo
-
-func (m *GuardianSetUpdateProposal) GetTitle() string {
-	if m != nil {
-		return m.Title
-	}
-	return ""
-}
-
-func (m *GuardianSetUpdateProposal) GetDescription() string {
-	if m != nil {
-		return m.Description
-	}
-	return ""
-}
-
-func (m *GuardianSetUpdateProposal) GetNewGuardianSet() GuardianSet {
-	if m != nil {
-		return m.NewGuardianSet
-	}
-	return GuardianSet{}
-}
-
-// GovernanceWormholeMessageProposal defines a governance proposal to emit a generic message in the governance message
-// format.
-type GovernanceWormholeMessageProposal struct {
-	Title       string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
-	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
-	Action      uint32 `protobuf:"varint,3,opt,name=action,proto3" json:"action,omitempty"`
-	Module      []byte `protobuf:"bytes,4,opt,name=module,proto3" json:"module,omitempty"`
-	TargetChain uint32 `protobuf:"varint,5,opt,name=targetChain,proto3" json:"targetChain,omitempty"`
-	Payload     []byte `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty"`
-}
-
-func (m *GovernanceWormholeMessageProposal) Reset()      { *m = GovernanceWormholeMessageProposal{} }
-func (*GovernanceWormholeMessageProposal) ProtoMessage() {}
-func (*GovernanceWormholeMessageProposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ceebda8f8c3f5f74, []int{1}
-}
-func (m *GovernanceWormholeMessageProposal) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GovernanceWormholeMessageProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GovernanceWormholeMessageProposal.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 *GovernanceWormholeMessageProposal) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GovernanceWormholeMessageProposal.Merge(m, src)
-}
-func (m *GovernanceWormholeMessageProposal) XXX_Size() int {
-	return m.Size()
-}
-func (m *GovernanceWormholeMessageProposal) XXX_DiscardUnknown() {
-	xxx_messageInfo_GovernanceWormholeMessageProposal.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GovernanceWormholeMessageProposal proto.InternalMessageInfo
-
-func (m *GovernanceWormholeMessageProposal) GetTitle() string {
-	if m != nil {
-		return m.Title
-	}
-	return ""
-}
-
-func (m *GovernanceWormholeMessageProposal) GetDescription() string {
-	if m != nil {
-		return m.Description
-	}
-	return ""
-}
-
-func (m *GovernanceWormholeMessageProposal) GetAction() uint32 {
-	if m != nil {
-		return m.Action
-	}
-	return 0
-}
-
-func (m *GovernanceWormholeMessageProposal) GetModule() []byte {
-	if m != nil {
-		return m.Module
-	}
-	return nil
-}
-
-func (m *GovernanceWormholeMessageProposal) GetTargetChain() uint32 {
-	if m != nil {
-		return m.TargetChain
-	}
-	return 0
-}
-
-func (m *GovernanceWormholeMessageProposal) GetPayload() []byte {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*GuardianSetUpdateProposal)(nil), "certusone.wormholechain.wormhole.GuardianSetUpdateProposal")
-	proto.RegisterType((*GovernanceWormholeMessageProposal)(nil), "certusone.wormholechain.wormhole.GovernanceWormholeMessageProposal")
-}
-
-func init() { proto.RegisterFile("wormhole/governance.proto", fileDescriptor_ceebda8f8c3f5f74) }
-
-var fileDescriptor_ceebda8f8c3f5f74 = []byte{
-	// 357 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x51, 0xb1, 0x4e, 0xe3, 0x40,
-	0x14, 0xf4, 0xde, 0x25, 0xb9, 0xbb, 0xcd, 0x41, 0x61, 0x45, 0xc8, 0x09, 0x92, 0x63, 0x52, 0xa5,
-	0x89, 0x2d, 0x01, 0x15, 0x65, 0x28, 0x52, 0x81, 0x90, 0x11, 0x42, 0x82, 0x02, 0x6d, 0xec, 0x27,
-	0xc7, 0x92, 0xe3, 0x67, 0xed, 0xae, 0x09, 0xf9, 0x0b, 0x4a, 0xca, 0x7c, 0x07, 0x5f, 0x90, 0x32,
-	0x74, 0x54, 0x08, 0x25, 0x0d, 0x9f, 0x81, 0xbc, 0x71, 0x1c, 0x8b, 0x86, 0x82, 0xee, 0xcd, 0xbc,
-	0x37, 0xa3, 0x9d, 0x59, 0xda, 0x9c, 0x20, 0x1f, 0x8f, 0x30, 0x02, 0x27, 0xc0, 0x7b, 0xe0, 0x31,
-	0x8b, 0x3d, 0xb0, 0x13, 0x8e, 0x12, 0x75, 0xcb, 0x03, 0x2e, 0x53, 0x81, 0x31, 0xd8, 0x9b, 0x23,
-	0x6f, 0xc4, 0xc2, 0xb8, 0x40, 0xad, 0xfd, 0xad, 0x38, 0x65, 0xdc, 0x0f, 0x59, 0x7c, 0x27, 0x40,
-	0xae, 0xe5, 0xad, 0x46, 0x80, 0x01, 0xaa, 0xd1, 0xc9, 0xa6, 0x35, 0xdb, 0x79, 0x26, 0xb4, 0x39,
-	0xc8, 0x8f, 0x2f, 0x41, 0x5e, 0x25, 0x3e, 0x93, 0x70, 0xc1, 0x31, 0x41, 0xc1, 0x22, 0xbd, 0x41,
-	0xab, 0x32, 0x94, 0x11, 0x18, 0xc4, 0x22, 0xdd, 0x7f, 0xee, 0x1a, 0xe8, 0x16, 0xad, 0xfb, 0x20,
-	0x3c, 0x1e, 0x26, 0x32, 0xc4, 0xd8, 0xf8, 0xa5, 0x76, 0x65, 0x4a, 0xbf, 0xa5, 0xbb, 0x31, 0x4c,
-	0x4a, 0xbe, 0xc6, 0x6f, 0x8b, 0x74, 0xeb, 0x87, 0x3d, 0xfb, 0xbb, 0x0c, 0x76, 0x49, 0xd4, 0xaf,
-	0xcc, 0xdf, 0xda, 0x9a, 0xfb, 0xc5, 0xea, 0xe4, 0xef, 0xd3, 0xac, 0xad, 0x7d, 0xcc, 0xda, 0xa4,
-	0xf3, 0x42, 0xe8, 0xc1, 0xa0, 0xa8, 0xe9, 0x3a, 0xb7, 0x38, 0x03, 0x21, 0x58, 0xf0, 0xf3, 0x10,
-	0x7b, 0xb4, 0xc6, 0x3c, 0xb5, 0xcc, 0x1e, 0xbf, 0xe3, 0xe6, 0x28, 0xe3, 0xc7, 0xe8, 0xa7, 0x11,
-	0x18, 0x15, 0x8b, 0x74, 0xff, 0xbb, 0x39, 0xca, 0x1c, 0x25, 0xe3, 0x01, 0xc8, 0xd3, 0x2c, 0x91,
-	0x51, 0x55, 0xa2, 0x32, 0xa5, 0x1b, 0xf4, 0x4f, 0xc2, 0xa6, 0x11, 0x32, 0xdf, 0xa8, 0x29, 0xe9,
-	0x06, 0x6e, 0x33, 0xf5, 0xcf, 0xe7, 0x4b, 0x93, 0x2c, 0x96, 0x26, 0x79, 0x5f, 0x9a, 0xe4, 0x71,
-	0x65, 0x6a, 0x8b, 0x95, 0xa9, 0xbd, 0xae, 0x4c, 0xed, 0xe6, 0x38, 0x08, 0xe5, 0x28, 0x1d, 0xda,
-	0x1e, 0x8e, 0x9d, 0xa2, 0x46, 0x67, 0x53, 0x5c, 0x4f, 0xf5, 0xe8, 0x3c, 0x14, 0x84, 0x23, 0xa7,
-	0x09, 0x88, 0x61, 0x4d, 0xfd, 0xf3, 0xd1, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x07, 0x3a,
-	0x70, 0x59, 0x02, 0x00, 0x00,
-}
-
-func (this *GuardianSetUpdateProposal) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*GuardianSetUpdateProposal)
-	if !ok {
-		that2, ok := that.(GuardianSetUpdateProposal)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if this.Title != that1.Title {
-		return false
-	}
-	if this.Description != that1.Description {
-		return false
-	}
-	if !this.NewGuardianSet.Equal(&that1.NewGuardianSet) {
-		return false
-	}
-	return true
-}
-func (this *GovernanceWormholeMessageProposal) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*GovernanceWormholeMessageProposal)
-	if !ok {
-		that2, ok := that.(GovernanceWormholeMessageProposal)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if this.Title != that1.Title {
-		return false
-	}
-	if this.Description != that1.Description {
-		return false
-	}
-	if this.Action != that1.Action {
-		return false
-	}
-	if !bytes.Equal(this.Module, that1.Module) {
-		return false
-	}
-	if this.TargetChain != that1.TargetChain {
-		return false
-	}
-	if !bytes.Equal(this.Payload, that1.Payload) {
-		return false
-	}
-	return true
-}
-func (m *GuardianSetUpdateProposal) 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 *GuardianSetUpdateProposal) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GuardianSetUpdateProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.NewGuardianSet.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGovernance(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x1a
-	if len(m.Description) > 0 {
-		i -= len(m.Description)
-		copy(dAtA[i:], m.Description)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Title) > 0 {
-		i -= len(m.Title)
-		copy(dAtA[i:], m.Title)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *GovernanceWormholeMessageProposal) 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 *GovernanceWormholeMessageProposal) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GovernanceWormholeMessageProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Payload) > 0 {
-		i -= len(m.Payload)
-		copy(dAtA[i:], m.Payload)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Payload)))
-		i--
-		dAtA[i] = 0x32
-	}
-	if m.TargetChain != 0 {
-		i = encodeVarintGovernance(dAtA, i, uint64(m.TargetChain))
-		i--
-		dAtA[i] = 0x28
-	}
-	if len(m.Module) > 0 {
-		i -= len(m.Module)
-		copy(dAtA[i:], m.Module)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Module)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if m.Action != 0 {
-		i = encodeVarintGovernance(dAtA, i, uint64(m.Action))
-		i--
-		dAtA[i] = 0x18
-	}
-	if len(m.Description) > 0 {
-		i -= len(m.Description)
-		copy(dAtA[i:], m.Description)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Description)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Title) > 0 {
-		i -= len(m.Title)
-		copy(dAtA[i:], m.Title)
-		i = encodeVarintGovernance(dAtA, i, uint64(len(m.Title)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGovernance(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGovernance(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GuardianSetUpdateProposal) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Title)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	l = len(m.Description)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	l = m.NewGuardianSet.Size()
-	n += 1 + l + sovGovernance(uint64(l))
-	return n
-}
-
-func (m *GovernanceWormholeMessageProposal) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Title)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	l = len(m.Description)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	if m.Action != 0 {
-		n += 1 + sovGovernance(uint64(m.Action))
-	}
-	l = len(m.Module)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	if m.TargetChain != 0 {
-		n += 1 + sovGovernance(uint64(m.TargetChain))
-	}
-	l = len(m.Payload)
-	if l > 0 {
-		n += 1 + l + sovGovernance(uint64(l))
-	}
-	return n
-}
-
-func sovGovernance(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGovernance(x uint64) (n int) {
-	return sovGovernance(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GuardianSetUpdateProposal) 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 ErrIntOverflowGovernance
-			}
-			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: GuardianSetUpdateProposal: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GuardianSetUpdateProposal: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				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 ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Title = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				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 ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Description = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NewGuardianSet", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.NewGuardianSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGovernance(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *GovernanceWormholeMessageProposal) 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 ErrIntOverflowGovernance
-			}
-			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: GovernanceWormholeMessageProposal: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GovernanceWormholeMessageProposal: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				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 ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Title = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				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 ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Description = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
-			}
-			m.Action = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Action |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Module = append(m.Module[:0], dAtA[iNdEx:postIndex]...)
-			if m.Module == nil {
-				m.Module = []byte{}
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TargetChain", wireType)
-			}
-			m.TargetChain = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.TargetChain |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
-			if m.Payload == nil {
-				m.Payload = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGovernance(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGovernance
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGovernance(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGovernance
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGovernance
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGovernance
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGovernance
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGovernance
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGovernance        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGovernance          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGovernance = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/guardian_key.pb.go

@@ -1,318 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/guardian_key.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type GuardianKey struct {
-	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
-}
-
-func (m *GuardianKey) Reset()         { *m = GuardianKey{} }
-func (m *GuardianKey) String() string { return proto.CompactTextString(m) }
-func (*GuardianKey) ProtoMessage()    {}
-func (*GuardianKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_87576a0b45454f44, []int{0}
-}
-func (m *GuardianKey) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GuardianKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GuardianKey.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 *GuardianKey) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GuardianKey.Merge(m, src)
-}
-func (m *GuardianKey) XXX_Size() int {
-	return m.Size()
-}
-func (m *GuardianKey) XXX_DiscardUnknown() {
-	xxx_messageInfo_GuardianKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GuardianKey proto.InternalMessageInfo
-
-func (m *GuardianKey) GetKey() []byte {
-	if m != nil {
-		return m.Key
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*GuardianKey)(nil), "certusone.wormholechain.wormhole.GuardianKey")
-}
-
-func init() { proto.RegisterFile("wormhole/guardian_key.proto", fileDescriptor_87576a0b45454f44) }
-
-var fileDescriptor_87576a0b45454f44 = []byte{
-	// 164 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0xcf, 0x4e,
-	0xad, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48, 0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce,
-	0xcf, 0x4b, 0xd5, 0x83, 0x29, 0x4b, 0xce, 0x48, 0xcc, 0xcc, 0x83, 0xf3, 0x94, 0xe4, 0xb9, 0xb8,
-	0xdd, 0xa1, 0xfa, 0xbc, 0x53, 0x2b, 0x85, 0x04, 0xb8, 0x98, 0xb3, 0x53, 0x2b, 0x25, 0x18, 0x15,
-	0x18, 0x35, 0x78, 0x82, 0x40, 0x4c, 0x27, 0xbf, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63,
-	0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96,
-	0x63, 0x88, 0x32, 0x49, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x87, 0xdb,
-	0xa3, 0x0f, 0x33, 0x59, 0x17, 0x6c, 0x91, 0x7e, 0x05, 0x5c, 0x40, 0xbf, 0xa4, 0xb2, 0x20, 0xb5,
-	0x38, 0x89, 0x0d, 0xec, 0x32, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x28, 0x0c, 0xe7, 0x2d,
-	0xb8, 0x00, 0x00, 0x00,
-}
-
-func (m *GuardianKey) 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 *GuardianKey) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GuardianKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintGuardianKey(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGuardianKey(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGuardianKey(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GuardianKey) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Key)
-	if l > 0 {
-		n += 1 + l + sovGuardianKey(uint64(l))
-	}
-	return n
-}
-
-func sovGuardianKey(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGuardianKey(x uint64) (n int) {
-	return sovGuardianKey(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GuardianKey) 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 ErrIntOverflowGuardianKey
-			}
-			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: GuardianKey: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GuardianKey: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianKey
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGuardianKey
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGuardianKey
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
-			if m.Key == nil {
-				m.Key = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGuardianKey(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGuardianKey
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGuardianKey(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGuardianKey
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianKey
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianKey
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGuardianKey
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGuardianKey
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGuardianKey
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGuardianKey        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGuardianKey          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGuardianKey = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/guardian_set.pb.go

@@ -1,431 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/guardian_set.proto
-
-package types
-
-import (
-	bytes "bytes"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	_ "github.com/gogo/protobuf/gogoproto"
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type GuardianSet struct {
-	Index          uint32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
-	Keys           [][]byte `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"`
-	ExpirationTime uint64   `protobuf:"varint,3,opt,name=expirationTime,proto3" json:"expirationTime,omitempty"`
-}
-
-func (m *GuardianSet) Reset()         { *m = GuardianSet{} }
-func (m *GuardianSet) String() string { return proto.CompactTextString(m) }
-func (*GuardianSet) ProtoMessage()    {}
-func (*GuardianSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3a6a773f49e89397, []int{0}
-}
-func (m *GuardianSet) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GuardianSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GuardianSet.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 *GuardianSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GuardianSet.Merge(m, src)
-}
-func (m *GuardianSet) XXX_Size() int {
-	return m.Size()
-}
-func (m *GuardianSet) XXX_DiscardUnknown() {
-	xxx_messageInfo_GuardianSet.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GuardianSet proto.InternalMessageInfo
-
-func (m *GuardianSet) GetIndex() uint32 {
-	if m != nil {
-		return m.Index
-	}
-	return 0
-}
-
-func (m *GuardianSet) GetKeys() [][]byte {
-	if m != nil {
-		return m.Keys
-	}
-	return nil
-}
-
-func (m *GuardianSet) GetExpirationTime() uint64 {
-	if m != nil {
-		return m.ExpirationTime
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*GuardianSet)(nil), "certusone.wormholechain.wormhole.GuardianSet")
-}
-
-func init() { proto.RegisterFile("wormhole/guardian_set.proto", fileDescriptor_3a6a773f49e89397) }
-
-var fileDescriptor_3a6a773f49e89397 = []byte{
-	// 229 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4e,
-	0x2d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48, 0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce,
-	0xcf, 0x4b, 0xd5, 0x83, 0x29, 0x4b, 0xce, 0x48, 0xcc, 0xcc, 0x83, 0xf3, 0xa4, 0x44, 0xd2, 0xf3,
-	0xd3, 0xf3, 0xc1, 0x8a, 0xf5, 0x41, 0x2c, 0x88, 0x3e, 0xa5, 0x54, 0x2e, 0x6e, 0x77, 0xa8, 0x69,
-	0xc1, 0xa9, 0x25, 0x42, 0x22, 0x5c, 0xac, 0x99, 0x79, 0x29, 0xa9, 0x15, 0x12, 0x8c, 0x0a, 0x8c,
-	0x1a, 0xbc, 0x41, 0x10, 0x8e, 0x90, 0x10, 0x17, 0x4b, 0x76, 0x6a, 0x65, 0xb1, 0x04, 0x93, 0x02,
-	0xb3, 0x06, 0x4f, 0x10, 0x98, 0x2d, 0xa4, 0xc6, 0xc5, 0x97, 0x5a, 0x51, 0x90, 0x59, 0x94, 0x58,
-	0x92, 0x99, 0x9f, 0x17, 0x92, 0x99, 0x9b, 0x2a, 0xc1, 0xac, 0xc0, 0xa8, 0xc1, 0x12, 0x84, 0x26,
-	0x6a, 0xc5, 0xf2, 0x62, 0x81, 0x3c, 0xa3, 0x93, 0xdf, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9,
-	0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e,
-	0xcb, 0x31, 0x44, 0x99, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xc3,
-	0xfd, 0xa0, 0x0f, 0x73, 0xb5, 0x2e, 0xd8, 0x13, 0xfa, 0x15, 0x70, 0x01, 0xfd, 0x92, 0xca, 0x82,
-	0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xeb, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x44, 0x6e,
-	0x52, 0x14, 0x01, 0x00, 0x00,
-}
-
-func (this *GuardianSet) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*GuardianSet)
-	if !ok {
-		that2, ok := that.(GuardianSet)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if this.Index != that1.Index {
-		return false
-	}
-	if len(this.Keys) != len(that1.Keys) {
-		return false
-	}
-	for i := range this.Keys {
-		if !bytes.Equal(this.Keys[i], that1.Keys[i]) {
-			return false
-		}
-	}
-	if this.ExpirationTime != that1.ExpirationTime {
-		return false
-	}
-	return true
-}
-func (m *GuardianSet) 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 *GuardianSet) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GuardianSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.ExpirationTime != 0 {
-		i = encodeVarintGuardianSet(dAtA, i, uint64(m.ExpirationTime))
-		i--
-		dAtA[i] = 0x18
-	}
-	if len(m.Keys) > 0 {
-		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Keys[iNdEx])
-			copy(dAtA[i:], m.Keys[iNdEx])
-			i = encodeVarintGuardianSet(dAtA, i, uint64(len(m.Keys[iNdEx])))
-			i--
-			dAtA[i] = 0x12
-		}
-	}
-	if m.Index != 0 {
-		i = encodeVarintGuardianSet(dAtA, i, uint64(m.Index))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGuardianSet(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGuardianSet(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GuardianSet) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Index != 0 {
-		n += 1 + sovGuardianSet(uint64(m.Index))
-	}
-	if len(m.Keys) > 0 {
-		for _, b := range m.Keys {
-			l = len(b)
-			n += 1 + l + sovGuardianSet(uint64(l))
-		}
-	}
-	if m.ExpirationTime != 0 {
-		n += 1 + sovGuardianSet(uint64(m.ExpirationTime))
-	}
-	return n
-}
-
-func sovGuardianSet(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGuardianSet(x uint64) (n int) {
-	return sovGuardianSet(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GuardianSet) 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 ErrIntOverflowGuardianSet
-			}
-			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: GuardianSet: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GuardianSet: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			m.Index = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianSet
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Index |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianSet
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGuardianSet
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGuardianSet
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
-			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
-			}
-			m.ExpirationTime = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianSet
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ExpirationTime |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGuardianSet(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGuardianSet
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGuardianSet(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGuardianSet
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianSet
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianSet
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGuardianSet
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGuardianSet
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGuardianSet
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGuardianSet        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGuardianSet          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGuardianSet = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/guardian_validator.pb.go

@@ -1,372 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/guardian_validator.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type GuardianValidator struct {
-	GuardianKey   []byte `protobuf:"bytes,1,opt,name=guardianKey,proto3" json:"guardianKey,omitempty"`
-	ValidatorAddr []byte `protobuf:"bytes,2,opt,name=validatorAddr,proto3" json:"validatorAddr,omitempty"`
-}
-
-func (m *GuardianValidator) Reset()         { *m = GuardianValidator{} }
-func (m *GuardianValidator) String() string { return proto.CompactTextString(m) }
-func (*GuardianValidator) ProtoMessage()    {}
-func (*GuardianValidator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a7e08ab792af660a, []int{0}
-}
-func (m *GuardianValidator) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GuardianValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GuardianValidator.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 *GuardianValidator) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GuardianValidator.Merge(m, src)
-}
-func (m *GuardianValidator) XXX_Size() int {
-	return m.Size()
-}
-func (m *GuardianValidator) XXX_DiscardUnknown() {
-	xxx_messageInfo_GuardianValidator.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GuardianValidator proto.InternalMessageInfo
-
-func (m *GuardianValidator) GetGuardianKey() []byte {
-	if m != nil {
-		return m.GuardianKey
-	}
-	return nil
-}
-
-func (m *GuardianValidator) GetValidatorAddr() []byte {
-	if m != nil {
-		return m.ValidatorAddr
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*GuardianValidator)(nil), "certusone.wormholechain.wormhole.GuardianValidator")
-}
-
-func init() { proto.RegisterFile("wormhole/guardian_validator.proto", fileDescriptor_a7e08ab792af660a) }
-
-var fileDescriptor_a7e08ab792af660a = []byte{
-	// 188 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x2c, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x4f, 0x2f, 0x4d, 0x2c, 0x4a, 0xc9, 0x4c, 0xcc, 0x8b, 0x2f, 0x4b,
-	0xcc, 0xc9, 0x4c, 0x49, 0x2c, 0xc9, 0x2f, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48,
-	0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce, 0xcf, 0x4b, 0xd5, 0x83, 0x29, 0x4e, 0xce, 0x48, 0xcc, 0xcc,
-	0x83, 0xf3, 0x94, 0xa2, 0xb9, 0x04, 0xdd, 0xa1, 0xba, 0xc3, 0x60, 0x9a, 0x85, 0x14, 0xb8, 0xb8,
-	0x61, 0x46, 0x7a, 0xa7, 0x56, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x04, 0x21, 0x0b, 0x09, 0xa9,
-	0x70, 0xf1, 0xc2, 0xed, 0x72, 0x4c, 0x49, 0x29, 0x92, 0x60, 0x02, 0xab, 0x41, 0x15, 0x74, 0xf2,
-	0x3b, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96,
-	0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x93, 0xf4, 0xcc, 0x92, 0x8c,
-	0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0xb8, 0x1b, 0xf5, 0x61, 0xae, 0xd2, 0x05, 0x3b, 0x52,
-	0xbf, 0x02, 0x2e, 0xa0, 0x5f, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0xf6, 0x95, 0x31, 0x20,
-	0x00, 0x00, 0xff, 0xff, 0x8b, 0x11, 0xf2, 0xe1, 0xfa, 0x00, 0x00, 0x00,
-}
-
-func (m *GuardianValidator) 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 *GuardianValidator) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GuardianValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.ValidatorAddr) > 0 {
-		i -= len(m.ValidatorAddr)
-		copy(dAtA[i:], m.ValidatorAddr)
-		i = encodeVarintGuardianValidator(dAtA, i, uint64(len(m.ValidatorAddr)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.GuardianKey) > 0 {
-		i -= len(m.GuardianKey)
-		copy(dAtA[i:], m.GuardianKey)
-		i = encodeVarintGuardianValidator(dAtA, i, uint64(len(m.GuardianKey)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGuardianValidator(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGuardianValidator(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *GuardianValidator) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.GuardianKey)
-	if l > 0 {
-		n += 1 + l + sovGuardianValidator(uint64(l))
-	}
-	l = len(m.ValidatorAddr)
-	if l > 0 {
-		n += 1 + l + sovGuardianValidator(uint64(l))
-	}
-	return n
-}
-
-func sovGuardianValidator(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGuardianValidator(x uint64) (n int) {
-	return sovGuardianValidator(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *GuardianValidator) 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 ErrIntOverflowGuardianValidator
-			}
-			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: GuardianValidator: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GuardianValidator: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianValidator
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGuardianValidator
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGuardianValidator
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.GuardianKey == nil {
-				m.GuardianKey = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGuardianValidator
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGuardianValidator
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGuardianValidator
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...)
-			if m.ValidatorAddr == nil {
-				m.ValidatorAddr = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGuardianValidator(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGuardianValidator
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGuardianValidator(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGuardianValidator
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianValidator
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGuardianValidator
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGuardianValidator
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGuardianValidator
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGuardianValidator
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGuardianValidator        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGuardianValidator          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGuardianValidator = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/message_wasmd.go

@@ -0,0 +1,58 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var _ sdk.Msg = &MsgInstantiateContract{}
+var _ sdk.Msg = &MsgStoreCode{}
+
+func (msg *MsgInstantiateContract) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgInstantiateContract) Type() string {
+	return "InstantiateContract"
+}
+
+func (msg *MsgInstantiateContract) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{signer}
+}
+
+func (msg *MsgInstantiateContract) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgInstantiateContract) ValidateBasic() error {
+	return msg.ToWasmd().ValidateBasic()
+}
+
+func (msg *MsgStoreCode) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgStoreCode) Type() string {
+	return "StoreCode"
+}
+
+func (msg *MsgStoreCode) GetSigners() []sdk.AccAddress {
+	signer, err := sdk.AccAddressFromBech32(msg.Signer)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{signer}
+}
+
+func (msg *MsgStoreCode) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+func (msg *MsgStoreCode) ValidateBasic() error {
+	return msg.ToWasmd().ValidateBasic()
+}

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

@@ -1,4570 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/query.proto
-
-package types
-
-import (
-	context "context"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	query "github.com/cosmos/cosmos-sdk/types/query"
-	_ "github.com/gogo/protobuf/gogoproto"
-	grpc1 "github.com/gogo/protobuf/grpc"
-	proto "github.com/gogo/protobuf/proto"
-	_ "google.golang.org/genproto/googleapis/api/annotations"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type QueryGetGuardianSetRequest struct {
-	Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *QueryGetGuardianSetRequest) Reset()         { *m = QueryGetGuardianSetRequest{} }
-func (m *QueryGetGuardianSetRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetGuardianSetRequest) ProtoMessage()    {}
-func (*QueryGetGuardianSetRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{0}
-}
-func (m *QueryGetGuardianSetRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetGuardianSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetGuardianSetRequest.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 *QueryGetGuardianSetRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetGuardianSetRequest.Merge(m, src)
-}
-func (m *QueryGetGuardianSetRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetGuardianSetRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetGuardianSetRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetGuardianSetRequest proto.InternalMessageInfo
-
-func (m *QueryGetGuardianSetRequest) GetIndex() uint32 {
-	if m != nil {
-		return m.Index
-	}
-	return 0
-}
-
-type QueryGetGuardianSetResponse struct {
-	GuardianSet GuardianSet `protobuf:"bytes,1,opt,name=GuardianSet,proto3" json:"GuardianSet"`
-}
-
-func (m *QueryGetGuardianSetResponse) Reset()         { *m = QueryGetGuardianSetResponse{} }
-func (m *QueryGetGuardianSetResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetGuardianSetResponse) ProtoMessage()    {}
-func (*QueryGetGuardianSetResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{1}
-}
-func (m *QueryGetGuardianSetResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetGuardianSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetGuardianSetResponse.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 *QueryGetGuardianSetResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetGuardianSetResponse.Merge(m, src)
-}
-func (m *QueryGetGuardianSetResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetGuardianSetResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetGuardianSetResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetGuardianSetResponse proto.InternalMessageInfo
-
-func (m *QueryGetGuardianSetResponse) GetGuardianSet() GuardianSet {
-	if m != nil {
-		return m.GuardianSet
-	}
-	return GuardianSet{}
-}
-
-type QueryAllGuardianSetRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllGuardianSetRequest) Reset()         { *m = QueryAllGuardianSetRequest{} }
-func (m *QueryAllGuardianSetRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllGuardianSetRequest) ProtoMessage()    {}
-func (*QueryAllGuardianSetRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{2}
-}
-func (m *QueryAllGuardianSetRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllGuardianSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllGuardianSetRequest.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 *QueryAllGuardianSetRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllGuardianSetRequest.Merge(m, src)
-}
-func (m *QueryAllGuardianSetRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllGuardianSetRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllGuardianSetRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllGuardianSetRequest proto.InternalMessageInfo
-
-func (m *QueryAllGuardianSetRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllGuardianSetResponse struct {
-	GuardianSet []GuardianSet       `protobuf:"bytes,1,rep,name=GuardianSet,proto3" json:"GuardianSet"`
-	Pagination  *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllGuardianSetResponse) Reset()         { *m = QueryAllGuardianSetResponse{} }
-func (m *QueryAllGuardianSetResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllGuardianSetResponse) ProtoMessage()    {}
-func (*QueryAllGuardianSetResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{3}
-}
-func (m *QueryAllGuardianSetResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllGuardianSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllGuardianSetResponse.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 *QueryAllGuardianSetResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllGuardianSetResponse.Merge(m, src)
-}
-func (m *QueryAllGuardianSetResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllGuardianSetResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllGuardianSetResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllGuardianSetResponse proto.InternalMessageInfo
-
-func (m *QueryAllGuardianSetResponse) GetGuardianSet() []GuardianSet {
-	if m != nil {
-		return m.GuardianSet
-	}
-	return nil
-}
-
-func (m *QueryAllGuardianSetResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryGetConfigRequest struct {
-}
-
-func (m *QueryGetConfigRequest) Reset()         { *m = QueryGetConfigRequest{} }
-func (m *QueryGetConfigRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetConfigRequest) ProtoMessage()    {}
-func (*QueryGetConfigRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{4}
-}
-func (m *QueryGetConfigRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConfigRequest.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 *QueryGetConfigRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConfigRequest.Merge(m, src)
-}
-func (m *QueryGetConfigRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConfigRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConfigRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConfigRequest proto.InternalMessageInfo
-
-type QueryGetConfigResponse struct {
-	Config Config `protobuf:"bytes,1,opt,name=Config,proto3" json:"Config"`
-}
-
-func (m *QueryGetConfigResponse) Reset()         { *m = QueryGetConfigResponse{} }
-func (m *QueryGetConfigResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetConfigResponse) ProtoMessage()    {}
-func (*QueryGetConfigResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{5}
-}
-func (m *QueryGetConfigResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConfigResponse.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 *QueryGetConfigResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConfigResponse.Merge(m, src)
-}
-func (m *QueryGetConfigResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConfigResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConfigResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConfigResponse proto.InternalMessageInfo
-
-func (m *QueryGetConfigResponse) GetConfig() Config {
-	if m != nil {
-		return m.Config
-	}
-	return Config{}
-}
-
-type QueryGetReplayProtectionRequest struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *QueryGetReplayProtectionRequest) Reset()         { *m = QueryGetReplayProtectionRequest{} }
-func (m *QueryGetReplayProtectionRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetReplayProtectionRequest) ProtoMessage()    {}
-func (*QueryGetReplayProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{6}
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetReplayProtectionRequest.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 *QueryGetReplayProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetReplayProtectionRequest.Merge(m, src)
-}
-func (m *QueryGetReplayProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetReplayProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetReplayProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetReplayProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryGetReplayProtectionRequest) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-type QueryGetReplayProtectionResponse struct {
-	ReplayProtection ReplayProtection `protobuf:"bytes,1,opt,name=replayProtection,proto3" json:"replayProtection"`
-}
-
-func (m *QueryGetReplayProtectionResponse) Reset()         { *m = QueryGetReplayProtectionResponse{} }
-func (m *QueryGetReplayProtectionResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetReplayProtectionResponse) ProtoMessage()    {}
-func (*QueryGetReplayProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{7}
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetReplayProtectionResponse.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 *QueryGetReplayProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetReplayProtectionResponse.Merge(m, src)
-}
-func (m *QueryGetReplayProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetReplayProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetReplayProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetReplayProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryGetReplayProtectionResponse) GetReplayProtection() ReplayProtection {
-	if m != nil {
-		return m.ReplayProtection
-	}
-	return ReplayProtection{}
-}
-
-type QueryAllReplayProtectionRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllReplayProtectionRequest) Reset()         { *m = QueryAllReplayProtectionRequest{} }
-func (m *QueryAllReplayProtectionRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllReplayProtectionRequest) ProtoMessage()    {}
-func (*QueryAllReplayProtectionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{8}
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllReplayProtectionRequest.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 *QueryAllReplayProtectionRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllReplayProtectionRequest.Merge(m, src)
-}
-func (m *QueryAllReplayProtectionRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllReplayProtectionRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllReplayProtectionRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllReplayProtectionRequest proto.InternalMessageInfo
-
-func (m *QueryAllReplayProtectionRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllReplayProtectionResponse struct {
-	ReplayProtection []ReplayProtection  `protobuf:"bytes,1,rep,name=replayProtection,proto3" json:"replayProtection"`
-	Pagination       *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllReplayProtectionResponse) Reset()         { *m = QueryAllReplayProtectionResponse{} }
-func (m *QueryAllReplayProtectionResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllReplayProtectionResponse) ProtoMessage()    {}
-func (*QueryAllReplayProtectionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{9}
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllReplayProtectionResponse.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 *QueryAllReplayProtectionResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllReplayProtectionResponse.Merge(m, src)
-}
-func (m *QueryAllReplayProtectionResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllReplayProtectionResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllReplayProtectionResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllReplayProtectionResponse proto.InternalMessageInfo
-
-func (m *QueryAllReplayProtectionResponse) GetReplayProtection() []ReplayProtection {
-	if m != nil {
-		return m.ReplayProtection
-	}
-	return nil
-}
-
-func (m *QueryAllReplayProtectionResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryGetSequenceCounterRequest struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *QueryGetSequenceCounterRequest) Reset()         { *m = QueryGetSequenceCounterRequest{} }
-func (m *QueryGetSequenceCounterRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetSequenceCounterRequest) ProtoMessage()    {}
-func (*QueryGetSequenceCounterRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{10}
-}
-func (m *QueryGetSequenceCounterRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetSequenceCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetSequenceCounterRequest.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 *QueryGetSequenceCounterRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetSequenceCounterRequest.Merge(m, src)
-}
-func (m *QueryGetSequenceCounterRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetSequenceCounterRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetSequenceCounterRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetSequenceCounterRequest proto.InternalMessageInfo
-
-func (m *QueryGetSequenceCounterRequest) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-type QueryGetSequenceCounterResponse struct {
-	SequenceCounter SequenceCounter `protobuf:"bytes,1,opt,name=sequenceCounter,proto3" json:"sequenceCounter"`
-}
-
-func (m *QueryGetSequenceCounterResponse) Reset()         { *m = QueryGetSequenceCounterResponse{} }
-func (m *QueryGetSequenceCounterResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetSequenceCounterResponse) ProtoMessage()    {}
-func (*QueryGetSequenceCounterResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{11}
-}
-func (m *QueryGetSequenceCounterResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetSequenceCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetSequenceCounterResponse.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 *QueryGetSequenceCounterResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetSequenceCounterResponse.Merge(m, src)
-}
-func (m *QueryGetSequenceCounterResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetSequenceCounterResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetSequenceCounterResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetSequenceCounterResponse proto.InternalMessageInfo
-
-func (m *QueryGetSequenceCounterResponse) GetSequenceCounter() SequenceCounter {
-	if m != nil {
-		return m.SequenceCounter
-	}
-	return SequenceCounter{}
-}
-
-type QueryAllSequenceCounterRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllSequenceCounterRequest) Reset()         { *m = QueryAllSequenceCounterRequest{} }
-func (m *QueryAllSequenceCounterRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllSequenceCounterRequest) ProtoMessage()    {}
-func (*QueryAllSequenceCounterRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{12}
-}
-func (m *QueryAllSequenceCounterRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllSequenceCounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllSequenceCounterRequest.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 *QueryAllSequenceCounterRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllSequenceCounterRequest.Merge(m, src)
-}
-func (m *QueryAllSequenceCounterRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllSequenceCounterRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllSequenceCounterRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllSequenceCounterRequest proto.InternalMessageInfo
-
-func (m *QueryAllSequenceCounterRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllSequenceCounterResponse struct {
-	SequenceCounter []SequenceCounter   `protobuf:"bytes,1,rep,name=sequenceCounter,proto3" json:"sequenceCounter"`
-	Pagination      *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllSequenceCounterResponse) Reset()         { *m = QueryAllSequenceCounterResponse{} }
-func (m *QueryAllSequenceCounterResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllSequenceCounterResponse) ProtoMessage()    {}
-func (*QueryAllSequenceCounterResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{13}
-}
-func (m *QueryAllSequenceCounterResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllSequenceCounterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllSequenceCounterResponse.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 *QueryAllSequenceCounterResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllSequenceCounterResponse.Merge(m, src)
-}
-func (m *QueryAllSequenceCounterResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllSequenceCounterResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllSequenceCounterResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllSequenceCounterResponse proto.InternalMessageInfo
-
-func (m *QueryAllSequenceCounterResponse) GetSequenceCounter() []SequenceCounter {
-	if m != nil {
-		return m.SequenceCounter
-	}
-	return nil
-}
-
-func (m *QueryAllSequenceCounterResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryGetConsensusGuardianSetIndexRequest struct {
-}
-
-func (m *QueryGetConsensusGuardianSetIndexRequest) Reset() {
-	*m = QueryGetConsensusGuardianSetIndexRequest{}
-}
-func (m *QueryGetConsensusGuardianSetIndexRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetConsensusGuardianSetIndexRequest) ProtoMessage()    {}
-func (*QueryGetConsensusGuardianSetIndexRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{14}
-}
-func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.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 *QueryGetConsensusGuardianSetIndexRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.Merge(m, src)
-}
-func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConsensusGuardianSetIndexRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConsensusGuardianSetIndexRequest proto.InternalMessageInfo
-
-type QueryGetConsensusGuardianSetIndexResponse struct {
-	ConsensusGuardianSetIndex ConsensusGuardianSetIndex `protobuf:"bytes,1,opt,name=ConsensusGuardianSetIndex,proto3" json:"ConsensusGuardianSetIndex"`
-}
-
-func (m *QueryGetConsensusGuardianSetIndexResponse) Reset() {
-	*m = QueryGetConsensusGuardianSetIndexResponse{}
-}
-func (m *QueryGetConsensusGuardianSetIndexResponse) String() string {
-	return proto.CompactTextString(m)
-}
-func (*QueryGetConsensusGuardianSetIndexResponse) ProtoMessage() {}
-func (*QueryGetConsensusGuardianSetIndexResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{15}
-}
-func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.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 *QueryGetConsensusGuardianSetIndexResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.Merge(m, src)
-}
-func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetConsensusGuardianSetIndexResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetConsensusGuardianSetIndexResponse proto.InternalMessageInfo
-
-func (m *QueryGetConsensusGuardianSetIndexResponse) GetConsensusGuardianSetIndex() ConsensusGuardianSetIndex {
-	if m != nil {
-		return m.ConsensusGuardianSetIndex
-	}
-	return ConsensusGuardianSetIndex{}
-}
-
-type QueryGetGuardianValidatorRequest struct {
-	GuardianKey []byte `protobuf:"bytes,1,opt,name=guardianKey,proto3" json:"guardianKey,omitempty"`
-}
-
-func (m *QueryGetGuardianValidatorRequest) Reset()         { *m = QueryGetGuardianValidatorRequest{} }
-func (m *QueryGetGuardianValidatorRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryGetGuardianValidatorRequest) ProtoMessage()    {}
-func (*QueryGetGuardianValidatorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{16}
-}
-func (m *QueryGetGuardianValidatorRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetGuardianValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetGuardianValidatorRequest.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 *QueryGetGuardianValidatorRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetGuardianValidatorRequest.Merge(m, src)
-}
-func (m *QueryGetGuardianValidatorRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetGuardianValidatorRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetGuardianValidatorRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetGuardianValidatorRequest proto.InternalMessageInfo
-
-func (m *QueryGetGuardianValidatorRequest) GetGuardianKey() []byte {
-	if m != nil {
-		return m.GuardianKey
-	}
-	return nil
-}
-
-type QueryGetGuardianValidatorResponse struct {
-	GuardianValidator GuardianValidator `protobuf:"bytes,1,opt,name=guardianValidator,proto3" json:"guardianValidator"`
-}
-
-func (m *QueryGetGuardianValidatorResponse) Reset()         { *m = QueryGetGuardianValidatorResponse{} }
-func (m *QueryGetGuardianValidatorResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryGetGuardianValidatorResponse) ProtoMessage()    {}
-func (*QueryGetGuardianValidatorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{17}
-}
-func (m *QueryGetGuardianValidatorResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryGetGuardianValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryGetGuardianValidatorResponse.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 *QueryGetGuardianValidatorResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryGetGuardianValidatorResponse.Merge(m, src)
-}
-func (m *QueryGetGuardianValidatorResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryGetGuardianValidatorResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryGetGuardianValidatorResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryGetGuardianValidatorResponse proto.InternalMessageInfo
-
-func (m *QueryGetGuardianValidatorResponse) GetGuardianValidator() GuardianValidator {
-	if m != nil {
-		return m.GuardianValidator
-	}
-	return GuardianValidator{}
-}
-
-type QueryAllGuardianValidatorRequest struct {
-	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllGuardianValidatorRequest) Reset()         { *m = QueryAllGuardianValidatorRequest{} }
-func (m *QueryAllGuardianValidatorRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryAllGuardianValidatorRequest) ProtoMessage()    {}
-func (*QueryAllGuardianValidatorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{18}
-}
-func (m *QueryAllGuardianValidatorRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllGuardianValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllGuardianValidatorRequest.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 *QueryAllGuardianValidatorRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllGuardianValidatorRequest.Merge(m, src)
-}
-func (m *QueryAllGuardianValidatorRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllGuardianValidatorRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllGuardianValidatorRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllGuardianValidatorRequest proto.InternalMessageInfo
-
-func (m *QueryAllGuardianValidatorRequest) GetPagination() *query.PageRequest {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryAllGuardianValidatorResponse struct {
-	GuardianValidator []GuardianValidator `protobuf:"bytes,1,rep,name=guardianValidator,proto3" json:"guardianValidator"`
-	Pagination        *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-}
-
-func (m *QueryAllGuardianValidatorResponse) Reset()         { *m = QueryAllGuardianValidatorResponse{} }
-func (m *QueryAllGuardianValidatorResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryAllGuardianValidatorResponse) ProtoMessage()    {}
-func (*QueryAllGuardianValidatorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{19}
-}
-func (m *QueryAllGuardianValidatorResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryAllGuardianValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryAllGuardianValidatorResponse.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 *QueryAllGuardianValidatorResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryAllGuardianValidatorResponse.Merge(m, src)
-}
-func (m *QueryAllGuardianValidatorResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryAllGuardianValidatorResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryAllGuardianValidatorResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryAllGuardianValidatorResponse proto.InternalMessageInfo
-
-func (m *QueryAllGuardianValidatorResponse) GetGuardianValidator() []GuardianValidator {
-	if m != nil {
-		return m.GuardianValidator
-	}
-	return nil
-}
-
-func (m *QueryAllGuardianValidatorResponse) GetPagination() *query.PageResponse {
-	if m != nil {
-		return m.Pagination
-	}
-	return nil
-}
-
-type QueryLatestGuardianSetIndexRequest struct {
-}
-
-func (m *QueryLatestGuardianSetIndexRequest) Reset()         { *m = QueryLatestGuardianSetIndexRequest{} }
-func (m *QueryLatestGuardianSetIndexRequest) String() string { return proto.CompactTextString(m) }
-func (*QueryLatestGuardianSetIndexRequest) ProtoMessage()    {}
-func (*QueryLatestGuardianSetIndexRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{20}
-}
-func (m *QueryLatestGuardianSetIndexRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryLatestGuardianSetIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryLatestGuardianSetIndexRequest.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 *QueryLatestGuardianSetIndexRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryLatestGuardianSetIndexRequest.Merge(m, src)
-}
-func (m *QueryLatestGuardianSetIndexRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryLatestGuardianSetIndexRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryLatestGuardianSetIndexRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryLatestGuardianSetIndexRequest proto.InternalMessageInfo
-
-type QueryLatestGuardianSetIndexResponse struct {
-	LatestGuardianSetIndex uint32 `protobuf:"varint,1,opt,name=latestGuardianSetIndex,proto3" json:"latestGuardianSetIndex,omitempty"`
-}
-
-func (m *QueryLatestGuardianSetIndexResponse) Reset()         { *m = QueryLatestGuardianSetIndexResponse{} }
-func (m *QueryLatestGuardianSetIndexResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryLatestGuardianSetIndexResponse) ProtoMessage()    {}
-func (*QueryLatestGuardianSetIndexResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_273185ecc792fa38, []int{21}
-}
-func (m *QueryLatestGuardianSetIndexResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryLatestGuardianSetIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryLatestGuardianSetIndexResponse.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 *QueryLatestGuardianSetIndexResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryLatestGuardianSetIndexResponse.Merge(m, src)
-}
-func (m *QueryLatestGuardianSetIndexResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryLatestGuardianSetIndexResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryLatestGuardianSetIndexResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryLatestGuardianSetIndexResponse proto.InternalMessageInfo
-
-func (m *QueryLatestGuardianSetIndexResponse) GetLatestGuardianSetIndex() uint32 {
-	if m != nil {
-		return m.LatestGuardianSetIndex
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*QueryGetGuardianSetRequest)(nil), "certusone.wormholechain.wormhole.QueryGetGuardianSetRequest")
-	proto.RegisterType((*QueryGetGuardianSetResponse)(nil), "certusone.wormholechain.wormhole.QueryGetGuardianSetResponse")
-	proto.RegisterType((*QueryAllGuardianSetRequest)(nil), "certusone.wormholechain.wormhole.QueryAllGuardianSetRequest")
-	proto.RegisterType((*QueryAllGuardianSetResponse)(nil), "certusone.wormholechain.wormhole.QueryAllGuardianSetResponse")
-	proto.RegisterType((*QueryGetConfigRequest)(nil), "certusone.wormholechain.wormhole.QueryGetConfigRequest")
-	proto.RegisterType((*QueryGetConfigResponse)(nil), "certusone.wormholechain.wormhole.QueryGetConfigResponse")
-	proto.RegisterType((*QueryGetReplayProtectionRequest)(nil), "certusone.wormholechain.wormhole.QueryGetReplayProtectionRequest")
-	proto.RegisterType((*QueryGetReplayProtectionResponse)(nil), "certusone.wormholechain.wormhole.QueryGetReplayProtectionResponse")
-	proto.RegisterType((*QueryAllReplayProtectionRequest)(nil), "certusone.wormholechain.wormhole.QueryAllReplayProtectionRequest")
-	proto.RegisterType((*QueryAllReplayProtectionResponse)(nil), "certusone.wormholechain.wormhole.QueryAllReplayProtectionResponse")
-	proto.RegisterType((*QueryGetSequenceCounterRequest)(nil), "certusone.wormholechain.wormhole.QueryGetSequenceCounterRequest")
-	proto.RegisterType((*QueryGetSequenceCounterResponse)(nil), "certusone.wormholechain.wormhole.QueryGetSequenceCounterResponse")
-	proto.RegisterType((*QueryAllSequenceCounterRequest)(nil), "certusone.wormholechain.wormhole.QueryAllSequenceCounterRequest")
-	proto.RegisterType((*QueryAllSequenceCounterResponse)(nil), "certusone.wormholechain.wormhole.QueryAllSequenceCounterResponse")
-	proto.RegisterType((*QueryGetConsensusGuardianSetIndexRequest)(nil), "certusone.wormholechain.wormhole.QueryGetConsensusGuardianSetIndexRequest")
-	proto.RegisterType((*QueryGetConsensusGuardianSetIndexResponse)(nil), "certusone.wormholechain.wormhole.QueryGetConsensusGuardianSetIndexResponse")
-	proto.RegisterType((*QueryGetGuardianValidatorRequest)(nil), "certusone.wormholechain.wormhole.QueryGetGuardianValidatorRequest")
-	proto.RegisterType((*QueryGetGuardianValidatorResponse)(nil), "certusone.wormholechain.wormhole.QueryGetGuardianValidatorResponse")
-	proto.RegisterType((*QueryAllGuardianValidatorRequest)(nil), "certusone.wormholechain.wormhole.QueryAllGuardianValidatorRequest")
-	proto.RegisterType((*QueryAllGuardianValidatorResponse)(nil), "certusone.wormholechain.wormhole.QueryAllGuardianValidatorResponse")
-	proto.RegisterType((*QueryLatestGuardianSetIndexRequest)(nil), "certusone.wormholechain.wormhole.QueryLatestGuardianSetIndexRequest")
-	proto.RegisterType((*QueryLatestGuardianSetIndexResponse)(nil), "certusone.wormholechain.wormhole.QueryLatestGuardianSetIndexResponse")
-}
-
-func init() { proto.RegisterFile("wormhole/query.proto", fileDescriptor_273185ecc792fa38) }
-
-var fileDescriptor_273185ecc792fa38 = []byte{
-	// 1111 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x98, 0xcf, 0x6f, 0x1b, 0x45,
-	0x14, 0xc7, 0x33, 0x0d, 0xad, 0xc4, 0x04, 0x68, 0x3b, 0xa4, 0x01, 0xb6, 0xc8, 0x71, 0x07, 0x04,
-	0x21, 0x28, 0xbb, 0xc4, 0x49, 0x13, 0xda, 0x24, 0x28, 0x76, 0x42, 0x22, 0x5a, 0x84, 0x8a, 0x23,
-	0x38, 0x20, 0x21, 0xb3, 0xb1, 0x87, 0xcd, 0xa2, 0xcd, 0x8e, 0xeb, 0x1d, 0x97, 0x5a, 0x55, 0x85,
-	0x84, 0x38, 0x70, 0xe0, 0x80, 0xc4, 0xbf, 0x01, 0x7f, 0x02, 0x37, 0x0e, 0xe5, 0x80, 0x54, 0x04,
-	0x48, 0xe1, 0x00, 0x42, 0x09, 0x07, 0xc4, 0x85, 0x7f, 0x80, 0x43, 0xb5, 0xb3, 0x6f, 0xd7, 0xeb,
-	0xf5, 0xfe, 0x72, 0xbc, 0x37, 0x7b, 0x66, 0xde, 0x9b, 0xef, 0x67, 0xde, 0xcb, 0xcc, 0x37, 0xc6,
-	0xd3, 0x9f, 0xf2, 0xce, 0xe1, 0x01, 0xb7, 0x98, 0x76, 0xbb, 0xcb, 0x3a, 0x3d, 0xb5, 0xdd, 0xe1,
-	0x82, 0x93, 0x72, 0x93, 0x75, 0x44, 0xd7, 0xe1, 0x36, 0x53, 0xfd, 0xf9, 0xe6, 0x81, 0x6e, 0xda,
-	0xc1, 0x37, 0xe5, 0x79, 0x83, 0x73, 0xc3, 0x62, 0x9a, 0xde, 0x36, 0x35, 0xdd, 0xb6, 0xb9, 0xd0,
-	0x85, 0xc9, 0x6d, 0xc7, 0x8b, 0x57, 0xe6, 0x9b, 0xdc, 0x39, 0xe4, 0x8e, 0xb6, 0xaf, 0x3b, 0x90,
-	0x58, 0xbb, 0xb3, 0xb8, 0xcf, 0x84, 0xbe, 0xa8, 0xb5, 0x75, 0xc3, 0xb4, 0xe5, 0x62, 0x58, 0x7b,
-	0x39, 0x50, 0x60, 0x74, 0xf5, 0x4e, 0xcb, 0xd4, 0xed, 0x86, 0xc3, 0x04, 0x4c, 0x5e, 0x0a, 0x26,
-	0x9b, 0xdc, 0xfe, 0xd8, 0x34, 0x60, 0xb8, 0x1c, 0x0c, 0x77, 0x58, 0xdb, 0xd2, 0x7b, 0x0d, 0x77,
-	0x98, 0x35, 0x43, 0x59, 0x67, 0x83, 0x15, 0x0e, 0xbb, 0xdd, 0x65, 0x76, 0x93, 0x35, 0x9a, 0xbc,
-	0x6b, 0x0b, 0xd6, 0x81, 0x05, 0xaf, 0x86, 0x33, 0x3b, 0xcc, 0x76, 0xba, 0x4e, 0x23, 0x2c, 0xa0,
-	0x61, 0xda, 0x2d, 0x76, 0x17, 0x16, 0x5f, 0x19, 0xd6, 0x78, 0x47, 0xb7, 0xcc, 0x96, 0x2e, 0xb8,
-	0x9f, 0x6f, 0xda, 0xe0, 0x06, 0x97, 0x1f, 0x35, 0xf7, 0x93, 0x37, 0x4a, 0x2b, 0x58, 0x79, 0xd7,
-	0xc5, 0xdf, 0x65, 0x62, 0x17, 0x22, 0xf7, 0x98, 0xa8, 0xbb, 0x92, 0x1c, 0x41, 0xa6, 0xf1, 0x59,
-	0xb9, 0xcb, 0xb3, 0xa8, 0x8c, 0xe6, 0x9e, 0xac, 0x7b, 0x5f, 0xa8, 0xc0, 0x97, 0x63, 0x63, 0x9c,
-	0xb6, 0x2b, 0x94, 0xbc, 0x87, 0xa7, 0x42, 0xc3, 0x32, 0x74, 0xaa, 0xb2, 0xa0, 0x66, 0x55, 0x4c,
-	0x0d, 0x05, 0xd5, 0x1e, 0x7b, 0xf0, 0xe7, 0xec, 0x44, 0x3d, 0x9c, 0x87, 0xb6, 0x40, 0x69, 0xd5,
-	0xb2, 0x62, 0x94, 0xee, 0x60, 0xdc, 0x2f, 0x1c, 0xec, 0xf9, 0x92, 0xea, 0x55, 0x59, 0x75, 0xab,
-	0xac, 0x7a, 0xed, 0x03, 0x55, 0x56, 0x6f, 0xe9, 0x06, 0x83, 0xd8, 0x7a, 0x28, 0x92, 0x7e, 0x8f,
-	0x00, 0x2e, 0xba, 0x4d, 0x12, 0xdc, 0x64, 0x11, 0x70, 0x64, 0x77, 0x40, 0xfe, 0x19, 0x29, 0xff,
-	0xe5, 0x4c, 0xf9, 0x9e, 0xa6, 0x01, 0xfd, 0xcf, 0xe0, 0x4b, 0x7e, 0x6d, 0xb6, 0x64, 0x43, 0x02,
-	0x24, 0xfd, 0x08, 0xcf, 0x44, 0x27, 0x00, 0x69, 0x07, 0x9f, 0xf3, 0x46, 0xe0, 0xd8, 0xe6, 0xb2,
-	0x69, 0xbc, 0xf5, 0x00, 0x02, 0xd1, 0x74, 0x15, 0xcf, 0xfa, 0x3b, 0xd4, 0x65, 0xd3, 0xdf, 0x0a,
-	0x7a, 0x3e, 0xb6, 0x9f, 0x1e, 0xf7, 0xfb, 0xe9, 0x4b, 0x84, 0xcb, 0xc9, 0x91, 0xa0, 0xb2, 0x85,
-	0x2f, 0x74, 0x22, 0x73, 0xa0, 0xb7, 0x92, 0xad, 0x37, 0x9a, 0x15, 0x94, 0x0f, 0x65, 0xa4, 0x26,
-	0x30, 0x54, 0x2d, 0x2b, 0x89, 0xa1, 0xa8, 0x4e, 0xfb, 0xd9, 0xa7, 0x8e, 0xdd, 0x2b, 0x95, 0x7a,
-	0xb2, 0x58, 0xea, 0xe2, 0xba, 0x6f, 0x05, 0x97, 0xfc, 0x42, 0xee, 0xc1, 0xad, 0xb6, 0xe5, 0x5d,
-	0x6a, 0xe9, 0x1d, 0xf0, 0x05, 0xea, 0xf7, 0xce, 0x50, 0x20, 0x1c, 0x85, 0x8e, 0xcf, 0x3b, 0x83,
-	0x53, 0x70, 0xf8, 0x8b, 0xd9, 0x27, 0x11, 0xc9, 0x09, 0x07, 0x11, 0xcd, 0x47, 0x0f, 0x40, 0x7e,
-	0xd5, 0xb2, 0x12, 0xe4, 0x17, 0x55, 0xfc, 0x9f, 0x50, 0xbf, 0xd1, 0x46, 0x02, 0x9e, 0x2c, 0x12,
-	0xb8, 0xb8, 0xc2, 0xcf, 0xe3, 0xb9, 0xd0, 0xed, 0xe2, 0xbd, 0x56, 0xa1, 0xfb, 0xed, 0x2d, 0xb7,
-	0xca, 0xfe, 0x4d, 0xf4, 0x2d, 0xc2, 0xaf, 0xe4, 0x58, 0x0c, 0xa7, 0xf0, 0x19, 0x7e, 0x2e, 0x71,
-	0x11, 0x14, 0x60, 0x2d, 0xd7, 0x85, 0x15, 0x9f, 0x02, 0x4e, 0x26, 0x79, 0x0f, 0xba, 0xdd, 0xbf,
-	0x9c, 0xfc, 0xb9, 0xf7, 0xfd, 0xa7, 0xd5, 0x6f, 0x8b, 0x32, 0x9e, 0xf2, 0xdf, 0xdd, 0x9b, 0xac,
-	0x27, 0x65, 0x3d, 0x51, 0x0f, 0x0f, 0xd1, 0xaf, 0x10, 0xbe, 0x92, 0x92, 0x06, 0x60, 0x0d, 0x7c,
-	0xd1, 0x88, 0x4e, 0x02, 0xe4, 0x52, 0xfe, 0x37, 0x26, 0x08, 0x05, 0xb8, 0xe1, 0x9c, 0xf4, 0x93,
-	0xfe, 0xdd, 0x93, 0x08, 0x55, 0x54, 0xaf, 0xff, 0xe6, 0xa3, 0xc7, 0x6f, 0x96, 0x8e, 0x3e, 0x59,
-	0x34, 0x7a, 0x71, 0x3d, 0xff, 0x22, 0xa6, 0x12, 0xeb, 0x6d, 0x5d, 0x30, 0x47, 0x24, 0x75, 0xfb,
-	0x87, 0xf8, 0x85, 0xd4, 0x55, 0x80, 0xbf, 0x82, 0x67, 0xac, 0xd8, 0x15, 0x60, 0xbd, 0x12, 0x66,
-	0x2b, 0xff, 0x11, 0x7c, 0x56, 0xe6, 0x27, 0x3f, 0xa2, 0x01, 0x6b, 0x42, 0xd6, 0xb3, 0x4f, 0x2d,
-	0xd9, 0xf9, 0x29, 0x1b, 0xa7, 0x8c, 0xf6, 0x70, 0xe8, 0xc6, 0xe7, 0xbf, 0xfc, 0xfd, 0xcd, 0x99,
-	0x55, 0x72, 0x55, 0x0b, 0xd2, 0x68, 0x03, 0x69, 0xb4, 0x21, 0xc3, 0xba, 0xc7, 0x84, 0x76, 0x4f,
-	0x3e, 0x07, 0xf7, 0xc9, 0x0f, 0x08, 0x3f, 0x15, 0x4a, 0x5b, 0xb5, 0xac, 0xdc, 0x38, 0xb1, 0xf6,
-	0x30, 0x37, 0x4e, 0xbc, 0xeb, 0xa3, 0x57, 0x25, 0x8e, 0x46, 0x16, 0x46, 0xc2, 0x21, 0xdf, 0x21,
-	0xdf, 0x5a, 0x91, 0xd5, 0xfc, 0xe7, 0x39, 0xe0, 0xdb, 0x94, 0xd7, 0x47, 0x0f, 0x04, 0xd1, 0xaf,
-	0x49, 0xd1, 0xf3, 0x64, 0x2e, 0x5b, 0xb4, 0xf7, 0xbf, 0x0b, 0xf9, 0x03, 0xe1, 0x0b, 0x51, 0xd3,
-	0x40, 0xaa, 0xf9, 0x05, 0x24, 0x58, 0x26, 0xa5, 0x36, 0x4e, 0x0a, 0xa0, 0xa9, 0x49, 0x9a, 0x75,
-	0x72, 0x3d, 0x9b, 0x26, 0xea, 0x6f, 0x82, 0xb6, 0x3a, 0x42, 0xf8, 0xe9, 0xe8, 0x06, 0x6e, 0x6f,
-	0x55, 0xf3, 0x77, 0xc7, 0xb8, 0x88, 0x29, 0x66, 0x8f, 0x5e, 0x97, 0x88, 0xcb, 0xa4, 0x32, 0x3a,
-	0x22, 0xf9, 0x1d, 0xe1, 0xf3, 0x91, 0x47, 0x9f, 0x6c, 0xe6, 0x3f, 0xf6, 0x78, 0xbb, 0xa3, 0x54,
-	0xc7, 0xc8, 0x00, 0x50, 0x55, 0x09, 0xb5, 0x46, 0xae, 0x65, 0x43, 0x45, 0xdc, 0x49, 0x50, 0xb6,
-	0x5f, 0x11, 0x26, 0x91, 0xf4, 0x6e, 0xd5, 0x36, 0xf3, 0x1f, 0xf9, 0x98, 0x78, 0xc9, 0x26, 0x8d,
-	0x5e, 0x93, 0x78, 0x4b, 0x64, 0x71, 0x64, 0x3c, 0xf2, 0x3f, 0x4a, 0xb1, 0x36, 0xe4, 0xc6, 0x48,
-	0x7f, 0xf7, 0xa9, 0x8e, 0x4b, 0xb9, 0x59, 0x48, 0x2e, 0x20, 0xde, 0x91, 0xc4, 0x9b, 0xe4, 0x8d,
-	0x5c, 0xd7, 0x4a, 0xe2, 0x0f, 0x17, 0xe4, 0x1f, 0x84, 0x2f, 0x0e, 0x3d, 0xdb, 0xa4, 0x36, 0xfa,
-	0xbb, 0x13, 0x35, 0x2e, 0xca, 0xd6, 0x58, 0x39, 0x00, 0xf3, 0x86, 0xc4, 0xdc, 0x26, 0xb5, 0xfc,
-	0x57, 0x7e, 0xff, 0x27, 0x17, 0xed, 0x5e, 0xc8, 0xfb, 0xdd, 0x77, 0xef, 0xd5, 0xe9, 0xa1, 0x9d,
-	0xdc, 0x16, 0xae, 0x8d, 0xfe, 0x2c, 0x9d, 0x9a, 0x36, 0xcd, 0x7d, 0xd1, 0x75, 0x49, 0xbb, 0x42,
-	0x96, 0x4f, 0x43, 0x4b, 0xfe, 0x45, 0x78, 0x26, 0xde, 0xdf, 0x90, 0xed, 0x9c, 0xea, 0x52, 0x4d,
-	0x94, 0xf2, 0xe6, 0x98, 0x59, 0x80, 0x72, 0x4b, 0x52, 0x6e, 0x90, 0xb5, 0x6c, 0x4a, 0xcf, 0x6e,
-	0xc5, 0xf4, 0x6d, 0xed, 0x9d, 0x07, 0xc7, 0x25, 0xf4, 0xf0, 0xb8, 0x84, 0xfe, 0x3a, 0x2e, 0xa1,
-	0xaf, 0x4f, 0x4a, 0x13, 0x0f, 0x4f, 0x4a, 0x13, 0x47, 0x27, 0xa5, 0x89, 0x0f, 0x96, 0x0d, 0x53,
-	0x1c, 0x74, 0xf7, 0xd5, 0x26, 0x3f, 0x8c, 0xd9, 0x60, 0xc1, 0xdb, 0xe1, 0x6e, 0x7f, 0x0f, 0xd1,
-	0x6b, 0x33, 0x67, 0xff, 0x9c, 0xfc, 0x21, 0x6e, 0xe9, 0x51, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf7,
-	0xd2, 0x11, 0x3b, 0xe9, 0x14, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// QueryClient is the client API for Query service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type QueryClient interface {
-	// Queries a guardianSet by index.
-	GuardianSet(ctx context.Context, in *QueryGetGuardianSetRequest, opts ...grpc.CallOption) (*QueryGetGuardianSetResponse, error)
-	// Queries a list of guardianSet items.
-	GuardianSetAll(ctx context.Context, in *QueryAllGuardianSetRequest, opts ...grpc.CallOption) (*QueryAllGuardianSetResponse, error)
-	// Queries a config by index.
-	Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error)
-	// Queries a replayProtection by index.
-	ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error)
-	// Queries a list of replayProtection items.
-	ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error)
-	// Queries a sequenceCounter by index.
-	SequenceCounter(ctx context.Context, in *QueryGetSequenceCounterRequest, opts ...grpc.CallOption) (*QueryGetSequenceCounterResponse, error)
-	// Queries a list of sequenceCounter items.
-	SequenceCounterAll(ctx context.Context, in *QueryAllSequenceCounterRequest, opts ...grpc.CallOption) (*QueryAllSequenceCounterResponse, error)
-	// Queries a ConsensusGuardianSetIndex by index.
-	ConsensusGuardianSetIndex(ctx context.Context, in *QueryGetConsensusGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryGetConsensusGuardianSetIndexResponse, error)
-	// Queries a GuardianValidator by index.
-	GuardianValidator(ctx context.Context, in *QueryGetGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryGetGuardianValidatorResponse, error)
-	// Queries a list of GuardianValidator items.
-	GuardianValidatorAll(ctx context.Context, in *QueryAllGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryAllGuardianValidatorResponse, error)
-	// Queries a list of LatestGuardianSetIndex items.
-	LatestGuardianSetIndex(ctx context.Context, in *QueryLatestGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryLatestGuardianSetIndexResponse, error)
-}
-
-type queryClient struct {
-	cc grpc1.ClientConn
-}
-
-func NewQueryClient(cc grpc1.ClientConn) QueryClient {
-	return &queryClient{cc}
-}
-
-func (c *queryClient) GuardianSet(ctx context.Context, in *QueryGetGuardianSetRequest, opts ...grpc.CallOption) (*QueryGetGuardianSetResponse, error) {
-	out := new(QueryGetGuardianSetResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/GuardianSet", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) GuardianSetAll(ctx context.Context, in *QueryAllGuardianSetRequest, opts ...grpc.CallOption) (*QueryAllGuardianSetResponse, error) {
-	out := new(QueryAllGuardianSetResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/GuardianSetAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) Config(ctx context.Context, in *QueryGetConfigRequest, opts ...grpc.CallOption) (*QueryGetConfigResponse, error) {
-	out := new(QueryGetConfigResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/Config", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ReplayProtection(ctx context.Context, in *QueryGetReplayProtectionRequest, opts ...grpc.CallOption) (*QueryGetReplayProtectionResponse, error) {
-	out := new(QueryGetReplayProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/ReplayProtection", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ReplayProtectionAll(ctx context.Context, in *QueryAllReplayProtectionRequest, opts ...grpc.CallOption) (*QueryAllReplayProtectionResponse, error) {
-	out := new(QueryAllReplayProtectionResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/ReplayProtectionAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) SequenceCounter(ctx context.Context, in *QueryGetSequenceCounterRequest, opts ...grpc.CallOption) (*QueryGetSequenceCounterResponse, error) {
-	out := new(QueryGetSequenceCounterResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/SequenceCounter", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) SequenceCounterAll(ctx context.Context, in *QueryAllSequenceCounterRequest, opts ...grpc.CallOption) (*QueryAllSequenceCounterResponse, error) {
-	out := new(QueryAllSequenceCounterResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/SequenceCounterAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) ConsensusGuardianSetIndex(ctx context.Context, in *QueryGetConsensusGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryGetConsensusGuardianSetIndexResponse, error) {
-	out := new(QueryGetConsensusGuardianSetIndexResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/ConsensusGuardianSetIndex", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) GuardianValidator(ctx context.Context, in *QueryGetGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryGetGuardianValidatorResponse, error) {
-	out := new(QueryGetGuardianValidatorResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/GuardianValidator", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) GuardianValidatorAll(ctx context.Context, in *QueryAllGuardianValidatorRequest, opts ...grpc.CallOption) (*QueryAllGuardianValidatorResponse, error) {
-	out := new(QueryAllGuardianValidatorResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/GuardianValidatorAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *queryClient) LatestGuardianSetIndex(ctx context.Context, in *QueryLatestGuardianSetIndexRequest, opts ...grpc.CallOption) (*QueryLatestGuardianSetIndexResponse, error) {
-	out := new(QueryLatestGuardianSetIndexResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Query/LatestGuardianSetIndex", 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.
-	GuardianSet(context.Context, *QueryGetGuardianSetRequest) (*QueryGetGuardianSetResponse, error)
-	// Queries a list of guardianSet items.
-	GuardianSetAll(context.Context, *QueryAllGuardianSetRequest) (*QueryAllGuardianSetResponse, error)
-	// Queries a config by index.
-	Config(context.Context, *QueryGetConfigRequest) (*QueryGetConfigResponse, error)
-	// Queries a replayProtection by index.
-	ReplayProtection(context.Context, *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error)
-	// Queries a list of replayProtection items.
-	ReplayProtectionAll(context.Context, *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error)
-	// Queries a sequenceCounter by index.
-	SequenceCounter(context.Context, *QueryGetSequenceCounterRequest) (*QueryGetSequenceCounterResponse, error)
-	// Queries a list of sequenceCounter items.
-	SequenceCounterAll(context.Context, *QueryAllSequenceCounterRequest) (*QueryAllSequenceCounterResponse, error)
-	// Queries a ConsensusGuardianSetIndex by index.
-	ConsensusGuardianSetIndex(context.Context, *QueryGetConsensusGuardianSetIndexRequest) (*QueryGetConsensusGuardianSetIndexResponse, error)
-	// Queries a GuardianValidator by index.
-	GuardianValidator(context.Context, *QueryGetGuardianValidatorRequest) (*QueryGetGuardianValidatorResponse, error)
-	// Queries a list of GuardianValidator items.
-	GuardianValidatorAll(context.Context, *QueryAllGuardianValidatorRequest) (*QueryAllGuardianValidatorResponse, error)
-	// Queries a list of LatestGuardianSetIndex items.
-	LatestGuardianSetIndex(context.Context, *QueryLatestGuardianSetIndexRequest) (*QueryLatestGuardianSetIndexResponse, error)
-}
-
-// UnimplementedQueryServer can be embedded to have forward compatible implementations.
-type UnimplementedQueryServer struct {
-}
-
-func (*UnimplementedQueryServer) GuardianSet(ctx context.Context, req *QueryGetGuardianSetRequest) (*QueryGetGuardianSetResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GuardianSet not implemented")
-}
-func (*UnimplementedQueryServer) GuardianSetAll(ctx context.Context, req *QueryAllGuardianSetRequest) (*QueryAllGuardianSetResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GuardianSetAll not implemented")
-}
-func (*UnimplementedQueryServer) Config(ctx context.Context, req *QueryGetConfigRequest) (*QueryGetConfigResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Config not implemented")
-}
-func (*UnimplementedQueryServer) ReplayProtection(ctx context.Context, req *QueryGetReplayProtectionRequest) (*QueryGetReplayProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ReplayProtection not implemented")
-}
-func (*UnimplementedQueryServer) ReplayProtectionAll(ctx context.Context, req *QueryAllReplayProtectionRequest) (*QueryAllReplayProtectionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ReplayProtectionAll not implemented")
-}
-func (*UnimplementedQueryServer) SequenceCounter(ctx context.Context, req *QueryGetSequenceCounterRequest) (*QueryGetSequenceCounterResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method SequenceCounter not implemented")
-}
-func (*UnimplementedQueryServer) SequenceCounterAll(ctx context.Context, req *QueryAllSequenceCounterRequest) (*QueryAllSequenceCounterResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method SequenceCounterAll not implemented")
-}
-func (*UnimplementedQueryServer) ConsensusGuardianSetIndex(ctx context.Context, req *QueryGetConsensusGuardianSetIndexRequest) (*QueryGetConsensusGuardianSetIndexResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ConsensusGuardianSetIndex not implemented")
-}
-func (*UnimplementedQueryServer) GuardianValidator(ctx context.Context, req *QueryGetGuardianValidatorRequest) (*QueryGetGuardianValidatorResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GuardianValidator not implemented")
-}
-func (*UnimplementedQueryServer) GuardianValidatorAll(ctx context.Context, req *QueryAllGuardianValidatorRequest) (*QueryAllGuardianValidatorResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GuardianValidatorAll not implemented")
-}
-func (*UnimplementedQueryServer) LatestGuardianSetIndex(ctx context.Context, req *QueryLatestGuardianSetIndexRequest) (*QueryLatestGuardianSetIndexResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method LatestGuardianSetIndex not implemented")
-}
-
-func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
-	s.RegisterService(&_Query_serviceDesc, srv)
-}
-
-func _Query_GuardianSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetGuardianSetRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).GuardianSet(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/GuardianSet",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).GuardianSet(ctx, req.(*QueryGetGuardianSetRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_GuardianSetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllGuardianSetRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).GuardianSetAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/GuardianSetAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).GuardianSetAll(ctx, req.(*QueryAllGuardianSetRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_Config_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetConfigRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).Config(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/Config",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).Config(ctx, req.(*QueryGetConfigRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ReplayProtection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetReplayProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ReplayProtection(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/ReplayProtection",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ReplayProtection(ctx, req.(*QueryGetReplayProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ReplayProtectionAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllReplayProtectionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ReplayProtectionAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/ReplayProtectionAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ReplayProtectionAll(ctx, req.(*QueryAllReplayProtectionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_SequenceCounter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetSequenceCounterRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).SequenceCounter(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/SequenceCounter",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).SequenceCounter(ctx, req.(*QueryGetSequenceCounterRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_SequenceCounterAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllSequenceCounterRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).SequenceCounterAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/SequenceCounterAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).SequenceCounterAll(ctx, req.(*QueryAllSequenceCounterRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_ConsensusGuardianSetIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetConsensusGuardianSetIndexRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).ConsensusGuardianSetIndex(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/ConsensusGuardianSetIndex",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).ConsensusGuardianSetIndex(ctx, req.(*QueryGetConsensusGuardianSetIndexRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_GuardianValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryGetGuardianValidatorRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).GuardianValidator(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/GuardianValidator",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).GuardianValidator(ctx, req.(*QueryGetGuardianValidatorRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_GuardianValidatorAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryAllGuardianValidatorRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).GuardianValidatorAll(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/GuardianValidatorAll",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).GuardianValidatorAll(ctx, req.(*QueryAllGuardianValidatorRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Query_LatestGuardianSetIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryLatestGuardianSetIndexRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).LatestGuardianSetIndex(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Query/LatestGuardianSetIndex",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).LatestGuardianSetIndex(ctx, req.(*QueryLatestGuardianSetIndexRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Query_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "certusone.wormholechain.wormhole.Query",
-	HandlerType: (*QueryServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "GuardianSet",
-			Handler:    _Query_GuardianSet_Handler,
-		},
-		{
-			MethodName: "GuardianSetAll",
-			Handler:    _Query_GuardianSetAll_Handler,
-		},
-		{
-			MethodName: "Config",
-			Handler:    _Query_Config_Handler,
-		},
-		{
-			MethodName: "ReplayProtection",
-			Handler:    _Query_ReplayProtection_Handler,
-		},
-		{
-			MethodName: "ReplayProtectionAll",
-			Handler:    _Query_ReplayProtectionAll_Handler,
-		},
-		{
-			MethodName: "SequenceCounter",
-			Handler:    _Query_SequenceCounter_Handler,
-		},
-		{
-			MethodName: "SequenceCounterAll",
-			Handler:    _Query_SequenceCounterAll_Handler,
-		},
-		{
-			MethodName: "ConsensusGuardianSetIndex",
-			Handler:    _Query_ConsensusGuardianSetIndex_Handler,
-		},
-		{
-			MethodName: "GuardianValidator",
-			Handler:    _Query_GuardianValidator_Handler,
-		},
-		{
-			MethodName: "GuardianValidatorAll",
-			Handler:    _Query_GuardianValidatorAll_Handler,
-		},
-		{
-			MethodName: "LatestGuardianSetIndex",
-			Handler:    _Query_LatestGuardianSetIndex_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "wormhole/query.proto",
-}
-
-func (m *QueryGetGuardianSetRequest) 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 *QueryGetGuardianSetRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetGuardianSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Index != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.Index))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetGuardianSetResponse) 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 *QueryGetGuardianSetResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetGuardianSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.GuardianSet.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 *QueryAllGuardianSetRequest) 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 *QueryAllGuardianSetRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllGuardianSetRequest) 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 *QueryAllGuardianSetResponse) 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 *QueryAllGuardianSetResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllGuardianSetResponse) 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.GuardianSet) > 0 {
-		for iNdEx := len(m.GuardianSet) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.GuardianSet[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 (m *QueryGetConfigRequest) 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 *QueryGetConfigRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetConfigResponse) 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 *QueryGetConfigResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.Config.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 *QueryGetReplayProtectionRequest) 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 *QueryGetReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetReplayProtectionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetReplayProtectionResponse) 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 *QueryGetReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetReplayProtectionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.ReplayProtection.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 *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionResponse) 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 *QueryAllReplayProtectionResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllReplayProtectionResponse) 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.ReplayProtection) > 0 {
-		for iNdEx := len(m.ReplayProtection) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ReplayProtection[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 (m *QueryGetSequenceCounterRequest) 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 *QueryGetSequenceCounterRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetSequenceCounterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetSequenceCounterResponse) 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 *QueryGetSequenceCounterResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetSequenceCounterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.SequenceCounter.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 *QueryAllSequenceCounterRequest) 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 *QueryAllSequenceCounterRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllSequenceCounterRequest) 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 *QueryAllSequenceCounterResponse) 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 *QueryAllSequenceCounterResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllSequenceCounterResponse) 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.SequenceCounter) > 0 {
-		for iNdEx := len(m.SequenceCounter) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.SequenceCounter[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 (m *QueryGetConsensusGuardianSetIndexRequest) 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 *QueryGetConsensusGuardianSetIndexRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConsensusGuardianSetIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetConsensusGuardianSetIndexResponse) 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 *QueryGetConsensusGuardianSetIndexResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetConsensusGuardianSetIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.ConsensusGuardianSetIndex.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 *QueryGetGuardianValidatorRequest) 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 *QueryGetGuardianValidatorRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetGuardianValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.GuardianKey) > 0 {
-		i -= len(m.GuardianKey)
-		copy(dAtA[i:], m.GuardianKey)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.GuardianKey)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryGetGuardianValidatorResponse) 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 *QueryGetGuardianValidatorResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryGetGuardianValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.GuardianValidator.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 *QueryAllGuardianValidatorRequest) 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 *QueryAllGuardianValidatorRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllGuardianValidatorRequest) 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 *QueryAllGuardianValidatorResponse) 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 *QueryAllGuardianValidatorResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryAllGuardianValidatorResponse) 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.GuardianValidator) > 0 {
-		for iNdEx := len(m.GuardianValidator) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.GuardianValidator[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 (m *QueryLatestGuardianSetIndexRequest) 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 *QueryLatestGuardianSetIndexRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryLatestGuardianSetIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *QueryLatestGuardianSetIndexResponse) 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 *QueryLatestGuardianSetIndexResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryLatestGuardianSetIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.LatestGuardianSetIndex != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.LatestGuardianSetIndex))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
-	offset -= sovQuery(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *QueryGetGuardianSetRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Index != 0 {
-		n += 1 + sovQuery(uint64(m.Index))
-	}
-	return n
-}
-
-func (m *QueryGetGuardianSetResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.GuardianSet.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllGuardianSetRequest) 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 *QueryAllGuardianSetResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.GuardianSet) > 0 {
-		for _, e := range m.GuardianSet {
-			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 (m *QueryGetConfigRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *QueryGetConfigResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Config.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryGetReplayProtectionRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryGetReplayProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.ReplayProtection.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllReplayProtectionRequest) 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 *QueryAllReplayProtectionResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.ReplayProtection) > 0 {
-		for _, e := range m.ReplayProtection {
-			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 (m *QueryGetSequenceCounterRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryGetSequenceCounterResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.SequenceCounter.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllSequenceCounterRequest) 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 *QueryAllSequenceCounterResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.SequenceCounter) > 0 {
-		for _, e := range m.SequenceCounter {
-			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 (m *QueryGetConsensusGuardianSetIndexRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *QueryGetConsensusGuardianSetIndexResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.ConsensusGuardianSetIndex.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryGetGuardianValidatorRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.GuardianKey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryGetGuardianValidatorResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.GuardianValidator.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryAllGuardianValidatorRequest) 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 *QueryAllGuardianValidatorResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.GuardianValidator) > 0 {
-		for _, e := range m.GuardianValidator {
-			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 (m *QueryLatestGuardianSetIndexRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *QueryLatestGuardianSetIndexResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.LatestGuardianSetIndex != 0 {
-		n += 1 + sovQuery(uint64(m.LatestGuardianSetIndex))
-	}
-	return n
-}
-
-func sovQuery(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozQuery(x uint64) (n int) {
-	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *QueryGetGuardianSetRequest) 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: QueryGetGuardianSetRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetGuardianSetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			m.Index = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Index |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		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 *QueryGetGuardianSetResponse) 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: QueryGetGuardianSetResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetGuardianSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianSet", 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 err := m.GuardianSet.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 *QueryAllGuardianSetRequest) 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: QueryAllGuardianSetRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllGuardianSetRequest: 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 *QueryAllGuardianSetResponse) 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: QueryAllGuardianSetResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllGuardianSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianSet", 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.GuardianSet = append(m.GuardianSet, GuardianSet{})
-			if err := m.GuardianSet[len(m.GuardianSet)-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 (m *QueryGetConfigRequest) 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: QueryGetConfigRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		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 *QueryGetConfigResponse) 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: QueryGetConfigResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Config", 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 err := m.Config.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 *QueryGetReplayProtectionRequest) 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: QueryGetReplayProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetReplayProtectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				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 ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			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 *QueryGetReplayProtectionResponse) 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: QueryGetReplayProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", 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 err := m.ReplayProtection.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 *QueryAllReplayProtectionRequest) 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: QueryAllReplayProtectionRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllReplayProtectionRequest: 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 *QueryAllReplayProtectionResponse) 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: QueryAllReplayProtectionResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllReplayProtectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReplayProtection", 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.ReplayProtection = append(m.ReplayProtection, ReplayProtection{})
-			if err := m.ReplayProtection[len(m.ReplayProtection)-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 (m *QueryGetSequenceCounterRequest) 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: QueryGetSequenceCounterRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetSequenceCounterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				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 ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			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 *QueryGetSequenceCounterResponse) 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: QueryGetSequenceCounterResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetSequenceCounterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounter", 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 err := m.SequenceCounter.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 *QueryAllSequenceCounterRequest) 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: QueryAllSequenceCounterRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllSequenceCounterRequest: 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 *QueryAllSequenceCounterResponse) 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: QueryAllSequenceCounterResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllSequenceCounterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SequenceCounter", 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.SequenceCounter = append(m.SequenceCounter, SequenceCounter{})
-			if err := m.SequenceCounter[len(m.SequenceCounter)-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 (m *QueryGetConsensusGuardianSetIndexRequest) 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: QueryGetConsensusGuardianSetIndexRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConsensusGuardianSetIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		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 *QueryGetConsensusGuardianSetIndexResponse) 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: QueryGetConsensusGuardianSetIndexResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetConsensusGuardianSetIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusGuardianSetIndex", 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 err := m.ConsensusGuardianSetIndex.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 *QueryGetGuardianValidatorRequest) 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: QueryGetGuardianValidatorRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetGuardianValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianKey", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.GuardianKey = append(m.GuardianKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.GuardianKey == nil {
-				m.GuardianKey = []byte{}
-			}
-			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 *QueryGetGuardianValidatorResponse) 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: QueryGetGuardianValidatorResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetGuardianValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidator", 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 err := m.GuardianValidator.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 *QueryAllGuardianValidatorRequest) 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: QueryAllGuardianValidatorRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllGuardianValidatorRequest: 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 *QueryAllGuardianValidatorResponse) 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: QueryAllGuardianValidatorResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllGuardianValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GuardianValidator", 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.GuardianValidator = append(m.GuardianValidator, GuardianValidator{})
-			if err := m.GuardianValidator[len(m.GuardianValidator)-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 (m *QueryLatestGuardianSetIndexRequest) 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: QueryLatestGuardianSetIndexRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryLatestGuardianSetIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		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 *QueryLatestGuardianSetIndexResponse) 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: QueryLatestGuardianSetIndexResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryLatestGuardianSetIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LatestGuardianSetIndex", wireType)
-			}
-			m.LatestGuardianSetIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.LatestGuardianSetIndex |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		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
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowQuery
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthQuery
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupQuery
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthQuery
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
-)

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

@@ -971,27 +971,27 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 }
 
 var (
-	pattern_Query_GuardianSet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "wormhole", "guardianSet", "index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_GuardianSet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "wormhole", "guardianSet", "index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_GuardianSetAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "guardianSet"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_GuardianSetAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "guardianSet"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_Config_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "config"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_Config_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "config"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ReplayProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "wormhole", "replayProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ReplayProtection_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "wormhole", "replayProtection", "index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ReplayProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "replayProtection"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ReplayProtectionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "replayProtection"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_SequenceCounter_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "wormhole", "sequenceCounter", "index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_SequenceCounter_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "wormhole", "sequenceCounter", "index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_SequenceCounterAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "sequenceCounter"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_SequenceCounterAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "sequenceCounter"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_ConsensusGuardianSetIndex_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "consensus_guardian_set_index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_ConsensusGuardianSetIndex_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "consensus_guardian_set_index"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_GuardianValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"certusone", "wormholechain", "wormhole", "guardian_validator", "guardianKey"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_GuardianValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"wormhole_foundation", "wormholechain", "wormhole", "guardian_validator", "guardianKey"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_GuardianValidatorAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "guardian_validator"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_GuardianValidatorAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "guardian_validator"}, "", runtime.AssumeColonVerbOpt(true)))
 
-	pattern_Query_LatestGuardianSetIndex_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"certusone", "wormholechain", "wormhole", "latest_guardian_set_index"}, "", runtime.AssumeColonVerbOpt(true)))
+	pattern_Query_LatestGuardianSetIndex_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"wormhole_foundation", "wormholechain", "wormhole", "latest_guardian_set_index"}, "", runtime.AssumeColonVerbOpt(true)))
 )
 
 var (

wormhole_chain/x/wormhole/types/replay_protection.pb.go

@@ -1,316 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/replay_protection.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type ReplayProtection struct {
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-}
-
-func (m *ReplayProtection) Reset()         { *m = ReplayProtection{} }
-func (m *ReplayProtection) String() string { return proto.CompactTextString(m) }
-func (*ReplayProtection) ProtoMessage()    {}
-func (*ReplayProtection) Descriptor() ([]byte, []int) {
-	return fileDescriptor_da495f697a0fb01c, []int{0}
-}
-func (m *ReplayProtection) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ReplayProtection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ReplayProtection.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 *ReplayProtection) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplayProtection.Merge(m, src)
-}
-func (m *ReplayProtection) XXX_Size() int {
-	return m.Size()
-}
-func (m *ReplayProtection) XXX_DiscardUnknown() {
-	xxx_messageInfo_ReplayProtection.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ReplayProtection proto.InternalMessageInfo
-
-func (m *ReplayProtection) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*ReplayProtection)(nil), "certusone.wormholechain.wormhole.ReplayProtection")
-}
-
-func init() { proto.RegisterFile("wormhole/replay_protection.proto", fileDescriptor_da495f697a0fb01c) }
-
-var fileDescriptor_da495f697a0fb01c = []byte{
-	// 168 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x28, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x2f, 0x4a, 0x2d, 0xc8, 0x49, 0xac, 0x8c, 0x2f, 0x28, 0xca, 0x2f,
-	0x49, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x31, 0xf3, 0x85, 0x14, 0x92, 0x53, 0x8b, 0x4a,
-	0x4a, 0x8b, 0xf3, 0xf3, 0x52, 0xf5, 0x60, 0x6a, 0x93, 0x33, 0x12, 0x33, 0xf3, 0xe0, 0x3c, 0x25,
-	0x0d, 0x2e, 0x81, 0x20, 0xb0, 0xe6, 0x00, 0xb8, 0x5e, 0x21, 0x11, 0x2e, 0xd6, 0xcc, 0xbc, 0x94,
-	0xd4, 0x0a, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x08, 0xc7, 0xc9, 0xef, 0xc4, 0x23, 0x39,
-	0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63,
-	0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x4c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92,
-	0xf3, 0x73, 0xf5, 0xe1, 0x16, 0xea, 0xc3, 0xac, 0xd0, 0x05, 0xdb, 0xa8, 0x5f, 0x01, 0x17, 0xd0,
-	0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x3b, 0xd1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
-	0x56, 0x0b, 0xd5, 0x49, 0xc6, 0x00, 0x00, 0x00,
-}
-
-func (m *ReplayProtection) 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 *ReplayProtection) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ReplayProtection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintReplayProtection(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintReplayProtection(dAtA []byte, offset int, v uint64) int {
-	offset -= sovReplayProtection(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *ReplayProtection) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovReplayProtection(uint64(l))
-	}
-	return n
-}
-
-func sovReplayProtection(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozReplayProtection(x uint64) (n int) {
-	return sovReplayProtection(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *ReplayProtection) 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 ErrIntOverflowReplayProtection
-			}
-			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: ReplayProtection: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ReplayProtection: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowReplayProtection
-				}
-				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 ErrInvalidLengthReplayProtection
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthReplayProtection
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipReplayProtection(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthReplayProtection
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipReplayProtection(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowReplayProtection
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowReplayProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowReplayProtection
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthReplayProtection
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupReplayProtection
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthReplayProtection
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthReplayProtection        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowReplayProtection          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupReplayProtection = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/sequence_counter.pb.go

@@ -1,352 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/sequence_counter.proto
-
-package types
-
-import (
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type SequenceCounter struct {
-	Index    string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
-	Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
-}
-
-func (m *SequenceCounter) Reset()         { *m = SequenceCounter{} }
-func (m *SequenceCounter) String() string { return proto.CompactTextString(m) }
-func (*SequenceCounter) ProtoMessage()    {}
-func (*SequenceCounter) Descriptor() ([]byte, []int) {
-	return fileDescriptor_adec725923edb1a5, []int{0}
-}
-func (m *SequenceCounter) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *SequenceCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_SequenceCounter.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 *SequenceCounter) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SequenceCounter.Merge(m, src)
-}
-func (m *SequenceCounter) XXX_Size() int {
-	return m.Size()
-}
-func (m *SequenceCounter) XXX_DiscardUnknown() {
-	xxx_messageInfo_SequenceCounter.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SequenceCounter proto.InternalMessageInfo
-
-func (m *SequenceCounter) GetIndex() string {
-	if m != nil {
-		return m.Index
-	}
-	return ""
-}
-
-func (m *SequenceCounter) GetSequence() uint64 {
-	if m != nil {
-		return m.Sequence
-	}
-	return 0
-}
-
-func init() {
-	proto.RegisterType((*SequenceCounter)(nil), "certusone.wormholechain.wormhole.SequenceCounter")
-}
-
-func init() { proto.RegisterFile("wormhole/sequence_counter.proto", fileDescriptor_adec725923edb1a5) }
-
-var fileDescriptor_adec725923edb1a5 = []byte{
-	// 185 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2f, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x2f, 0x4e, 0x2d, 0x2c, 0x4d, 0xcd, 0x4b, 0x4e, 0x8d, 0x4f, 0xce,
-	0x2f, 0xcd, 0x2b, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48, 0x4e, 0x2d,
-	0x2a, 0x29, 0x2d, 0xce, 0xcf, 0x4b, 0xd5, 0x83, 0x29, 0x4d, 0xce, 0x48, 0xcc, 0xcc, 0x83, 0xf3,
-	0x94, 0x9c, 0xb9, 0xf8, 0x83, 0xa1, 0x7a, 0x9d, 0x21, 0x5a, 0x85, 0x44, 0xb8, 0x58, 0x33, 0xf3,
-	0x52, 0x52, 0x2b, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x20, 0x1c, 0x21, 0x29, 0x2e, 0x0e,
-	0x98, 0x25, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x2c, 0x41, 0x70, 0xbe, 0x93, 0xdf, 0x89, 0x47, 0x72,
-	0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7,
-	0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x99, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25,
-	0xe7, 0xe7, 0xea, 0xc3, 0xdd, 0xa2, 0x0f, 0xb3, 0x5d, 0x17, 0xec, 0x18, 0xfd, 0x0a, 0xb8, 0x80,
-	0x7e, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0xf5, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0x47, 0xc8, 0x9f, 0x62, 0xe0, 0x00, 0x00, 0x00,
-}
-
-func (m *SequenceCounter) 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 *SequenceCounter) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *SequenceCounter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Sequence != 0 {
-		i = encodeVarintSequenceCounter(dAtA, i, uint64(m.Sequence))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintSequenceCounter(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintSequenceCounter(dAtA []byte, offset int, v uint64) int {
-	offset -= sovSequenceCounter(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *SequenceCounter) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovSequenceCounter(uint64(l))
-	}
-	if m.Sequence != 0 {
-		n += 1 + sovSequenceCounter(uint64(m.Sequence))
-	}
-	return n
-}
-
-func sovSequenceCounter(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozSequenceCounter(x uint64) (n int) {
-	return sovSequenceCounter(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *SequenceCounter) 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 ErrIntOverflowSequenceCounter
-			}
-			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: SequenceCounter: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: SequenceCounter: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSequenceCounter
-				}
-				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 ErrInvalidLengthSequenceCounter
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthSequenceCounter
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Index = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
-			}
-			m.Sequence = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSequenceCounter
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Sequence |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipSequenceCounter(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthSequenceCounter
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipSequenceCounter(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowSequenceCounter
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowSequenceCounter
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowSequenceCounter
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthSequenceCounter
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupSequenceCounter
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthSequenceCounter
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthSequenceCounter        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowSequenceCounter          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupSequenceCounter = fmt.Errorf("proto: unexpected end of group")
-)

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

@@ -1,1023 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: wormhole/tx.proto
-
-package types
-
-import (
-	context "context"
-	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
-	grpc1 "github.com/gogo/protobuf/grpc"
-	proto "github.com/gogo/protobuf/proto"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type MsgExecuteGovernanceVAA struct {
-	Vaa    []byte `protobuf:"bytes,1,opt,name=vaa,proto3" json:"vaa,omitempty"`
-	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
-}
-
-func (m *MsgExecuteGovernanceVAA) Reset()         { *m = MsgExecuteGovernanceVAA{} }
-func (m *MsgExecuteGovernanceVAA) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteGovernanceVAA) ProtoMessage()    {}
-func (*MsgExecuteGovernanceVAA) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{0}
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteGovernanceVAA.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 *MsgExecuteGovernanceVAA) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteGovernanceVAA.Merge(m, src)
-}
-func (m *MsgExecuteGovernanceVAA) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteGovernanceVAA) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteGovernanceVAA.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteGovernanceVAA proto.InternalMessageInfo
-
-func (m *MsgExecuteGovernanceVAA) GetVaa() []byte {
-	if m != nil {
-		return m.Vaa
-	}
-	return nil
-}
-
-func (m *MsgExecuteGovernanceVAA) GetSigner() string {
-	if m != nil {
-		return m.Signer
-	}
-	return ""
-}
-
-type MsgExecuteGovernanceVAAResponse struct {
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) Reset()         { *m = MsgExecuteGovernanceVAAResponse{} }
-func (m *MsgExecuteGovernanceVAAResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgExecuteGovernanceVAAResponse) ProtoMessage()    {}
-func (*MsgExecuteGovernanceVAAResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{1}
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgExecuteGovernanceVAAResponse.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 *MsgExecuteGovernanceVAAResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgExecuteGovernanceVAAResponse.Merge(m, src)
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgExecuteGovernanceVAAResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgExecuteGovernanceVAAResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgExecuteGovernanceVAAResponse proto.InternalMessageInfo
-
-type MsgRegisterAccountAsGuardian struct {
-	Signer         string       `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
-	GuardianPubkey *GuardianKey `protobuf:"bytes,2,opt,name=guardianPubkey,proto3" json:"guardianPubkey,omitempty"`
-	Signature      []byte       `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
-}
-
-func (m *MsgRegisterAccountAsGuardian) Reset()         { *m = MsgRegisterAccountAsGuardian{} }
-func (m *MsgRegisterAccountAsGuardian) String() string { return proto.CompactTextString(m) }
-func (*MsgRegisterAccountAsGuardian) ProtoMessage()    {}
-func (*MsgRegisterAccountAsGuardian) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{2}
-}
-func (m *MsgRegisterAccountAsGuardian) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgRegisterAccountAsGuardian) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgRegisterAccountAsGuardian.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 *MsgRegisterAccountAsGuardian) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgRegisterAccountAsGuardian.Merge(m, src)
-}
-func (m *MsgRegisterAccountAsGuardian) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgRegisterAccountAsGuardian) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgRegisterAccountAsGuardian.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgRegisterAccountAsGuardian proto.InternalMessageInfo
-
-func (m *MsgRegisterAccountAsGuardian) GetSigner() string {
-	if m != nil {
-		return m.Signer
-	}
-	return ""
-}
-
-func (m *MsgRegisterAccountAsGuardian) GetGuardianPubkey() *GuardianKey {
-	if m != nil {
-		return m.GuardianPubkey
-	}
-	return nil
-}
-
-func (m *MsgRegisterAccountAsGuardian) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-type MsgRegisterAccountAsGuardianResponse struct {
-}
-
-func (m *MsgRegisterAccountAsGuardianResponse) Reset()         { *m = MsgRegisterAccountAsGuardianResponse{} }
-func (m *MsgRegisterAccountAsGuardianResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgRegisterAccountAsGuardianResponse) ProtoMessage()    {}
-func (*MsgRegisterAccountAsGuardianResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_55f7aa067b0c517b, []int{3}
-}
-func (m *MsgRegisterAccountAsGuardianResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *MsgRegisterAccountAsGuardianResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.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 *MsgRegisterAccountAsGuardianResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.Merge(m, src)
-}
-func (m *MsgRegisterAccountAsGuardianResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *MsgRegisterAccountAsGuardianResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgRegisterAccountAsGuardianResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_MsgRegisterAccountAsGuardianResponse proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*MsgExecuteGovernanceVAA)(nil), "certusone.wormholechain.wormhole.MsgExecuteGovernanceVAA")
-	proto.RegisterType((*MsgExecuteGovernanceVAAResponse)(nil), "certusone.wormholechain.wormhole.MsgExecuteGovernanceVAAResponse")
-	proto.RegisterType((*MsgRegisterAccountAsGuardian)(nil), "certusone.wormholechain.wormhole.MsgRegisterAccountAsGuardian")
-	proto.RegisterType((*MsgRegisterAccountAsGuardianResponse)(nil), "certusone.wormholechain.wormhole.MsgRegisterAccountAsGuardianResponse")
-}
-
-func init() { proto.RegisterFile("wormhole/tx.proto", fileDescriptor_55f7aa067b0c517b) }
-
-var fileDescriptor_55f7aa067b0c517b = []byte{
-	// 360 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2c, 0xcf, 0x2f, 0xca,
-	0xcd, 0xc8, 0xcf, 0x49, 0xd5, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x48,
-	0x4e, 0x2d, 0x2a, 0x29, 0x2d, 0xce, 0xcf, 0x4b, 0xd5, 0x83, 0x49, 0x26, 0x67, 0x24, 0x66, 0xe6,
-	0xc1, 0x79, 0x52, 0xd2, 0x70, 0x4d, 0xe9, 0xa5, 0x89, 0x45, 0x29, 0x99, 0x89, 0x79, 0xf1, 0xd9,
-	0xa9, 0x95, 0x10, 0xed, 0x4a, 0xce, 0x5c, 0xe2, 0xbe, 0xc5, 0xe9, 0xae, 0x15, 0xa9, 0xc9, 0xa5,
-	0x25, 0xa9, 0xee, 0xf9, 0x65, 0xa9, 0x45, 0x79, 0x89, 0x79, 0xc9, 0xa9, 0x61, 0x8e, 0x8e, 0x42,
-	0x02, 0x5c, 0xcc, 0x65, 0x89, 0x89, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x20, 0xa6, 0x90,
-	0x18, 0x17, 0x5b, 0x71, 0x66, 0x7a, 0x5e, 0x6a, 0x91, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x67, 0x10,
-	0x94, 0xa7, 0xa4, 0xc8, 0x25, 0x8f, 0xc3, 0x90, 0xa0, 0xd4, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54,
-	0xa5, 0xd5, 0x8c, 0x5c, 0x32, 0xbe, 0xc5, 0xe9, 0x41, 0xa9, 0xe9, 0x99, 0xc5, 0x25, 0xa9, 0x45,
-	0x8e, 0xc9, 0xc9, 0xf9, 0xa5, 0x79, 0x25, 0x8e, 0xc5, 0xee, 0x50, 0x27, 0x21, 0x99, 0xcd, 0x88,
-	0x6c, 0xb6, 0x50, 0x28, 0x17, 0x1f, 0xcc, 0xd9, 0x01, 0xa5, 0x49, 0xd9, 0xa9, 0x95, 0x60, 0xbb,
-	0xb9, 0x8d, 0x74, 0xf5, 0x08, 0x79, 0x5c, 0x0f, 0x66, 0xb6, 0x77, 0x6a, 0x65, 0x10, 0x9a, 0x21,
-	0x42, 0x32, 0x5c, 0x9c, 0x20, 0x0b, 0x12, 0x4b, 0x4a, 0x8b, 0x52, 0x25, 0x98, 0xc1, 0x5e, 0x44,
-	0x08, 0x28, 0xa9, 0x71, 0xa9, 0xe0, 0x73, 0x2c, 0xcc, 0x57, 0x46, 0x87, 0x98, 0xb8, 0x98, 0x7d,
-	0x8b, 0xd3, 0x85, 0xa6, 0x30, 0x72, 0x89, 0x60, 0x0d, 0x43, 0x4b, 0xc2, 0xae, 0xc4, 0x11, 0x72,
-	0x52, 0x8e, 0x64, 0x6b, 0x85, 0x39, 0x4f, 0x68, 0x31, 0x23, 0x97, 0x24, 0xee, 0x10, 0xb7, 0x23,
-	0xca, 0x02, 0x9c, 0xfa, 0xa5, 0xdc, 0x28, 0xd3, 0x0f, 0x73, 0xa5, 0x93, 0xdf, 0x89, 0x47, 0x72,
-	0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7,
-	0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x99, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25,
-	0xe7, 0xe7, 0xea, 0xc3, 0xed, 0xd2, 0x87, 0x99, 0xae, 0x0b, 0xb6, 0x4c, 0xbf, 0x42, 0x1f, 0x91,
-	0x29, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x29, 0xdb, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
-	0xd2, 0x9e, 0x5e, 0x5d, 0x2d, 0x03, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// MsgClient is the client API for Msg service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type MsgClient interface {
-	ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error)
-	RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error)
-}
-
-type msgClient struct {
-	cc grpc1.ClientConn
-}
-
-func NewMsgClient(cc grpc1.ClientConn) MsgClient {
-	return &msgClient{cc}
-}
-
-func (c *msgClient) ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error) {
-	out := new(MsgExecuteGovernanceVAAResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Msg/ExecuteGovernanceVAA", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *msgClient) RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error) {
-	out := new(MsgRegisterAccountAsGuardianResponse)
-	err := c.cc.Invoke(ctx, "/certusone.wormholechain.wormhole.Msg/RegisterAccountAsGuardian", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// MsgServer is the server API for Msg service.
-type MsgServer interface {
-	ExecuteGovernanceVAA(context.Context, *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error)
-	RegisterAccountAsGuardian(context.Context, *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error)
-}
-
-// UnimplementedMsgServer can be embedded to have forward compatible implementations.
-type UnimplementedMsgServer struct {
-}
-
-func (*UnimplementedMsgServer) ExecuteGovernanceVAA(ctx context.Context, req *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ExecuteGovernanceVAA not implemented")
-}
-func (*UnimplementedMsgServer) RegisterAccountAsGuardian(ctx context.Context, req *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RegisterAccountAsGuardian not implemented")
-}
-
-func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
-	s.RegisterService(&_Msg_serviceDesc, srv)
-}
-
-func _Msg_ExecuteGovernanceVAA_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgExecuteGovernanceVAA)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).ExecuteGovernanceVAA(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Msg/ExecuteGovernanceVAA",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).ExecuteGovernanceVAA(ctx, req.(*MsgExecuteGovernanceVAA))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Msg_RegisterAccountAsGuardian_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgRegisterAccountAsGuardian)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MsgServer).RegisterAccountAsGuardian(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/certusone.wormholechain.wormhole.Msg/RegisterAccountAsGuardian",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).RegisterAccountAsGuardian(ctx, req.(*MsgRegisterAccountAsGuardian))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Msg_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "certusone.wormholechain.wormhole.Msg",
-	HandlerType: (*MsgServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "ExecuteGovernanceVAA",
-			Handler:    _Msg_ExecuteGovernanceVAA_Handler,
-		},
-		{
-			MethodName: "RegisterAccountAsGuardian",
-			Handler:    _Msg_RegisterAccountAsGuardian_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "wormhole/tx.proto",
-}
-
-func (m *MsgExecuteGovernanceVAA) 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 *MsgExecuteGovernanceVAA) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteGovernanceVAA) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	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] = 0x12
-	}
-	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] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) 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 *MsgExecuteGovernanceVAAResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *MsgRegisterAccountAsGuardian) 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 *MsgRegisterAccountAsGuardian) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgRegisterAccountAsGuardian) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Signature) > 0 {
-		i -= len(m.Signature)
-		copy(dAtA[i:], m.Signature)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.Signature)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.GuardianPubkey != nil {
-		{
-			size, err := m.GuardianPubkey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTx(dAtA, i, uint64(size))
-		}
-		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 *MsgRegisterAccountAsGuardianResponse) 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 *MsgRegisterAccountAsGuardianResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MsgRegisterAccountAsGuardianResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	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 *MsgExecuteGovernanceVAA) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Vaa)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Signer)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
-}
-
-func (m *MsgExecuteGovernanceVAAResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *MsgRegisterAccountAsGuardian) 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))
-	}
-	if m.GuardianPubkey != nil {
-		l = m.GuardianPubkey.Size()
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = len(m.Signature)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	return n
-}
-
-func (m *MsgRegisterAccountAsGuardianResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func sovTx(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozTx(x uint64) (n int) {
-	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *MsgExecuteGovernanceVAA) 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: MsgExecuteGovernanceVAA: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteGovernanceVAA: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			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
-		case 2:
-			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
-		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 *MsgExecuteGovernanceVAAResponse) 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: MsgExecuteGovernanceVAAResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgExecuteGovernanceVAAResponse: 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 *MsgRegisterAccountAsGuardian) 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: MsgRegisterAccountAsGuardian: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgRegisterAccountAsGuardian: 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 GuardianPubkey", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTx
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTx
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.GuardianPubkey == nil {
-				m.GuardianPubkey = &GuardianKey{}
-			}
-			if err := m.GuardianPubkey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Signature", 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.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
-			if m.Signature == nil {
-				m.Signature = []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 *MsgRegisterAccountAsGuardianResponse) 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: MsgRegisterAccountAsGuardianResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgRegisterAccountAsGuardianResponse: 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 skipTx(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowTx
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthTx
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupTx
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthTx
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
-)

wormhole_chain/x/wormhole/types/vaa.go

@@ -0,0 +1,31 @@
+package types
+
+import "encoding/binary"
+
+type GovernanceMessage struct {
+	Module  [32]byte
+	Action  byte
+	Chain   uint16
+	Payload []byte
+}
+
+func NewGovernanceMessage(module [32]byte, action byte, chain uint16, payload []byte) GovernanceMessage {
+	return GovernanceMessage{
+		Module:  module,
+		Action:  action,
+		Chain:   chain,
+		Payload: payload,
+	}
+}
+
+func (gm *GovernanceMessage) MarshalBinary() []byte {
+	bz := []byte{}
+	bz = append(bz, gm.Module[:]...)
+	bz = append(bz, gm.Action)
+	chain_bz := [2]byte{}
+	binary.BigEndian.PutUint16(chain_bz[:], gm.Chain)
+	bz = append(bz, chain_bz[:]...)
+	// set update payload
+	bz = append(bz, gm.Payload...)
+	return bz
+}

wormhole_chain/x/wormhole/types/wasmd.go

@@ -0,0 +1,21 @@
+package types
+
+import (
+	wasmdtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+)
+
+func (msg MsgInstantiateContract) ToWasmd() wasmdtypes.MsgInstantiateContract {
+	return wasmdtypes.MsgInstantiateContract{
+		Sender: msg.Signer,
+		CodeID: msg.CodeID,
+		Label:  msg.Label,
+		Msg:    msg.Msg,
+	}
+}
+
+func (msg MsgStoreCode) ToWasmd() wasmdtypes.MsgStoreCode {
+	return wasmdtypes.MsgStoreCode{
+		Sender:       msg.Signer,
+		WASMByteCode: msg.WASMByteCode,
+	}
+}