diff --git a/app/app.go b/app/app.go
index c9a4d859d..8d5fab53e 100644
--- a/app/app.go
+++ b/app/app.go
@@ -802,8 +802,10 @@ func New(
 		app.TransferKeeper,
 		&app.AdminmoduleKeeper,
 		app.FeeBurnerKeeper,
-		app.FeeKeeper, &app.BankKeeper,
-		app.TokenFactoryKeeper, &app.CronKeeper,
+		app.FeeKeeper,
+		&app.BankKeeper,
+		app.TokenFactoryKeeper,
+		&app.CronKeeper,
 		&app.ContractManagerKeeper,
 		&app.DexKeeper,
 		app.OracleKeeper,
diff --git a/docs/static/swagger.yaml b/docs/static/swagger.yaml
index f104e227a..c1c094a97 100644
--- a/docs/static/swagger.yaml
+++ b/docs/static/swagger.yaml
@@ -19724,7 +19724,7 @@ definitions:
   osmosis.tokenfactory.v1beta1.QueryBeforeSendHookAddressResponse:
     description: |-
       QueryBeforeSendHookAddressResponse defines the response structure for the
-      DenomBeforeSendHook gRPC query.
+      BeforeSendHookAddress gRPC query.
     properties:
       contract_addr:
         type: string
@@ -19759,6 +19759,14 @@ definitions:
           type: string
         type: array
     type: object
+  osmosis.tokenfactory.v1beta1.QueryFullDenomResponse:
+    description: |-
+      QueryFullDenomResponse defines the response structure for the
+      FullDenom gRPC query.
+    properties:
+      full_denom:
+        type: string
+    type: object
   osmosis.tokenfactory.v1beta1.QueryParamsResponse:
     description: QueryParamsResponse is the response type for the Query/Params RPC method.
     properties:
@@ -45519,7 +45527,7 @@ paths:
               QueryBeforeSendHookAddressResponse defines the response structure
               for the
 
-              DenomBeforeSendHook gRPC query.
+              BeforeSendHookAddress gRPC query.
             properties:
               contract_addr:
                 type: string
@@ -45551,6 +45559,56 @@ paths:
         getting the address registered for the before send hook.
       tags:
         - Query
+  /osmosis/tokenfactory/v1beta1/denoms/factory/{creator}/{subdenom}/full_denom:
+    get:
+      operationId: FullDenom
+      parameters:
+        - in: path
+          name: creator
+          required: true
+          type: string
+        - in: path
+          name: subdenom
+          required: true
+          type: string
+      responses:
+        '200':
+          description: A successful response.
+          schema:
+            description: |-
+              QueryFullDenomResponse defines the response structure for the
+              FullDenom gRPC query.
+            properties:
+              full_denom:
+                type: string
+            type: object
+        default:
+          description: An unexpected error response.
+          schema:
+            properties:
+              code:
+                format: int32
+                type: integer
+              details:
+                items:
+                  properties:
+                    type_url:
+                      type: string
+                    value:
+                      format: byte
+                      type: string
+                  type: object
+                type: array
+              error:
+                type: string
+              message:
+                type: string
+            type: object
+      summary: |-
+        FullDenom defines a gRPC query method for getting full denom name
+        from the creator and subdenom strings.
+      tags:
+        - Query
   /osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}:
     get:
       operationId: DenomsFromCreator
diff --git a/proto/neutron/contractmanager/tx.proto b/proto/neutron/contractmanager/tx.proto
index 24a98596d..6feb37d66 100644
--- a/proto/neutron/contractmanager/tx.proto
+++ b/proto/neutron/contractmanager/tx.proto
@@ -16,6 +16,8 @@ service Msg {
   option (cosmos.msg.v1.service) = true;
 
   rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
+  rpc ResubmitFailure(MsgResubmitFailure) returns (MsgResubmitFailureResponse);
+
   // this line is used by starport scaffolding # proto/tx/rpc
 }
 
@@ -43,3 +45,17 @@ message MsgUpdateParams {
 //
 // Since: 0.47
 message MsgUpdateParamsResponse {}
+
+// MsgResubmitFailure - contract that has failed acknowledgement can resubmit its failure
+message MsgResubmitFailure {
+  option (amino.name) = "contractmanager/MsgResubmitFailure";
+  option (cosmos.msg.v1.signer) = "sender";
+
+  // sender is the contract which failure to acknowledge is resubmitted.
+  string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+
+  // failure_id is id of failure to resubmit
+  uint64 failure_id = 2;
+}
+
+message MsgResubmitFailureResponse {}
diff --git a/proto/osmosis/tokenfactory/v1beta1/query.proto b/proto/osmosis/tokenfactory/v1beta1/query.proto
index 0c211bf0c..4eeb459bd 100644
--- a/proto/osmosis/tokenfactory/v1beta1/query.proto
+++ b/proto/osmosis/tokenfactory/v1beta1/query.proto
@@ -37,6 +37,12 @@ service Query {
       "/osmosis/tokenfactory/v1beta1/denoms/factory/{creator}/{subdenom}/"
       "before_send_hook";
   }
+
+  // FullDenom defines a gRPC query method for getting full denom name
+  // from the creator and subdenom strings.
+  rpc FullDenom(QueryFullDenomRequest) returns (QueryFullDenomResponse) {
+    option (google.api.http).get = "/osmosis/tokenfactory/v1beta1/denoms/factory/{creator}/{subdenom}/full_denom";
+  }
 }
 
 // QueryParamsRequest is the request type for the Query/Params RPC method.
@@ -76,13 +82,28 @@ message QueryDenomsFromCreatorResponse {
   repeated string denoms = 1 [(gogoproto.moretags) = "yaml:\"denoms\""];
 }
 
+// QueryBeforeSendHookAddressRequest defines the request structure for the
+// BeforeSendHookAddress gRPC query.
 message QueryBeforeSendHookAddressRequest {
   string creator = 1 [(gogoproto.moretags) = "yaml:\"creator\""];
   string subdenom = 2 [(gogoproto.moretags) = "yaml:\"subdenom\""];
 }
 
 // QueryBeforeSendHookAddressResponse defines the response structure for the
-// DenomBeforeSendHook gRPC query.
+// BeforeSendHookAddress gRPC query.
 message QueryBeforeSendHookAddressResponse {
   string contract_addr = 1 [(gogoproto.moretags) = "yaml:\"contract_addr\""];
 }
+
+// QueryFullDenomRequest defines the request structure for the
+// FullDenom gRPC query.
+message QueryFullDenomRequest {
+  string creator = 1 [(gogoproto.moretags) = "yaml:\"creator\""];
+  string subdenom = 2 [(gogoproto.moretags) = "yaml:\"subdenom\""];
+}
+
+// QueryFullDenomResponse defines the response structure for the
+// FullDenom gRPC query.
+message QueryFullDenomResponse {
+  string full_denom = 1 [(gogoproto.moretags) = "yaml:\"full_denom\""];
+}
diff --git a/wasmbinding/message_plugin.go b/wasmbinding/message_plugin.go
index 0eddd7d76..ed76a8ed3 100644
--- a/wasmbinding/message_plugin.go
+++ b/wasmbinding/message_plugin.go
@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	contractmanagerkeeper "github.com/neutron-org/neutron/v5/x/contractmanager/keeper"
+
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 
 	"github.com/cosmos/gogoproto/proto"
@@ -17,8 +19,6 @@ import (
 	dextypes "github.com/neutron-org/neutron/v5/x/dex/types"
 	dexutils "github.com/neutron-org/neutron/v5/x/dex/utils"
 
-	contractmanagerkeeper "github.com/neutron-org/neutron/v5/x/contractmanager/keeper"
-
 	"cosmossdk.io/errors"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 
@@ -37,6 +37,8 @@ import (
 	adminmodulekeeper "github.com/cosmos/admin-module/v2/x/adminmodule/keeper"
 	admintypes "github.com/cosmos/admin-module/v2/x/adminmodule/types"
 
+	contractmanagertypes "github.com/neutron-org/neutron/v5/x/contractmanager/types"
+
 	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
 	//nolint:staticcheck
 
@@ -65,37 +67,39 @@ func CustomMessageDecorator(
 ) func(messenger wasmkeeper.Messenger) wasmkeeper.Messenger {
 	return func(old wasmkeeper.Messenger) wasmkeeper.Messenger {
 		return &CustomMessenger{
-			Keeper:                *ictx,
-			Wrapped:               old,
-			Ictxmsgserver:         ictxkeeper.NewMsgServerImpl(*ictx),
-			Icqmsgserver:          icqkeeper.NewMsgServerImpl(*icq),
-			transferKeeper:        transferKeeper,
-			Adminserver:           adminmodulekeeper.NewMsgServerImpl(*adminKeeper),
-			Bank:                  bankKeeper,
-			TokenFactory:          tokenFactoryKeeper,
-			CronMsgServer:         cronkeeper.NewMsgServerImpl(*cronKeeper),
-			CronQueryServer:       cronKeeper,
-			AdminKeeper:           adminKeeper,
-			ContractmanagerKeeper: contractmanagerKeeper,
-			DexMsgServer:          dexkeeper.NewMsgServerImpl(*dexKeeper),
+			Keeper:                     *ictx,
+			Wrapped:                    old,
+			Ictxmsgserver:              ictxkeeper.NewMsgServerImpl(*ictx),
+			Icqmsgserver:               icqkeeper.NewMsgServerImpl(*icq),
+			transferKeeper:             transferKeeper,
+			Adminserver:                adminmodulekeeper.NewMsgServerImpl(*adminKeeper),
+			Bank:                       bankKeeper,
+			TokenFactory:               tokenFactoryKeeper,
+			CronMsgServer:              cronkeeper.NewMsgServerImpl(*cronKeeper),
+			CronQueryServer:            cronKeeper,
+			AdminKeeper:                adminKeeper,
+			ContractmanagerMsgServer:   contractmanagerkeeper.NewMsgServerImpl(*contractmanagerKeeper),
+			ContractmanagerQueryServer: contractmanagerkeeper.NewQueryServerImpl(*contractmanagerKeeper),
+			DexMsgServer:               dexkeeper.NewMsgServerImpl(*dexKeeper),
 		}
 	}
 }
 
 type CustomMessenger struct {
-	Keeper                ictxkeeper.Keeper
-	Wrapped               wasmkeeper.Messenger
-	Ictxmsgserver         ictxtypes.MsgServer
-	Icqmsgserver          icqtypes.MsgServer
-	transferKeeper        transferwrapperkeeper.KeeperTransferWrapper
-	Adminserver           admintypes.MsgServer
-	Bank                  *bankkeeper.BaseKeeper
-	TokenFactory          *tokenfactorykeeper.Keeper
-	CronMsgServer         crontypes.MsgServer
-	CronQueryServer       crontypes.QueryServer
-	AdminKeeper           *adminmodulekeeper.Keeper
-	ContractmanagerKeeper *contractmanagerkeeper.Keeper
-	DexMsgServer          dextypes.MsgServer
+	Keeper                     ictxkeeper.Keeper
+	Wrapped                    wasmkeeper.Messenger
+	Ictxmsgserver              ictxtypes.MsgServer
+	Icqmsgserver               icqtypes.MsgServer
+	transferKeeper             transferwrapperkeeper.KeeperTransferWrapper
+	Adminserver                admintypes.MsgServer
+	Bank                       *bankkeeper.BaseKeeper
+	TokenFactory               *tokenfactorykeeper.Keeper
+	CronMsgServer              crontypes.MsgServer
+	CronQueryServer            crontypes.QueryServer
+	AdminKeeper                *adminmodulekeeper.Keeper
+	ContractmanagerMsgServer   contractmanagertypes.MsgServer
+	ContractmanagerQueryServer contractmanagertypes.QueryServer
+	DexMsgServer               dextypes.MsgServer
 }
 
 var _ wasmkeeper.Messenger = (*CustomMessenger)(nil)
@@ -1060,12 +1064,18 @@ func (m *CustomMessenger) removeSchedule(ctx sdk.Context, contractAddr sdk.AccAd
 }
 
 func (m *CustomMessenger) resubmitFailure(ctx sdk.Context, contractAddr sdk.AccAddress, resubmitFailure *bindings.ResubmitFailure) ([]sdk.Event, [][]byte, [][]*types.Any, error) {
-	failure, err := m.ContractmanagerKeeper.GetFailure(ctx, contractAddr, resubmitFailure.FailureId)
+	failure, err := m.ContractmanagerQueryServer.AddressFailure(ctx, &contractmanagertypes.QueryFailureRequest{
+		Address:   contractAddr.String(),
+		FailureId: resubmitFailure.FailureId,
+	})
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(sdkerrors.ErrNotFound, "no failure found to resubmit")
+		return nil, nil, nil, errors.Wrapf(err, "no failure with given FailureId found to resubmit")
 	}
 
-	err = m.ContractmanagerKeeper.ResubmitFailure(ctx, contractAddr, failure)
+	_, err = m.ContractmanagerMsgServer.ResubmitFailure(ctx, &contractmanagertypes.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: resubmitFailure.FailureId,
+	})
 	if err != nil {
 		ctx.Logger().Error("failed to resubmitFailure",
 			"from_address", contractAddr.String(),
@@ -1074,7 +1084,7 @@ func (m *CustomMessenger) resubmitFailure(ctx sdk.Context, contractAddr sdk.AccA
 		return nil, nil, nil, errors.Wrap(err, "failed to resubmitFailure")
 	}
 
-	resp := bindings.ResubmitFailureResponse{FailureId: failure.Id}
+	resp := bindings.ResubmitFailureResponse{FailureId: resubmitFailure.FailureId}
 	data, err := json.Marshal(&resp)
 	if err != nil {
 		ctx.Logger().Error("json.Marshal: failed to marshal remove resubmitFailure response to JSON",
@@ -1084,6 +1094,8 @@ func (m *CustomMessenger) resubmitFailure(ctx sdk.Context, contractAddr sdk.AccA
 		return nil, nil, nil, errors.Wrap(err, "marshal json failed")
 	}
 
+	// Return failure for reverse compatibility purposes.
+	// Maybe it'll be removed in the future because it was already deleted after resubmit before returning here.
 	anyResp, err := types.NewAnyWithValue(failure)
 	if err != nil {
 		return nil, nil, nil, errors.Wrapf(err, "failed to convert {%T} to Any", failure)
diff --git a/wasmbinding/queries.go b/wasmbinding/queries.go
index 25257dd85..9dcee9b2e 100644
--- a/wasmbinding/queries.go
+++ b/wasmbinding/queries.go
@@ -129,7 +129,7 @@ func (qp *QueryPlugin) GetMinIbcFee(ctx sdk.Context, _ *bindings.QueryMinIbcFeeR
 }
 
 func (qp *QueryPlugin) GetFailures(ctx sdk.Context, address string, pagination *sdkquery.PageRequest) (*bindings.FailuresResponse, error) {
-	res, err := qp.contractmanagerKeeper.AddressFailures(ctx, &contractmanagertypes.QueryFailuresRequest{
+	res, err := qp.contractmanagerQueryServer.AddressFailures(ctx, &contractmanagertypes.QueryFailuresRequest{
 		Address:    address,
 		Pagination: pagination,
 	})
diff --git a/wasmbinding/query_plugin.go b/wasmbinding/query_plugin.go
index b079e7a3c..e8fc4794a 100644
--- a/wasmbinding/query_plugin.go
+++ b/wasmbinding/query_plugin.go
@@ -2,6 +2,7 @@ package wasmbinding
 
 import (
 	contractmanagerkeeper "github.com/neutron-org/neutron/v5/x/contractmanager/keeper"
+	contractmanagertypes "github.com/neutron-org/neutron/v5/x/contractmanager/types"
 	dexkeeper "github.com/neutron-org/neutron/v5/x/dex/keeper"
 	feeburnerkeeper "github.com/neutron-org/neutron/v5/x/feeburner/keeper"
 	feerefunderkeeper "github.com/neutron-org/neutron/v5/x/feerefunder/keeper"
@@ -15,28 +16,28 @@ import (
 )
 
 type QueryPlugin struct {
-	icaControllerKeeper   *icacontrollerkeeper.Keeper
-	icqKeeper             *icqkeeper.Keeper
-	feeBurnerKeeper       *feeburnerkeeper.Keeper
-	feeRefunderKeeper     *feerefunderkeeper.Keeper
-	tokenFactoryKeeper    *tokenfactorykeeper.Keeper
-	contractmanagerKeeper *contractmanagerkeeper.Keeper
-	dexKeeper             *dexkeeper.Keeper
-	oracleKeeper          *oraclekeeper.Keeper
-	marketmapKeeper       *marketmapkeeper.Keeper
+	icaControllerKeeper        *icacontrollerkeeper.Keeper
+	icqKeeper                  *icqkeeper.Keeper
+	feeBurnerKeeper            *feeburnerkeeper.Keeper
+	feeRefunderKeeper          *feerefunderkeeper.Keeper
+	tokenFactoryKeeper         *tokenfactorykeeper.Keeper
+	contractmanagerQueryServer contractmanagertypes.QueryServer
+	dexKeeper                  *dexkeeper.Keeper
+	oracleKeeper               *oraclekeeper.Keeper
+	marketmapKeeper            *marketmapkeeper.Keeper
 }
 
 // NewQueryPlugin returns a reference to a new QueryPlugin.
 func NewQueryPlugin(icaControllerKeeper *icacontrollerkeeper.Keeper, icqKeeper *icqkeeper.Keeper, feeBurnerKeeper *feeburnerkeeper.Keeper, feeRefunderKeeper *feerefunderkeeper.Keeper, tfk *tokenfactorykeeper.Keeper, contractmanagerKeeper *contractmanagerkeeper.Keeper, dexKeeper *dexkeeper.Keeper, oracleKeeper *oraclekeeper.Keeper, marketmapKeeper *marketmapkeeper.Keeper) *QueryPlugin {
 	return &QueryPlugin{
-		icaControllerKeeper:   icaControllerKeeper,
-		icqKeeper:             icqKeeper,
-		feeBurnerKeeper:       feeBurnerKeeper,
-		feeRefunderKeeper:     feeRefunderKeeper,
-		tokenFactoryKeeper:    tfk,
-		contractmanagerKeeper: contractmanagerKeeper,
-		dexKeeper:             dexKeeper,
-		oracleKeeper:          oracleKeeper,
-		marketmapKeeper:       marketmapKeeper,
+		icaControllerKeeper:        icaControllerKeeper,
+		icqKeeper:                  icqKeeper,
+		feeBurnerKeeper:            feeBurnerKeeper,
+		feeRefunderKeeper:          feeRefunderKeeper,
+		tokenFactoryKeeper:         tfk,
+		contractmanagerQueryServer: contractmanagerkeeper.NewQueryServerImpl(*contractmanagerKeeper),
+		dexKeeper:                  dexKeeper,
+		oracleKeeper:               oracleKeeper,
+		marketmapKeeper:            marketmapKeeper,
 	}
 }
diff --git a/wasmbinding/stargate_allowlist.go b/wasmbinding/stargate_allowlist.go
index 8daf2caac..1364c94a4 100644
--- a/wasmbinding/stargate_allowlist.go
+++ b/wasmbinding/stargate_allowlist.go
@@ -36,6 +36,7 @@ func AcceptedStargateQueries() wasmkeeper.AcceptedQueries {
 		"/osmosis.tokenfactory.v1beta1.Query/DenomAuthorityMetadata": &tokenfactorytypes.QueryDenomAuthorityMetadataResponse{},
 		"/osmosis.tokenfactory.v1beta1.Query/DenomsFromCreator":      &tokenfactorytypes.QueryDenomsFromCreatorResponse{},
 		"/osmosis.tokenfactory.v1beta1.Query/BeforeSendHookAddress":  &tokenfactorytypes.QueryBeforeSendHookAddressResponse{},
+		"/osmosis.tokenfactory.v1beta1.Query/FullDenom":              &tokenfactorytypes.QueryFullDenomResponse{},
 
 		// interchain accounts
 		"/ibc.applications.interchain_accounts.controller.v1.Query/InterchainAccount": &icacontrollertypes.QueryInterchainAccountResponse{},
diff --git a/wasmbinding/test/custom_message_test.go b/wasmbinding/test/custom_message_test.go
index 3f826c48f..457e63163 100644
--- a/wasmbinding/test/custom_message_test.go
+++ b/wasmbinding/test/custom_message_test.go
@@ -13,7 +13,6 @@ import (
 	admintypes "github.com/cosmos/admin-module/v2/x/adminmodule/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 
-	keeper2 "github.com/neutron-org/neutron/v5/x/contractmanager/keeper"
 	feeburnertypes "github.com/neutron-org/neutron/v5/x/feeburner/types"
 
 	ibcchanneltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
@@ -26,6 +25,8 @@ import (
 
 	cronkeeper "github.com/neutron-org/neutron/v5/x/cron/keeper"
 
+	contractmanagerkeeper "github.com/neutron-org/neutron/v5/x/contractmanager/keeper"
+
 	"github.com/neutron-org/neutron/v5/app/params"
 
 	"github.com/CosmWasm/wasmd/x/wasm/keeper"
@@ -73,7 +74,8 @@ func (suite *CustomMessengerTestSuite) SetupTest() {
 	suite.messenger.CronMsgServer = cronkeeper.NewMsgServerImpl(suite.neutron.CronKeeper)
 	suite.messenger.CronQueryServer = suite.neutron.CronKeeper
 	suite.messenger.AdminKeeper = &suite.neutron.AdminmoduleKeeper
-	suite.messenger.ContractmanagerKeeper = &suite.neutron.ContractManagerKeeper
+	suite.messenger.ContractmanagerMsgServer = contractmanagerkeeper.NewMsgServerImpl(suite.neutron.ContractManagerKeeper)
+	suite.messenger.ContractmanagerQueryServer = contractmanagerkeeper.NewQueryServerImpl(suite.neutron.ContractManagerKeeper)
 	suite.contractOwner = keeper.RandomAccountAddress(suite.T())
 
 	suite.contractKeeper = keeper.NewDefaultPermissionKeeper(&suite.neutron.WasmKeeper)
@@ -737,10 +739,11 @@ func (suite *CustomMessengerTestSuite) TestResubmitFailureAck() {
 	ack := ibcchanneltypes.Acknowledgement{
 		Response: &ibcchanneltypes.Acknowledgement_Result{Result: []byte("Result")},
 	}
-	payload, err := keeper2.PrepareSudoCallbackMessage(packet, &ack)
+	payload, err := contractmanagerkeeper.PrepareSudoCallbackMessage(packet, &ack)
 	require.NoError(suite.T(), err)
-	failureID := suite.messenger.ContractmanagerKeeper.GetNextFailureIDKey(suite.ctx, suite.contractAddress.String())
-	suite.messenger.ContractmanagerKeeper.AddContractFailure(suite.ctx, suite.contractAddress.String(), payload, "test error")
+
+	failureID := suite.neutron.ContractManagerKeeper.GetNextFailureIDKey(suite.ctx, suite.contractAddress.String())
+	suite.neutron.ContractManagerKeeper.AddContractFailure(suite.ctx, suite.contractAddress.String(), payload, "test error")
 
 	// Craft message
 	msg := bindings.NeutronMsg{
@@ -762,10 +765,11 @@ func (suite *CustomMessengerTestSuite) TestResubmitFailureAck() {
 func (suite *CustomMessengerTestSuite) TestResubmitFailureTimeout() {
 	// Add failure
 	packet := ibcchanneltypes.Packet{}
-	payload, err := keeper2.PrepareSudoCallbackMessage(packet, nil)
+	payload, err := contractmanagerkeeper.PrepareSudoCallbackMessage(packet, nil)
 	require.NoError(suite.T(), err)
-	failureID := suite.messenger.ContractmanagerKeeper.GetNextFailureIDKey(suite.ctx, suite.contractAddress.String())
-	suite.messenger.ContractmanagerKeeper.AddContractFailure(suite.ctx, suite.contractAddress.String(), payload, "test error")
+
+	failureID := suite.neutron.ContractManagerKeeper.GetNextFailureIDKey(suite.ctx, suite.contractAddress.String())
+	suite.neutron.ContractManagerKeeper.AddContractFailure(suite.ctx, suite.contractAddress.String(), payload, "test error")
 
 	// Craft message
 	msg := bindings.NeutronMsg{
@@ -790,10 +794,10 @@ func (suite *CustomMessengerTestSuite) TestResubmitFailureFromDifferentContract(
 	ack := ibcchanneltypes.Acknowledgement{
 		Response: &ibcchanneltypes.Acknowledgement_Error{Error: "ErrorSudoPayload"},
 	}
-	failureID := suite.messenger.ContractmanagerKeeper.GetNextFailureIDKey(suite.ctx, testutil.TestOwnerAddress)
-	payload, err := keeper2.PrepareSudoCallbackMessage(packet, &ack)
+	failureID := suite.neutron.ContractManagerKeeper.GetNextFailureIDKey(suite.ctx, testutil.TestOwnerAddress)
+	payload, err := contractmanagerkeeper.PrepareSudoCallbackMessage(packet, &ack)
 	require.NoError(suite.T(), err)
-	suite.messenger.ContractmanagerKeeper.AddContractFailure(suite.ctx, testutil.TestOwnerAddress, payload, "test error")
+	suite.neutron.ContractManagerKeeper.AddContractFailure(suite.ctx, testutil.TestOwnerAddress, payload, "test error")
 
 	// Craft message
 	msg := bindings.NeutronMsg{
@@ -804,7 +808,7 @@ func (suite *CustomMessengerTestSuite) TestResubmitFailureFromDifferentContract(
 
 	// Dispatch
 	_, err = suite.executeNeutronMsg(suite.contractAddress, msg)
-	suite.ErrorContains(err, "no failure found to resubmit: not found")
+	suite.ErrorContains(err, "no failure with given FailureId found to resubmit")
 }
 
 func (suite *CustomMessengerTestSuite) executeCustomMsg(contractAddress sdk.AccAddress, fullMsg json.RawMessage) (data []byte, err error) {
diff --git a/x/contractmanager/keeper/failure.go b/x/contractmanager/keeper/failure.go
index 4774ee978..c41eadf5e 100644
--- a/x/contractmanager/keeper/failure.go
+++ b/x/contractmanager/keeper/failure.go
@@ -88,8 +88,9 @@ func (k Keeper) GetFailure(ctx sdk.Context, contractAddr sdk.AccAddress, id uint
 	return &res, nil
 }
 
-// ResubmitFailure tries to call sudo handler for contract with same parameters as initially.
-func (k Keeper) ResubmitFailure(ctx sdk.Context, contractAddr sdk.AccAddress, failure *types.Failure) error {
+// resubmitFailure tries to call sudo handler for contract with same parameters as initially.
+// if successful, removes the failure from storage
+func (k Keeper) resubmitFailure(ctx sdk.Context, contractAddr sdk.AccAddress, failure *types.Failure) error {
 	if failure.SudoPayload == nil {
 		return errorsmod.Wrapf(types.ErrIncorrectFailureToResubmit, "cannot resubmit failure without sudo payload; failureId = %d", failure.Id)
 	}
diff --git a/x/contractmanager/keeper/failure_test.go b/x/contractmanager/keeper/failure_test.go
index d3e026faa..800f0fc7b 100644
--- a/x/contractmanager/keeper/failure_test.go
+++ b/x/contractmanager/keeper/failure_test.go
@@ -150,10 +150,14 @@ func TestResubmitFailure(t *testing.T) {
 
 	// case: successful resubmit with ack and ack = response
 	wk.EXPECT().Sudo(ctx, contractAddr, msgSuc).Return([]byte{}, nil)
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure, err := k.GetFailure(ctx, contractAddr, failureID)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure.Id,
+	})
 	require.NoError(t, err)
 	// failure should be deleted
 	_, err = k.GetFailure(ctx, contractAddr, failureID)
@@ -166,10 +170,14 @@ func TestResubmitFailure(t *testing.T) {
 	k.AddContractFailure(ctx, contractAddr.String(), payload, "test error")
 
 	wk.EXPECT().Sudo(ctx, contractAddr, msgSuc).Return(nil, fmt.Errorf("failed to sudo"))
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure2, err := k.GetFailure(ctx, contractAddr, failureID2)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure2)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure2.Id,
+	})
 	require.ErrorContains(t, err, "cannot resubmit failure")
 	// failure is still there
 	failureAfter2, err := k.GetFailure(ctx, contractAddr, failureID2)
@@ -184,10 +192,14 @@ func TestResubmitFailure(t *testing.T) {
 	k.AddContractFailure(ctx, contractAddr.String(), payload, "test error")
 
 	wk.EXPECT().Sudo(gomock.AssignableToTypeOf(ctx), contractAddr, msgErr).Return([]byte{}, nil)
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure3, err := k.GetFailure(ctx, contractAddr, failureID3)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure3)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure3.Id,
+	})
 	require.NoError(t, err)
 	// failure should be deleted
 	_, err = k.GetFailure(ctx, contractAddr, failureID3)
@@ -200,10 +212,14 @@ func TestResubmitFailure(t *testing.T) {
 	k.AddContractFailure(ctx, contractAddr.String(), payload, "test error")
 
 	wk.EXPECT().Sudo(gomock.AssignableToTypeOf(ctx), contractAddr, msgErr).Return(nil, fmt.Errorf("failed to sudo"))
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure4, err := k.GetFailure(ctx, contractAddr, failureID4)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure4)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure4.Id,
+	})
 	require.ErrorContains(t, err, "cannot resubmit failure")
 	// failure is still there
 	failureAfter4, err := k.GetFailure(ctx, contractAddr, failureID4)
@@ -218,10 +234,14 @@ func TestResubmitFailure(t *testing.T) {
 	k.AddContractFailure(ctx, contractAddr.String(), payload, "test error")
 
 	wk.EXPECT().Sudo(gomock.AssignableToTypeOf(ctx), contractAddr, msgTimeout).Return([]byte{}, nil)
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure5, err := k.GetFailure(ctx, contractAddr, failureID5)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure5)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure5.Id,
+	})
 	require.NoError(t, err)
 	// failure should be deleted
 	_, err = k.GetFailure(ctx, contractAddr, failureID5)
@@ -234,10 +254,14 @@ func TestResubmitFailure(t *testing.T) {
 	k.AddContractFailure(ctx, contractAddr.String(), payload, "test error")
 
 	wk.EXPECT().Sudo(gomock.AssignableToTypeOf(ctx), contractAddr, msgTimeout).Return(nil, fmt.Errorf("failed to sudo"))
+	wk.EXPECT().HasContractInfo(ctx, contractAddr).Return(true)
 
 	failure6, err := k.GetFailure(ctx, contractAddr, failureID6)
 	require.NoError(t, err)
-	err = k.ResubmitFailure(ctx, contractAddr, failure6)
+	_, err = k.ResubmitFailure(ctx, &types.MsgResubmitFailure{
+		Sender:    contractAddr.String(),
+		FailureId: failure6.Id,
+	})
 	require.ErrorContains(t, err, "cannot resubmit failure")
 	// failure is still there
 	failureAfter6, err := k.GetFailure(ctx, contractAddr, failureID6)
diff --git a/x/contractmanager/keeper/grpc_query.go b/x/contractmanager/keeper/grpc_query.go
index c8c613f21..4e3cfa19e 100644
--- a/x/contractmanager/keeper/grpc_query.go
+++ b/x/contractmanager/keeper/grpc_query.go
@@ -5,3 +5,13 @@ import (
 )
 
 var _ types.QueryServer = Keeper{}
+
+type queryServer struct {
+	Keeper
+}
+
+// NewQueryServerImpl returns an implementation of the QueryServer interface
+// for the provided Keeper.
+func NewQueryServerImpl(keeper Keeper) types.QueryServer {
+	return &queryServer{Keeper: keeper}
+}
diff --git a/x/contractmanager/keeper/msg_server.go b/x/contractmanager/keeper/msg_server.go
index 5e204b6fb..8a651415c 100644
--- a/x/contractmanager/keeper/msg_server.go
+++ b/x/contractmanager/keeper/msg_server.go
@@ -40,3 +40,32 @@ func (k Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams)
 
 	return &types.MsgUpdateParamsResponse{}, nil
 }
+
+// ResubmitFailure resubmits the failure after contract acknowledgement failed
+func (k Keeper) ResubmitFailure(goCtx context.Context, req *types.MsgResubmitFailure) (*types.MsgResubmitFailureResponse, error) {
+	if err := req.Validate(); err != nil {
+		return nil, errors.Wrap(err, "failed to validate MsgResubmitFailure")
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	sender, err := sdk.AccAddressFromBech32(req.Sender)
+	if err != nil {
+		return nil, errors.Wrap(err, "sender in resubmit request is not in correct address format")
+	}
+
+	if !k.wasmKeeper.HasContractInfo(ctx, sender) {
+		return nil, errors.Wrap(types.ErrNotContractResubmission, "sender in resubmit request is not a smart contract")
+	}
+
+	failure, err := k.GetFailure(ctx, sender, req.FailureId)
+	if err != nil {
+		return nil, errors.Wrap(sdkerrors.ErrNotFound, "no failure with given FailureId found to resubmit")
+	}
+
+	if err := k.resubmitFailure(ctx, sender, failure); err != nil {
+		return nil, err
+	}
+
+	return &types.MsgResubmitFailureResponse{}, nil
+}
diff --git a/x/contractmanager/types/codec.go b/x/contractmanager/types/codec.go
index 14f5aff7e..1ba0ec750 100644
--- a/x/contractmanager/types/codec.go
+++ b/x/contractmanager/types/codec.go
@@ -9,12 +9,14 @@ import (
 
 func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgUpdateParams{}, "neutron.contractmanager.v1.MsgUpdateParams", nil)
+	cdc.RegisterConcrete(&MsgResubmitFailure{}, "neutron.contractmanager.v1.MsgResubmitFailure", nil)
 }
 
 func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 	registry.RegisterImplementations(
 		(*sdk.Msg)(nil),
 		&MsgUpdateParams{},
+		&MsgResubmitFailure{},
 	)
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
 }
diff --git a/x/contractmanager/types/errors.go b/x/contractmanager/types/errors.go
index ba32da1fe..d18510513 100644
--- a/x/contractmanager/types/errors.go
+++ b/x/contractmanager/types/errors.go
@@ -9,4 +9,5 @@ var (
 	ErrIncorrectFailureToResubmit = errors.Register(ModuleName, 1101, "incorrect failure to resubmit")
 	ErrFailedToResubmitFailure    = errors.Register(ModuleName, 1102, "failed to resubmit failure")
 	ErrSudoOutOfGas               = errors.Register(ModuleName, 1103, "sudo handling went beyond the gas limit allowed by the module")
+	ErrNotContractResubmission    = errors.Register(ModuleName, 1104, "failures resubmission is only allowed to be called by a smart contract")
 )
diff --git a/x/contractmanager/types/tx.go b/x/contractmanager/types/tx.go
index 7b965fc04..581700ab0 100644
--- a/x/contractmanager/types/tx.go
+++ b/x/contractmanager/types/tx.go
@@ -33,3 +33,32 @@ func (msg *MsgUpdateParams) Validate() error {
 	}
 	return nil
 }
+
+var _ sdk.Msg = &MsgResubmitFailure{}
+
+func (msg *MsgResubmitFailure) Route() string {
+	return RouterKey
+}
+
+func (msg *MsgResubmitFailure) Type() string {
+	return "resubmit-failure"
+}
+
+func (msg *MsgResubmitFailure) GetSigners() []sdk.AccAddress {
+	sender, err := sdk.AccAddressFromBech32(msg.Sender)
+	if err != nil { // should never happen as valid basic rejects invalid addresses
+		panic(err.Error())
+	}
+	return []sdk.AccAddress{sender}
+}
+
+func (msg *MsgResubmitFailure) GetSignBytes() []byte {
+	return ModuleCdc.MustMarshalJSON(msg)
+}
+
+func (msg *MsgResubmitFailure) Validate() error {
+	if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
+		return errorsmod.Wrap(err, "sender is invalid")
+	}
+	return nil
+}
diff --git a/x/contractmanager/types/tx.pb.go b/x/contractmanager/types/tx.pb.go
index 2e1a57005..35061e6e3 100644
--- a/x/contractmanager/types/tx.pb.go
+++ b/x/contractmanager/types/tx.pb.go
@@ -130,15 +130,108 @@ func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo
 
+// MsgResubmitFailure - contract that has failed acknowledgement can resubmit its failure
+type MsgResubmitFailure struct {
+	// sender is the contract which failure to acknowledge is resubmitted.
+	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
+	// failure_id is id of failure to resubmit
+	FailureId uint64 `protobuf:"varint,2,opt,name=failure_id,json=failureId,proto3" json:"failure_id,omitempty"`
+}
+
+func (m *MsgResubmitFailure) Reset()         { *m = MsgResubmitFailure{} }
+func (m *MsgResubmitFailure) String() string { return proto.CompactTextString(m) }
+func (*MsgResubmitFailure) ProtoMessage()    {}
+func (*MsgResubmitFailure) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4dc444ed708d435f, []int{2}
+}
+func (m *MsgResubmitFailure) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgResubmitFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgResubmitFailure.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 *MsgResubmitFailure) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgResubmitFailure.Merge(m, src)
+}
+func (m *MsgResubmitFailure) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgResubmitFailure) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgResubmitFailure.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgResubmitFailure proto.InternalMessageInfo
+
+func (m *MsgResubmitFailure) GetSender() string {
+	if m != nil {
+		return m.Sender
+	}
+	return ""
+}
+
+func (m *MsgResubmitFailure) GetFailureId() uint64 {
+	if m != nil {
+		return m.FailureId
+	}
+	return 0
+}
+
+type MsgResubmitFailureResponse struct {
+}
+
+func (m *MsgResubmitFailureResponse) Reset()         { *m = MsgResubmitFailureResponse{} }
+func (m *MsgResubmitFailureResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgResubmitFailureResponse) ProtoMessage()    {}
+func (*MsgResubmitFailureResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_4dc444ed708d435f, []int{3}
+}
+func (m *MsgResubmitFailureResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgResubmitFailureResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgResubmitFailureResponse.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 *MsgResubmitFailureResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgResubmitFailureResponse.Merge(m, src)
+}
+func (m *MsgResubmitFailureResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgResubmitFailureResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgResubmitFailureResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgResubmitFailureResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MsgUpdateParams)(nil), "neutron.contractmanager.MsgUpdateParams")
 	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "neutron.contractmanager.MsgUpdateParamsResponse")
+	proto.RegisterType((*MsgResubmitFailure)(nil), "neutron.contractmanager.MsgResubmitFailure")
+	proto.RegisterType((*MsgResubmitFailureResponse)(nil), "neutron.contractmanager.MsgResubmitFailureResponse")
 }
 
 func init() { proto.RegisterFile("neutron/contractmanager/tx.proto", fileDescriptor_4dc444ed708d435f) }
 
 var fileDescriptor_4dc444ed708d435f = []byte{
-	// 351 bytes of a gzipped FileDescriptorProto
+	// 449 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xc8, 0x4b, 0x2d, 0x2d,
 	0x29, 0xca, 0xcf, 0xd3, 0x4f, 0xce, 0xcf, 0x2b, 0x29, 0x4a, 0x4c, 0x2e, 0xc9, 0x4d, 0xcc, 0x4b,
 	0x4c, 0x4f, 0x2d, 0xd2, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x87, 0xaa,
@@ -154,13 +247,20 @@ var fileDescriptor_4dc444ed708d435f = []byte{
 	0x88, 0x45, 0x4e, 0x9c, 0x27, 0xee, 0xc9, 0x33, 0xac, 0x78, 0xbe, 0x41, 0x8b, 0x31, 0x08, 0xaa,
 	0xd3, 0xca, 0xa8, 0xe9, 0xf9, 0x06, 0x2d, 0x84, 0x99, 0x5d, 0xcf, 0x37, 0x68, 0xc9, 0xa3, 0x7b,
 	0x00, 0xcd, 0xbd, 0x4a, 0x92, 0x5c, 0xe2, 0x68, 0x42, 0x41, 0xa9, 0xc5, 0x05, 0xf9, 0x79, 0xc5,
-	0xa9, 0x46, 0x15, 0x5c, 0xcc, 0xbe, 0xc5, 0xe9, 0x42, 0x59, 0x5c, 0x3c, 0x28, 0x3e, 0xd4, 0xc0,
-	0xe9, 0x32, 0x34, 0x83, 0xa4, 0x0c, 0x88, 0x55, 0x09, 0xb3, 0x52, 0x8a, 0xb5, 0x01, 0xe4, 0x21,
-	0xa7, 0xe0, 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, 0xb2, 0x4c, 0xcf, 0x2c,
-	0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x87, 0x1a, 0xae, 0x9b, 0x5f, 0x94, 0x0e, 0x63,
-	0xeb, 0x97, 0x99, 0xea, 0x57, 0x60, 0x26, 0xa6, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0x70, 0xa4,
-	0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x43, 0x71, 0x4d, 0xd8, 0x74, 0x02, 0x00, 0x00,
+	0xa9, 0x4a, 0x33, 0x19, 0xb9, 0x84, 0x7c, 0x8b, 0xd3, 0x83, 0x52, 0x8b, 0x4b, 0x93, 0x72, 0x33,
+	0x4b, 0xdc, 0x12, 0x33, 0x73, 0x4a, 0x8b, 0x52, 0x85, 0x0c, 0xb8, 0xd8, 0x8a, 0x53, 0xf3, 0x52,
+	0x52, 0x8b, 0x08, 0x7a, 0x0f, 0xaa, 0x4e, 0x48, 0x96, 0x8b, 0x2b, 0x0d, 0xa2, 0x39, 0x3e, 0x33,
+	0x05, 0xec, 0x3f, 0x96, 0x20, 0x4e, 0xa8, 0x88, 0x67, 0x0a, 0xc4, 0xd9, 0x50, 0xb5, 0x20, 0x37,
+	0x2b, 0x61, 0x71, 0x33, 0x9a, 0x23, 0x94, 0x64, 0xb8, 0xa4, 0x30, 0x45, 0x61, 0x2e, 0x37, 0x7a,
+	0xcb, 0xc8, 0xc5, 0xec, 0x5b, 0x9c, 0x2e, 0x94, 0xc5, 0xc5, 0x83, 0x12, 0x39, 0x1a, 0x38, 0x03,
+	0x15, 0x2d, 0x0c, 0xa4, 0x0c, 0x88, 0x55, 0x09, 0xb3, 0x53, 0xa8, 0x98, 0x8b, 0x1f, 0x3d, 0xa4,
+	0xb4, 0xf1, 0x19, 0x82, 0xa6, 0x58, 0xca, 0x98, 0x04, 0xc5, 0x30, 0x4b, 0xa5, 0x58, 0x1b, 0x40,
+	0x09, 0xc0, 0x29, 0xf8, 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, 0x2c, 0xd3,
+	0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xa1, 0xe6, 0xeb, 0xe6, 0x17, 0xa5,
+	0xc3, 0xd8, 0xfa, 0x65, 0xa6, 0xfa, 0x15, 0x98, 0x99, 0xaf, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d,
+	0x9c, 0xc8, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x38, 0x89, 0x6e, 0xe5, 0xa4, 0x03, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -176,6 +276,7 @@ const _ = grpc.SupportPackageIsVersion4
 // 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 {
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
+	ResubmitFailure(ctx context.Context, in *MsgResubmitFailure, opts ...grpc.CallOption) (*MsgResubmitFailureResponse, error)
 }
 
 type msgClient struct {
@@ -195,9 +296,19 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
 	return out, nil
 }
 
+func (c *msgClient) ResubmitFailure(ctx context.Context, in *MsgResubmitFailure, opts ...grpc.CallOption) (*MsgResubmitFailureResponse, error) {
+	out := new(MsgResubmitFailureResponse)
+	err := c.cc.Invoke(ctx, "/neutron.contractmanager.Msg/ResubmitFailure", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MsgServer is the server API for Msg service.
 type MsgServer interface {
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
+	ResubmitFailure(context.Context, *MsgResubmitFailure) (*MsgResubmitFailureResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -207,6 +318,9 @@ type UnimplementedMsgServer struct {
 func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
 }
+func (*UnimplementedMsgServer) ResubmitFailure(ctx context.Context, req *MsgResubmitFailure) (*MsgResubmitFailureResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ResubmitFailure not implemented")
+}
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
@@ -230,6 +344,24 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_ResubmitFailure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgResubmitFailure)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).ResubmitFailure(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/neutron.contractmanager.Msg/ResubmitFailure",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).ResubmitFailure(ctx, req.(*MsgResubmitFailure))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "neutron.contractmanager.Msg",
 	HandlerType: (*MsgServer)(nil),
@@ -238,6 +370,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "UpdateParams",
 			Handler:    _Msg_UpdateParams_Handler,
 		},
+		{
+			MethodName: "ResubmitFailure",
+			Handler:    _Msg_ResubmitFailure_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "neutron/contractmanager/tx.proto",
@@ -306,6 +442,64 @@ func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgResubmitFailure) 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 *MsgResubmitFailure) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgResubmitFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.FailureId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.FailureId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Sender) > 0 {
+		i -= len(m.Sender)
+		copy(dAtA[i:], m.Sender)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgResubmitFailureResponse) 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 *MsgResubmitFailureResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgResubmitFailureResponse) 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
@@ -341,6 +535,31 @@ func (m *MsgUpdateParamsResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgResubmitFailure) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Sender)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.FailureId != 0 {
+		n += 1 + sovTx(uint64(m.FailureId))
+	}
+	return n
+}
+
+func (m *MsgResubmitFailureResponse) 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
 }
@@ -512,6 +731,157 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgResubmitFailure) 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: MsgResubmitFailure: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgResubmitFailure: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FailureId", wireType)
+			}
+			m.FailureId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.FailureId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		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 *MsgResubmitFailureResponse) 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: MsgResubmitFailureResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgResubmitFailureResponse: 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
diff --git a/x/dex/types/query.pb.go b/x/dex/types/query.pb.go
index e6fddf00e..9bb947c6f 100644
--- a/x/dex/types/query.pb.go
+++ b/x/dex/types/query.pb.go
@@ -2500,179 +2500,179 @@ func init() {
 func init() { proto.RegisterFile("neutron/dex/query.proto", fileDescriptor_b6613ea5fce61e9c) }
 
 var fileDescriptor_b6613ea5fce61e9c = []byte{
-	// 2744 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xef, 0x6f, 0x1c, 0x47,
-	0xf9, 0xcf, 0xf8, 0x5c, 0xc7, 0x1e, 0x3b, 0xb1, 0x33, 0x76, 0xea, 0xcb, 0xc5, 0xf1, 0xd9, 0xdb,
-	0xa6, 0x76, 0xd2, 0xf8, 0x36, 0x76, 0xbf, 0x49, 0xd3, 0xe4, 0x5b, 0x20, 0xae, 0x9b, 0xc4, 0xb4,
-	0x21, 0x66, 0x13, 0xda, 0x24, 0x14, 0xad, 0xd6, 0x77, 0x13, 0x7b, 0xf1, 0xde, 0xee, 0x66, 0x77,
-	0x2e, 0xf6, 0x29, 0xca, 0x9b, 0xf6, 0x0d, 0x42, 0x20, 0x05, 0xca, 0x0f, 0xa5, 0x48, 0xe5, 0x05,
-	0x02, 0x09, 0x21, 0x54, 0x7e, 0x89, 0x77, 0xbc, 0x41, 0x02, 0x55, 0x08, 0xa1, 0x4a, 0xe5, 0x05,
-	0x02, 0xc9, 0xa0, 0x84, 0x57, 0xe1, 0x0d, 0xf2, 0x5f, 0x80, 0x66, 0xf6, 0xd9, 0xf3, 0xee, 0xed,
-	0xec, 0xed, 0xd9, 0x39, 0x50, 0x5f, 0xf9, 0x76, 0xe6, 0x99, 0x99, 0xcf, 0xf3, 0x99, 0x67, 0xe6,
-	0x99, 0xf9, 0x8c, 0xf1, 0xa8, 0x4d, 0x6b, 0xcc, 0x73, 0x6c, 0xb5, 0x42, 0x37, 0xd4, 0xdb, 0x35,
-	0xea, 0xd5, 0x4b, 0xae, 0xe7, 0x30, 0x87, 0xf4, 0x43, 0x45, 0xa9, 0x42, 0x37, 0x0a, 0xc7, 0xcb,
-	0x8e, 0x5f, 0x75, 0x7c, 0x75, 0xd9, 0xf0, 0x69, 0x60, 0xa5, 0xde, 0x99, 0x5d, 0xa6, 0xcc, 0x98,
-	0x55, 0x5d, 0x63, 0xc5, 0xb4, 0x0d, 0x66, 0x3a, 0x76, 0xd0, 0xb0, 0x30, 0x1e, 0xb5, 0x0d, 0xad,
-	0xca, 0x8e, 0x19, 0xd6, 0x8f, 0xac, 0x38, 0x2b, 0x8e, 0xf8, 0xa9, 0xf2, 0x5f, 0x50, 0x3a, 0xb6,
-	0xe2, 0x38, 0x2b, 0x16, 0x55, 0x0d, 0xd7, 0x54, 0x0d, 0xdb, 0x76, 0x98, 0xe8, 0xd2, 0x87, 0xda,
-	0x22, 0xd4, 0x8a, 0xaf, 0xe5, 0xda, 0x2d, 0x95, 0x99, 0x55, 0xea, 0x33, 0xa3, 0xea, 0x82, 0xc1,
-	0x44, 0xd4, 0x8d, 0x0a, 0x75, 0x1d, 0xdf, 0x64, 0xba, 0x47, 0xcb, 0x8e, 0x57, 0x01, 0x8b, 0xa3,
-	0x51, 0x0b, 0xcb, 0xac, 0x9a, 0x4c, 0x77, 0xbc, 0x0a, 0xf5, 0x74, 0xe6, 0x19, 0x76, 0x79, 0x95,
-	0x82, 0xd9, 0xf1, 0x0c, 0x33, 0xbd, 0xe6, 0x53, 0x0f, 0x6c, 0xf3, 0x51, 0x5b, 0xd7, 0xf0, 0x8c,
-	0x6a, 0x88, 0xf7, 0xe9, 0x58, 0x8d, 0xe3, 0x58, 0xa1, 0x1f, 0xcd, 0xe5, 0x7a, 0x95, 0x32, 0xa3,
-	0x62, 0x30, 0x23, 0xd5, 0xc0, 0xa3, 0x3e, 0xf5, 0xee, 0x50, 0x5f, 0xe6, 0x28, 0x33, 0xcb, 0x6b,
-	0xba, 0x65, 0xde, 0xae, 0x99, 0x15, 0x93, 0xd5, 0x43, 0x7e, 0x63, 0x16, 0x1b, 0x41, 0xa9, 0x32,
-	0x82, 0xc9, 0xe7, 0xf9, 0xbc, 0x2d, 0x09, 0x98, 0x1a, 0xbd, 0x5d, 0xa3, 0x3e, 0x53, 0x2e, 0xe1,
-	0xe1, 0x58, 0xa9, 0xef, 0x3a, 0xb6, 0x4f, 0xc9, 0x2c, 0xee, 0x09, 0xdc, 0xc9, 0xa3, 0x09, 0x34,
-	0xdd, 0x3f, 0x37, 0x5c, 0x8a, 0x04, 0x43, 0x29, 0x30, 0x9e, 0xef, 0xfe, 0x70, 0xb3, 0xb8, 0x47,
-	0x03, 0x43, 0xe5, 0x7b, 0x08, 0x3f, 0x2b, 0xba, 0xba, 0x48, 0xd9, 0xeb, 0x9c, 0xb6, 0x2b, 0x9c,
-	0xb5, 0x6b, 0x01, 0x69, 0x5f, 0xf0, 0xa9, 0x07, 0x43, 0x92, 0x3c, 0xde, 0x6b, 0x54, 0x2a, 0x1e,
-	0xf5, 0x83, 0xce, 0xfb, 0xb4, 0xf0, 0x93, 0x14, 0x71, 0x7f, 0x48, 0xf2, 0x1a, 0xad, 0xe7, 0xbb,
-	0x44, 0x2d, 0x86, 0xa2, 0xd7, 0x68, 0x9d, 0x9c, 0xc1, 0xf9, 0xb2, 0x61, 0x95, 0xf5, 0x75, 0x93,
-	0xad, 0x56, 0x3c, 0x63, 0xdd, 0x58, 0xb6, 0xa8, 0xee, 0xaf, 0x1a, 0x1e, 0xf5, 0xf3, 0xb9, 0x09,
-	0x34, 0xdd, 0xab, 0x3d, 0xcd, 0xeb, 0xdf, 0x8c, 0x54, 0x5f, 0x15, 0xb5, 0xca, 0xfd, 0x2e, 0x7c,
-	0x34, 0x03, 0x1d, 0xb8, 0x6e, 0xe0, 0x7c, 0xda, 0xac, 0x03, 0x19, 0x4a, 0x8c, 0x0c, 0x69, 0x6f,
-	0x82, 0x1b, 0xa4, 0x1d, 0xb4, 0x64, 0x95, 0xe4, 0x1d, 0x84, 0x87, 0x65, 0x2e, 0x08, 0x87, 0xe7,
-	0x35, 0xde, 0xf4, 0xaf, 0x9b, 0xc5, 0x83, 0xc1, 0x32, 0xf2, 0x2b, 0x6b, 0x25, 0xd3, 0x51, 0xab,
-	0x06, 0x5b, 0x2d, 0x2d, 0xda, 0xec, 0xf1, 0x66, 0x51, 0xd6, 0x76, 0x6b, 0xb3, 0x58, 0xa8, 0x1b,
-	0x55, 0xeb, 0xac, 0x22, 0xa9, 0x54, 0x34, 0xb2, 0x9e, 0xa4, 0xc4, 0x86, 0xf9, 0x3a, 0x6f, 0x59,
-	0x2d, 0xe7, 0xeb, 0x02, 0xc6, 0xdb, 0x4b, 0x1c, 0x28, 0x78, 0xae, 0x14, 0x80, 0x2b, 0xf1, 0x35,
-	0x5e, 0x0a, 0x76, 0x0d, 0x58, 0xe9, 0xa5, 0x25, 0x63, 0x85, 0x42, 0x5b, 0x2d, 0xd2, 0x52, 0xf9,
-	0x18, 0xc1, 0x14, 0xa4, 0x0f, 0xd8, 0xd6, 0x14, 0xe4, 0x3a, 0x31, 0x05, 0x17, 0x63, 0x4e, 0x75,
-	0x09, 0xa7, 0xa6, 0x32, 0x9d, 0x0a, 0xf0, 0xc5, 0xbc, 0xfa, 0x0e, 0xc2, 0x13, 0xa9, 0x81, 0x15,
-	0x52, 0x38, 0x8a, 0xf7, 0xba, 0x86, 0xe9, 0xe9, 0x66, 0x05, 0x42, 0xbe, 0x87, 0x7f, 0x2e, 0x56,
-	0xc8, 0x11, 0x8c, 0xc5, 0x12, 0x36, 0xed, 0x0a, 0xdd, 0x10, 0x30, 0x72, 0x5a, 0x1f, 0x2f, 0x59,
-	0xe4, 0x05, 0xe4, 0x10, 0xee, 0x65, 0xce, 0x1a, 0xb5, 0x75, 0xd3, 0x16, 0xf1, 0xdd, 0xa7, 0xed,
-	0x15, 0xdf, 0x8b, 0x76, 0xf3, 0x5a, 0xe9, 0x6e, 0x5e, 0x2b, 0x4a, 0x1d, 0x4f, 0xb6, 0xc0, 0x05,
-	0x4c, 0x5f, 0xc3, 0xc3, 0x12, 0xa6, 0x61, 0x92, 0xc7, 0x5b, 0x93, 0x0c, 0x04, 0x1f, 0x48, 0x10,
-	0xac, 0xbc, 0x1f, 0x72, 0x22, 0x9b, 0xe9, 0x4c, 0x4e, 0xa2, 0x4e, 0x77, 0xc5, 0x9d, 0x8e, 0x87,
-	0x62, 0x6e, 0xd7, 0xa1, 0xf8, 0x5b, 0x04, 0xe4, 0xc8, 0x01, 0x66, 0x91, 0x93, 0x7b, 0x02, 0x72,
-	0x3a, 0x17, 0x79, 0x3f, 0x41, 0xf8, 0x70, 0xe8, 0x04, 0x8f, 0xe9, 0x85, 0x20, 0xe9, 0xf9, 0xd9,
-	0xfb, 0xec, 0x05, 0x09, 0x84, 0x5d, 0xd0, 0x48, 0x8e, 0xe3, 0x03, 0xa6, 0x5d, 0xb6, 0x6a, 0x15,
-	0xaa, 0x8b, 0x4c, 0xc5, 0xd3, 0x18, 0xec, 0xc3, 0x83, 0x50, 0xb1, 0xe4, 0x38, 0xd6, 0x82, 0xc1,
-	0x0c, 0xe5, 0x87, 0x08, 0x8f, 0xc9, 0xd1, 0x02, 0xdb, 0xff, 0x8f, 0x7b, 0x21, 0x6d, 0xfb, 0x40,
-	0x71, 0x21, 0x46, 0x31, 0x34, 0xd0, 0x44, 0x4a, 0x07, 0x7a, 0x1b, 0x2d, 0x3a, 0xc7, 0xea, 0x37,
-	0x10, 0x9e, 0x69, 0xb9, 0x4b, 0xcd, 0xd7, 0xcf, 0x07, 0x34, 0xfe, 0xcf, 0x78, 0x56, 0x7e, 0x8f,
-	0x70, 0xa9, 0x5d, 0x4c, 0xc0, 0xe6, 0x6b, 0x78, 0x20, 0x12, 0xbb, 0xfe, 0x8e, 0xb7, 0xcd, 0xfe,
-	0xed, 0xc0, 0xed, 0x20, 0xb9, 0xef, 0x45, 0x82, 0xe0, 0x9a, 0x59, 0x5e, 0x7b, 0x3d, 0x3c, 0xb9,
-	0x7c, 0x12, 0x36, 0x85, 0x9f, 0x23, 0x7c, 0x24, 0x05, 0x1c, 0x90, 0x7a, 0x11, 0xef, 0x8f, 0x1f,
-	0xb8, 0xa4, 0x81, 0x1a, 0x6b, 0x0b, 0x74, 0xee, 0x63, 0xd1, 0xc2, 0xce, 0x11, 0xfa, 0x3e, 0xc2,
-	0xd3, 0xe1, 0x2e, 0xbf, 0x68, 0x1b, 0x65, 0x66, 0xde, 0xa1, 0x1d, 0xdd, 0x71, 0xe3, 0x09, 0x2a,
-	0xd7, 0x9c, 0xa0, 0x32, 0xb3, 0xd0, 0x37, 0x11, 0x3e, 0xd6, 0x06, 0x40, 0x20, 0x98, 0xe2, 0x31,
-	0x13, 0x8c, 0xf4, 0x27, 0xcd, 0x4b, 0x87, 0xcc, 0xb4, 0xe1, 0x14, 0x0f, 0x48, 0x3b, 0x6f, 0x59,
-	0x99, 0xa4, 0x75, 0xea, 0xf4, 0xf3, 0xb7, 0x90, 0x88, 0xd6, 0x83, 0xb6, 0x4d, 0x44, 0xae, 0x03,
-	0x44, 0x74, 0x2e, 0x0e, 0x1f, 0x44, 0x72, 0x11, 0xdf, 0xf2, 0x35, 0xb8, 0xb3, 0x7c, 0x12, 0xd6,
-	0xf5, 0x4f, 0x23, 0x9b, 0x4e, 0x1c, 0x1b, 0x90, 0xbd, 0x80, 0xf7, 0xc5, 0x2e, 0x5a, 0xc0, 0xee,
-	0xa1, 0xf8, 0x9d, 0x27, 0xd2, 0x12, 0x88, 0x1d, 0x70, 0x23, 0x65, 0x9d, 0xe3, 0xf2, 0xed, 0x90,
-	0xcb, 0x8b, 0x94, 0x75, 0x8a, 0xcb, 0x8c, 0x65, 0x3c, 0x84, 0x73, 0xb7, 0x28, 0x15, 0xcb, 0xb7,
-	0x5b, 0xe3, 0x3f, 0x95, 0x0a, 0x70, 0x96, 0xc0, 0x90, 0xce, 0x19, 0xda, 0x31, 0x67, 0xca, 0x8f,
-	0x73, 0x70, 0x50, 0x7c, 0xd5, 0x67, 0x66, 0xd5, 0x60, 0xf4, 0x72, 0xcd, 0x62, 0xe6, 0x25, 0xc7,
-	0xbd, 0xba, 0x6e, 0xb8, 0x91, 0xfc, 0x5a, 0xf6, 0xa8, 0xc1, 0x1c, 0x2f, 0xcc, 0xaf, 0xf0, 0x49,
-	0x0a, 0xb8, 0xd7, 0xa3, 0x65, 0x6a, 0xde, 0xa1, 0x1e, 0x38, 0xdc, 0xf8, 0x26, 0x73, 0xb8, 0xc7,
-	0x73, 0x6a, 0x4c, 0x5c, 0x0c, 0x93, 0x7b, 0x74, 0x38, 0x8e, 0xc6, 0x4d, 0x34, 0xb0, 0x24, 0x5f,
-	0xc4, 0x7d, 0x46, 0xd5, 0xa9, 0xd9, 0x8c, 0x33, 0x28, 0xf6, 0xb2, 0xf9, 0x4f, 0xf1, 0x3b, 0x6e,
-	0xab, 0xcb, 0xd8, 0x76, 0x8b, 0xad, 0xcd, 0xe2, 0x50, 0x70, 0x05, 0x6b, 0x14, 0x29, 0x5a, 0x6f,
-	0xf0, 0x7b, 0xd1, 0x26, 0xdf, 0x46, 0x78, 0x88, 0x6e, 0x98, 0x0c, 0xd6, 0xb3, 0xeb, 0x99, 0x65,
-	0x9a, 0x7f, 0x4a, 0x0c, 0xb2, 0x06, 0x83, 0xfc, 0xdf, 0x8a, 0xc9, 0x56, 0x6b, 0xcb, 0xa5, 0xb2,
-	0x53, 0x55, 0x01, 0xed, 0x8c, 0xe3, 0xad, 0x84, 0xbf, 0xd5, 0x3b, 0xa7, 0xd4, 0x1a, 0x33, 0x2d,
-	0x3f, 0x18, 0x7f, 0xc9, 0xa3, 0xe5, 0x05, 0x5a, 0x7e, 0xbc, 0x59, 0x4c, 0xf4, 0xbb, 0xb5, 0x59,
-	0x1c, 0x0d, 0xa0, 0x34, 0xd7, 0x28, 0xda, 0x7e, 0x5e, 0x24, 0xb6, 0x82, 0x25, 0x5e, 0x40, 0x9e,
-	0xc3, 0x83, 0x2e, 0x0f, 0x8d, 0x65, 0xea, 0x33, 0x5d, 0x10, 0x91, 0xef, 0x11, 0x47, 0xb8, 0x7d,
-	0xbc, 0x78, 0x9e, 0xaf, 0x26, 0x5e, 0xc8, 0x2f, 0x3a, 0x93, 0x2d, 0xe6, 0x0a, 0xe2, 0xe2, 0x36,
-	0xee, 0x2d, 0x3b, 0xa6, 0xad, 0x3b, 0x35, 0xd6, 0x08, 0x89, 0xe8, 0x1a, 0x08, 0xa3, 0xff, 0x15,
-	0xc7, 0xb4, 0xe7, 0xcf, 0x81, 0xdf, 0x53, 0x11, 0xbf, 0x41, 0x3b, 0x0a, 0xfe, 0xcc, 0xf8, 0x95,
-	0x35, 0x95, 0xd5, 0x5d, 0xea, 0x8b, 0x06, 0x8f, 0x37, 0x8b, 0x8d, 0xde, 0xb5, 0xbd, 0xfc, 0xd7,
-	0x95, 0x1a, 0x53, 0xde, 0xeb, 0xc6, 0xcf, 0xc4, 0x80, 0x2d, 0x59, 0x46, 0x39, 0xb2, 0xd9, 0x3d,
-	0x59, 0x1c, 0xb5, 0xb8, 0x82, 0x1d, 0xc6, 0x7d, 0x41, 0x15, 0x77, 0x36, 0x48, 0x7d, 0x81, 0xed,
-	0x95, 0x1a, 0x23, 0x25, 0x3c, 0xb2, 0xbd, 0xe2, 0x74, 0xd3, 0xd6, 0x99, 0x23, 0xec, 0x9e, 0x12,
-	0x6b, 0x6f, 0xa8, 0xb1, 0xf6, 0x16, 0xed, 0x6b, 0x0e, 0xb7, 0x8f, 0xc5, 0x5e, 0x4f, 0x87, 0x63,
-	0xef, 0x2c, 0xc6, 0x90, 0x3f, 0xea, 0x2e, 0xcd, 0xef, 0x9d, 0x40, 0xd3, 0xfb, 0xe7, 0x0e, 0xa7,
-	0x25, 0x8f, 0xba, 0x4b, 0xb5, 0x3e, 0x27, 0xfc, 0x49, 0x2e, 0xe3, 0x41, 0xba, 0xe1, 0x9a, 0x9e,
-	0xd8, 0x9c, 0x74, 0x66, 0x56, 0x69, 0xbe, 0x57, 0x4c, 0x6c, 0xa1, 0x14, 0x68, 0x72, 0xa5, 0x50,
-	0x93, 0x2b, 0x5d, 0x0b, 0x35, 0xb9, 0xf9, 0x5e, 0xbe, 0xd8, 0xef, 0xff, 0xbd, 0x88, 0x78, 0xb8,
-	0x85, 0x8d, 0x79, 0x35, 0xa9, 0xe2, 0x7d, 0x55, 0x63, 0xe3, 0x7c, 0x80, 0x92, 0x13, 0xd2, 0x27,
-	0x7c, 0xbd, 0x94, 0x25, 0x7a, 0xec, 0xaf, 0x1a, 0x1b, 0xba, 0xd1, 0x68, 0xb6, 0xb5, 0x59, 0x3c,
-	0x18, 0x38, 0x1c, 0x2f, 0x57, 0xb4, 0x81, 0x46, 0xf7, 0x3c, 0x38, 0xfe, 0x9d, 0x03, 0x95, 0x23,
-	0x35, 0x38, 0x20, 0x70, 0xbf, 0x8b, 0xf0, 0x3e, 0xe6, 0x30, 0xc3, 0xe2, 0x73, 0xc5, 0x43, 0x2b,
-	0x3b, 0x7c, 0xaf, 0xef, 0x3c, 0x7c, 0xe3, 0x43, 0x6c, 0x6d, 0x16, 0x47, 0x02, 0x27, 0x62, 0xc5,
-	0x8a, 0xd6, 0x2f, 0xbe, 0x17, 0x6d, 0xde, 0x8a, 0xbc, 0x8b, 0xf0, 0x80, 0xbf, 0x6e, 0xb8, 0x0d,
-	0x60, 0x5d, 0x59, 0xc0, 0xde, 0xd8, 0x39, 0xb0, 0xd8, 0x08, 0x5b, 0x9b, 0xc5, 0xe1, 0x00, 0x57,
-	0xb4, 0x54, 0xd1, 0x30, 0xff, 0x04, 0x54, 0x9c, 0x2f, 0x51, 0xeb, 0xd4, 0x58, 0x00, 0x2b, 0xf7,
-	0xdf, 0xe0, 0x2b, 0x36, 0xc4, 0x36, 0x5f, 0xb1, 0x62, 0x45, 0xeb, 0xe7, 0xdf, 0x57, 0x6a, 0x8c,
-	0xb7, 0x52, 0xde, 0xc2, 0x43, 0x81, 0xa4, 0x29, 0x32, 0xcd, 0x93, 0x09, 0x30, 0x90, 0x18, 0x73,
-	0xdb, 0x89, 0x51, 0xc5, 0x23, 0x8d, 0xde, 0xe7, 0xeb, 0x8b, 0x0b, 0xd1, 0x11, 0x78, 0x42, 0x84,
-	0x11, 0xba, 0xb5, 0x1e, 0xfe, 0xb9, 0x58, 0x51, 0x3e, 0x83, 0x0f, 0x44, 0xe0, 0x40, 0xb4, 0x3d,
-	0x8f, 0xbb, 0x79, 0x35, 0xc4, 0xd8, 0x81, 0x44, 0xd6, 0x84, 0x6c, 0x29, 0x8c, 0x94, 0x99, 0xf8,
-	0x79, 0xe0, 0x32, 0x08, 0xc6, 0xe1, 0xc8, 0xfb, 0x71, 0x57, 0x63, 0xd0, 0x2e, 0xb3, 0xd2, 0x9c,
-	0xba, 0xb7, 0xcd, 0xb7, 0x53, 0xf7, 0x52, 0x54, 0x78, 0x4e, 0x4d, 0xdd, 0x61, 0x4b, 0x10, 0x7a,
-	0x07, 0xa2, 0x65, 0x0a, 0x8d, 0x1f, 0xf8, 0x9a, 0x41, 0x75, 0xea, 0xd8, 0xdc, 0x7c, 0x78, 0x93,
-	0x79, 0xe3, 0x36, 0x79, 0x93, 0x6b, 0xcb, 0x1b, 0x37, 0x52, 0xd6, 0xb9, 0xc3, 0xdb, 0x25, 0xa0,
-	0xe5, 0xaa, 0x59, 0xad, 0x59, 0x06, 0xa3, 0x0d, 0xd5, 0x22, 0xa0, 0xe5, 0x18, 0xce, 0x55, 0xfd,
-	0x15, 0xe0, 0x63, 0x34, 0x7e, 0x24, 0xf1, 0x57, 0x42, 0x63, 0x6e, 0xa3, 0x5c, 0x05, 0xc7, 0x13,
-	0x3d, 0x81, 0xe3, 0x2f, 0xe0, 0x6e, 0x8f, 0xfa, 0x2e, 0xf4, 0x55, 0x4c, 0xeb, 0x2b, 0x04, 0x29,
-	0x8c, 0x95, 0xcf, 0xe1, 0xf1, 0x58, 0xa7, 0x0d, 0xa5, 0xbc, 0xb1, 0x52, 0x4e, 0x44, 0x11, 0x16,
-	0x9a, 0x7b, 0x8d, 0xd8, 0x0b, 0x90, 0x37, 0x70, 0x31, 0xb5, 0x3f, 0xc0, 0x79, 0x3a, 0x86, 0x53,
-	0x69, 0xd1, 0x63, 0x1c, 0xea, 0x75, 0xc8, 0xea, 0x61, 0xd7, 0x29, 0x59, 0x7d, 0x36, 0x8a, 0x37,
-	0xc1, 0x42, 0x73, 0x23, 0x01, 0xba, 0x0c, 0x29, 0x21, 0xb5, 0x67, 0x40, 0x7e, 0x2e, 0x86, 0x7c,
-	0x2a, 0xab, 0xef, 0x38, 0xfc, 0x2f, 0xe3, 0x13, 0x52, 0x66, 0x2e, 0x98, 0x96, 0x45, 0x2b, 0x49,
-	0x3f, 0xce, 0x46, 0xfd, 0x98, 0x4e, 0x63, 0x29, 0xd1, 0x5a, 0x38, 0x54, 0x03, 0xc9, 0x2a, 0x7b,
-	0xac, 0xc6, 0xa2, 0x89, 0x7a, 0x76, 0xb2, 0xed, 0xd1, 0xe2, 0x2e, 0xde, 0x6c, 0xe2, 0xf1, 0x15,
-	0xc3, 0x2e, 0x53, 0x2b, 0xe9, 0xda, 0x5c, 0xd4, 0xb5, 0x89, 0xe6, 0xc1, 0x12, 0xad, 0x84, 0x4b,
-	0x14, 0xde, 0x0a, 0xd2, 0xfb, 0x6e, 0xc8, 0x86, 0x51, 0x57, 0xa6, 0x33, 0x7b, 0x8f, 0xbb, 0xa0,
-	0xc1, 0xfd, 0x23, 0x1c, 0x46, 0x76, 0xff, 0x28, 0x45, 0xe1, 0x8f, 0x35, 0x0f, 0x10, 0x6b, 0x21,
-	0xa0, 0x7f, 0x09, 0xce, 0xc9, 0xf2, 0x3e, 0x01, 0xf6, 0x99, 0x18, 0xec, 0x67, 0x5b, 0xf6, 0x1a,
-	0x83, 0x3c, 0xf7, 0xce, 0x24, 0x7e, 0x4a, 0xf4, 0x4f, 0x56, 0x71, 0x4f, 0xf0, 0x12, 0x47, 0xe2,
-	0x71, 0x9f, 0x7c, 0xe6, 0x2b, 0x4c, 0xa4, 0x1b, 0x04, 0x9d, 0x2b, 0x87, 0xdf, 0xfe, 0xf8, 0x9f,
-	0xef, 0x76, 0x1d, 0x24, 0xc3, 0x6a, 0xf2, 0x4d, 0x93, 0xfc, 0x0e, 0xe1, 0x83, 0x52, 0xb5, 0x90,
-	0xcc, 0x26, 0x3b, 0xce, 0x78, 0xff, 0x2b, 0xcc, 0xed, 0xa4, 0x09, 0xa0, 0x7b, 0x55, 0xa0, 0xfb,
-	0x34, 0x79, 0x59, 0x6d, 0xe7, 0x75, 0x56, 0xbd, 0x0b, 0x0a, 0xec, 0x3d, 0xf5, 0x6e, 0x44, 0x9e,
-	0xba, 0x47, 0x7e, 0x86, 0x70, 0x5e, 0x3a, 0xd0, 0x79, 0xcb, 0x92, 0xb9, 0x92, 0xf1, 0x34, 0x26,
-	0x73, 0x25, 0xeb, 0x71, 0x4b, 0x99, 0x11, 0xae, 0x4c, 0x91, 0xa3, 0x6d, 0xb9, 0x42, 0xfe, 0x84,
-	0xf0, 0x64, 0x1a, 0xe4, 0x86, 0xec, 0x4b, 0xce, 0xb6, 0x0f, 0xa4, 0x59, 0xbf, 0x2e, 0x9c, 0xdb,
-	0x55, 0x5b, 0xf0, 0xe6, 0xa4, 0xf0, 0xe6, 0x38, 0x99, 0x8e, 0x79, 0x23, 0x26, 0x21, 0xaa, 0x3f,
-	0x6f, 0xcf, 0x08, 0xf9, 0x23, 0xc2, 0x07, 0x92, 0x4a, 0xd4, 0x4c, 0x7b, 0x41, 0x11, 0x62, 0x2e,
-	0xb5, 0x6b, 0x0e, 0x30, 0xaf, 0x0b, 0x98, 0x1a, 0x59, 0xca, 0x22, 0x5d, 0xbd, 0x0b, 0xe7, 0x44,
-	0x1e, 0x3a, 0x70, 0xef, 0xe3, 0x3f, 0x1b, 0x67, 0xc4, 0xe6, 0x90, 0xfa, 0x15, 0xc2, 0x23, 0x89,
-	0x71, 0x79, 0x38, 0xcd, 0xb4, 0x47, 0x6b, 0x0b, 0x8f, 0x5a, 0x3d, 0x4e, 0x29, 0x2f, 0x0b, 0x8f,
-	0x5e, 0x24, 0xa7, 0x76, 0xe5, 0x11, 0xf9, 0x16, 0xc2, 0x83, 0xd1, 0x67, 0x18, 0x8e, 0x78, 0x5a,
-	0x0a, 0x41, 0xf2, 0xb4, 0x54, 0x38, 0xd6, 0x86, 0x25, 0xe0, 0x3c, 0x21, 0x70, 0x3e, 0x47, 0x9e,
-	0x4d, 0x06, 0x48, 0xf8, 0x78, 0x13, 0x09, 0x8e, 0x1f, 0x20, 0x3c, 0x14, 0xd3, 0xcf, 0x39, 0x2e,
-	0xf9, 0x68, 0xb2, 0xf7, 0x83, 0xc2, 0xf1, 0x76, 0x4c, 0x01, 0xd9, 0x19, 0x81, 0x6c, 0x8e, 0x9c,
-	0x54, 0xd3, 0xff, 0xa3, 0x42, 0x4e, 0xde, 0x1f, 0xba, 0xf0, 0xa1, 0x54, 0x0d, 0x97, 0x9c, 0x92,
-	0xc6, 0x66, 0x96, 0xd0, 0x5c, 0x38, 0xbd, 0xd3, 0x66, 0xe0, 0xc6, 0x6f, 0x90, 0xf0, 0xe3, 0xd7,
-	0xe8, 0xe6, 0x0d, 0xf2, 0x66, 0xcc, 0x95, 0x5b, 0x22, 0x7d, 0xeb, 0x9d, 0x88, 0xf2, 0x1b, 0xb1,
-	0x8e, 0x5b, 0x49, 0xd3, 0x3b, 0xee, 0xfa, 0x5f, 0x08, 0x8f, 0xa5, 0x7a, 0xc9, 0xa7, 0xff, 0x94,
-	0x74, 0x4e, 0x77, 0xc3, 0x67, 0x3b, 0xd2, 0xbb, 0xf2, 0x96, 0xa0, 0xf3, 0x8d, 0x9b, 0xc7, 0xc8,
-	0x54, 0x9b, 0x6c, 0x92, 0x63, 0x6d, 0xb3, 0x43, 0xbe, 0x8f, 0xf0, 0x60, 0x54, 0x16, 0x4d, 0x5f,
-	0x77, 0x12, 0xe9, 0x37, 0x65, 0xdd, 0xc9, 0x04, 0x5a, 0xe5, 0x45, 0xe1, 0xc6, 0x2c, 0x51, 0xd5,
-	0xd4, 0x7f, 0x28, 0x92, 0x07, 0xf7, 0x07, 0x08, 0x0f, 0x44, 0x7b, 0x94, 0xc1, 0x93, 0x2b, 0xd3,
-	0x32, 0x78, 0x29, 0xfa, 0xb1, 0xf2, 0x59, 0x01, 0x6f, 0x81, 0xcc, 0xef, 0x10, 0x5e, 0x53, 0x24,
-	0xdd, 0xa2, 0xf4, 0x1e, 0xf9, 0x11, 0xc2, 0x23, 0x32, 0x51, 0x52, 0xb6, 0x05, 0xb7, 0x10, 0x9a,
-	0x65, 0x5b, 0x70, 0x2b, 0xad, 0x53, 0x51, 0xa5, 0x5b, 0x1b, 0x85, 0x26, 0x7a, 0x95, 0xb7, 0xd1,
-	0x57, 0x1d, 0x57, 0xf7, 0xd7, 0x0d, 0xf7, 0x2b, 0x5d, 0x88, 0xfc, 0x02, 0xe1, 0xd1, 0x14, 0x1d,
-	0x8a, 0x9c, 0x4c, 0x1f, 0x5c, 0x7e, 0xf3, 0x29, 0xcc, 0xee, 0xa0, 0x05, 0x20, 0x9e, 0x13, 0x88,
-	0x9b, 0x23, 0xbb, 0x81, 0xd8, 0xe5, 0xcd, 0xa2, 0x61, 0xcb, 0x41, 0xdf, 0xc3, 0xdd, 0x7c, 0x06,
-	0xc9, 0x11, 0xc9, 0x11, 0x72, 0x5b, 0x61, 0x29, 0x8c, 0xa7, 0x55, 0xc3, 0xd0, 0xa7, 0xc5, 0xd0,
-	0x27, 0x49, 0x29, 0x31, 0xe1, 0xb1, 0x79, 0x4e, 0x4c, 0xae, 0x87, 0x7b, 0x43, 0xa9, 0x85, 0x4c,
-	0xca, 0xc7, 0x88, 0xc8, 0x30, 0x99, 0x30, 0x9e, 0x11, 0x30, 0x8e, 0x90, 0xc3, 0x32, 0x18, 0x81,
-	0x7e, 0x73, 0x8f, 0x7c, 0x0d, 0x96, 0x40, 0x43, 0x1e, 0x48, 0x5f, 0x02, 0x4d, 0xba, 0x47, 0x8b,
-	0x25, 0xd0, 0xac, 0x5c, 0x28, 0x53, 0x02, 0xca, 0x24, 0x29, 0xaa, 0xa9, 0xff, 0x13, 0xa8, 0xde,
-	0xe5, 0x70, 0xbe, 0x0a, 0x7b, 0x46, 0xd8, 0x43, 0xeb, 0x3d, 0xa3, 0x0d, 0x44, 0x29, 0x5a, 0x8a,
-	0xa2, 0x08, 0x44, 0x63, 0xa4, 0x90, 0x8e, 0x88, 0x7c, 0x1d, 0xe1, 0xc1, 0x26, 0x49, 0x42, 0x06,
-	0x46, 0xae, 0x7f, 0xc8, 0xc0, 0xa4, 0xe8, 0x1b, 0xca, 0x51, 0x01, 0xa6, 0x48, 0x8e, 0xc4, 0xc0,
-	0xf8, 0x60, 0xad, 0xc3, 0xe1, 0x81, 0x3c, 0x40, 0x98, 0x24, 0xd5, 0x07, 0xf2, 0x7c, 0xfa, 0x40,
-	0x09, 0xcd, 0xa3, 0x70, 0xa2, 0x3d, 0x63, 0x00, 0x36, 0x2d, 0x80, 0x29, 0x64, 0x42, 0x0e, 0x6c,
-	0x7d, 0x1b, 0xc4, 0x07, 0x08, 0x8f, 0xa6, 0x88, 0x0c, 0xb2, 0xf5, 0xde, 0x5a, 0xe9, 0x90, 0xad,
-	0xf7, 0x0c, 0x05, 0x03, 0x76, 0xa8, 0xe6, 0xf5, 0xde, 0x80, 0x9a, 0x58, 0xef, 0xe4, 0xcf, 0x08,
-	0x4f, 0x64, 0xa9, 0x08, 0xe4, 0xa5, 0x6c, 0xba, 0x52, 0x54, 0x8e, 0xc2, 0xd9, 0xdd, 0x34, 0x05,
-	0x67, 0x5e, 0x12, 0xce, 0xbc, 0x40, 0x66, 0x5b, 0xf3, 0xae, 0x27, 0x13, 0x35, 0xf9, 0x25, 0xc2,
-	0xf9, 0x34, 0x25, 0x81, 0xb4, 0xe0, 0x35, 0x45, 0xd1, 0x90, 0xdd, 0xfb, 0xb2, 0x84, 0x8a, 0x94,
-	0x9b, 0x52, 0x03, 0x7e, 0x59, 0xb4, 0x8b, 0xa1, 0x7e, 0x80, 0xf0, 0x88, 0x4c, 0x44, 0x90, 0xe5,
-	0xb5, 0x16, 0x02, 0x86, 0x2c, 0xaf, 0xb5, 0xd2, 0x26, 0xda, 0xd9, 0x06, 0xe6, 0x2f, 0x7e, 0xf8,
-	0x70, 0x1c, 0x7d, 0xf4, 0x70, 0x1c, 0xfd, 0xe3, 0xe1, 0x38, 0xba, 0xff, 0x68, 0x7c, 0xcf, 0x47,
-	0x8f, 0xc6, 0xf7, 0xfc, 0xe5, 0xd1, 0xf8, 0x9e, 0x9b, 0x33, 0xd9, 0x8f, 0x98, 0x1b, 0xc1, 0x49,
-	0xbb, 0xee, 0x52, 0x7f, 0xb9, 0x47, 0xbc, 0x1e, 0xbd, 0xf0, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x93, 0xa9, 0x81, 0xfd, 0x87, 0x2e, 0x00, 0x00,
+	// 2746 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xdf, 0x6f, 0x1c, 0x47,
+	0x1d, 0xcf, 0xf8, 0x1c, 0xc7, 0x1e, 0x3b, 0xb1, 0x33, 0x76, 0xea, 0xcb, 0xc5, 0xf1, 0xd9, 0xdb,
+	0x24, 0x76, 0xd2, 0xf8, 0x36, 0x76, 0x48, 0x9a, 0x26, 0x14, 0x88, 0xeb, 0x26, 0x31, 0x6d, 0x88,
+	0xd9, 0x84, 0x36, 0x09, 0x45, 0xab, 0xf5, 0xdd, 0xc4, 0x5e, 0xbc, 0xb7, 0xbb, 0xd9, 0xdd, 0x8b,
+	0x7d, 0x8a, 0xf2, 0x52, 0x5e, 0x10, 0xa2, 0x52, 0xa0, 0xfc, 0x50, 0x8b, 0x54, 0x1e, 0x2a, 0x90,
+	0x10, 0x42, 0xe5, 0x97, 0x78, 0xe3, 0x05, 0x09, 0x54, 0x21, 0x84, 0x2a, 0x95, 0x07, 0x04, 0x92,
+	0x41, 0x09, 0x4f, 0xe1, 0x05, 0xf9, 0x2f, 0x40, 0x33, 0xfb, 0xdd, 0xbd, 0xdd, 0xdb, 0xd9, 0xdb,
+	0xb3, 0x73, 0xa0, 0x3e, 0xf9, 0x76, 0xe6, 0x3b, 0x33, 0x9f, 0xef, 0x67, 0xbe, 0x33, 0xdf, 0x99,
+	0xcf, 0x18, 0x8f, 0x9a, 0xb4, 0xe6, 0x39, 0x96, 0x29, 0x57, 0xe8, 0x86, 0x7c, 0xb7, 0x46, 0x9d,
+	0x7a, 0xc9, 0x76, 0x2c, 0xcf, 0x22, 0xfd, 0x50, 0x51, 0xaa, 0xd0, 0x8d, 0xc2, 0x89, 0xb2, 0xe5,
+	0x56, 0x2d, 0x57, 0x5e, 0xd6, 0x5c, 0xea, 0x5b, 0xc9, 0xf7, 0x66, 0x97, 0xa9, 0xa7, 0xcd, 0xca,
+	0xb6, 0xb6, 0xa2, 0x9b, 0x9a, 0xa7, 0x5b, 0xa6, 0xdf, 0xb0, 0x30, 0x1e, 0xb5, 0x0d, 0xac, 0xca,
+	0x96, 0x1e, 0xd4, 0x8f, 0xac, 0x58, 0x2b, 0x16, 0xff, 0x29, 0xb3, 0x5f, 0x50, 0x3a, 0xb6, 0x62,
+	0x59, 0x2b, 0x06, 0x95, 0x35, 0x5b, 0x97, 0x35, 0xd3, 0xb4, 0x3c, 0xde, 0xa5, 0x0b, 0xb5, 0x45,
+	0xa8, 0xe5, 0x5f, 0xcb, 0xb5, 0x3b, 0xb2, 0xa7, 0x57, 0xa9, 0xeb, 0x69, 0x55, 0x1b, 0x0c, 0x26,
+	0xa2, 0x6e, 0x54, 0xa8, 0x6d, 0xb9, 0xba, 0xa7, 0x3a, 0xb4, 0x6c, 0x39, 0x15, 0xb0, 0x38, 0x1a,
+	0xb5, 0x30, 0xf4, 0xaa, 0xee, 0xa9, 0x96, 0x53, 0xa1, 0x8e, 0xea, 0x39, 0x9a, 0x59, 0x5e, 0xa5,
+	0x60, 0x76, 0x22, 0xc3, 0x4c, 0xad, 0xb9, 0xd4, 0x01, 0xdb, 0x7c, 0xd4, 0xd6, 0xd6, 0x1c, 0xad,
+	0x1a, 0xe0, 0x7d, 0x26, 0x56, 0x63, 0x59, 0x46, 0xe0, 0x47, 0x73, 0xb9, 0x5a, 0xa5, 0x9e, 0x56,
+	0xd1, 0x3c, 0x2d, 0xd5, 0xc0, 0xa1, 0x2e, 0x75, 0xee, 0x51, 0x57, 0xe4, 0xa8, 0xa7, 0x97, 0xd7,
+	0x54, 0x43, 0xbf, 0x5b, 0xd3, 0x2b, 0xba, 0x57, 0x0f, 0xf8, 0x8d, 0x59, 0x6c, 0xf8, 0xa5, 0xd2,
+	0x08, 0x26, 0x5f, 0x64, 0xf3, 0xb6, 0xc4, 0x61, 0x2a, 0xf4, 0x6e, 0x8d, 0xba, 0x9e, 0x74, 0x05,
+	0x0f, 0xc7, 0x4a, 0x5d, 0xdb, 0x32, 0x5d, 0x4a, 0x66, 0x71, 0x8f, 0xef, 0x4e, 0x1e, 0x4d, 0xa0,
+	0xe9, 0xfe, 0xb9, 0xe1, 0x52, 0x24, 0x18, 0x4a, 0xbe, 0xf1, 0x7c, 0xf7, 0x87, 0x9b, 0xc5, 0x5d,
+	0x0a, 0x18, 0x4a, 0x3f, 0x40, 0xf8, 0x08, 0xef, 0xea, 0x32, 0xf5, 0x5e, 0x65, 0xb4, 0x5d, 0x63,
+	0xac, 0xdd, 0xf0, 0x49, 0xfb, 0x92, 0x4b, 0x1d, 0x18, 0x92, 0xe4, 0xf1, 0x1e, 0xad, 0x52, 0x71,
+	0xa8, 0xeb, 0x77, 0xde, 0xa7, 0x04, 0x9f, 0xa4, 0x88, 0xfb, 0x03, 0x92, 0xd7, 0x68, 0x3d, 0xdf,
+	0xc5, 0x6b, 0x31, 0x14, 0xbd, 0x42, 0xeb, 0xe4, 0x1c, 0xce, 0x97, 0x35, 0xa3, 0xac, 0xae, 0xeb,
+	0xde, 0x6a, 0xc5, 0xd1, 0xd6, 0xb5, 0x65, 0x83, 0xaa, 0xee, 0xaa, 0xe6, 0x50, 0x37, 0x9f, 0x9b,
+	0x40, 0xd3, 0xbd, 0xca, 0x33, 0xac, 0xfe, 0xf5, 0x48, 0xf5, 0x75, 0x5e, 0x2b, 0x3d, 0xec, 0xc2,
+	0x47, 0x33, 0xd0, 0x81, 0xeb, 0x1a, 0xce, 0xa7, 0xcd, 0x3a, 0x90, 0x21, 0xc5, 0xc8, 0x10, 0xf6,
+	0xc6, 0xb9, 0x41, 0xca, 0x01, 0x43, 0x54, 0x49, 0xbe, 0x86, 0xf0, 0xb0, 0xc8, 0x05, 0xee, 0xf0,
+	0xbc, 0xc2, 0x9a, 0xfe, 0x6d, 0xb3, 0x78, 0xc0, 0x5f, 0x46, 0x6e, 0x65, 0xad, 0xa4, 0x5b, 0x72,
+	0x55, 0xf3, 0x56, 0x4b, 0x8b, 0xa6, 0xf7, 0x64, 0xb3, 0x28, 0x6a, 0xbb, 0xb5, 0x59, 0x2c, 0xd4,
+	0xb5, 0xaa, 0x71, 0x5e, 0x12, 0x54, 0x4a, 0x0a, 0x59, 0x4f, 0x52, 0x62, 0xc2, 0x7c, 0x5d, 0x34,
+	0x8c, 0x96, 0xf3, 0x75, 0x09, 0xe3, 0xc6, 0x12, 0x07, 0x0a, 0x8e, 0x95, 0x7c, 0x70, 0x25, 0xb6,
+	0xc6, 0x4b, 0xfe, 0xae, 0x01, 0x2b, 0xbd, 0xb4, 0xa4, 0xad, 0x50, 0x68, 0xab, 0x44, 0x5a, 0x4a,
+	0x1f, 0x23, 0x98, 0x82, 0xf4, 0x01, 0xdb, 0x9a, 0x82, 0x5c, 0x27, 0xa6, 0xe0, 0x72, 0xcc, 0xa9,
+	0x2e, 0xee, 0xd4, 0x54, 0xa6, 0x53, 0x3e, 0xbe, 0x98, 0x57, 0xdf, 0x43, 0x78, 0x22, 0x35, 0xb0,
+	0x02, 0x0a, 0x47, 0xf1, 0x1e, 0x5b, 0xd3, 0x1d, 0x55, 0xaf, 0x40, 0xc8, 0xf7, 0xb0, 0xcf, 0xc5,
+	0x0a, 0x39, 0x8c, 0x31, 0x5f, 0xc2, 0xba, 0x59, 0xa1, 0x1b, 0x1c, 0x46, 0x4e, 0xe9, 0x63, 0x25,
+	0x8b, 0xac, 0x80, 0x1c, 0xc4, 0xbd, 0x9e, 0xb5, 0x46, 0x4d, 0x55, 0x37, 0x79, 0x7c, 0xf7, 0x29,
+	0x7b, 0xf8, 0xf7, 0xa2, 0xd9, 0xbc, 0x56, 0xba, 0x9b, 0xd7, 0x8a, 0x54, 0xc7, 0x93, 0x2d, 0x70,
+	0x01, 0xd3, 0x37, 0xf0, 0xb0, 0x80, 0x69, 0x98, 0xe4, 0xf1, 0xd6, 0x24, 0x03, 0xc1, 0xfb, 0x13,
+	0x04, 0x4b, 0xef, 0x05, 0x9c, 0x88, 0x66, 0x3a, 0x93, 0x93, 0xa8, 0xd3, 0x5d, 0x71, 0xa7, 0xe3,
+	0xa1, 0x98, 0xdb, 0x71, 0x28, 0xfe, 0x0e, 0x01, 0x39, 0x62, 0x80, 0x59, 0xe4, 0xe4, 0x9e, 0x82,
+	0x9c, 0xce, 0x45, 0xde, 0x4f, 0x11, 0x3e, 0x14, 0x38, 0xc1, 0x62, 0x7a, 0xc1, 0x4f, 0x7a, 0x6e,
+	0xf6, 0x3e, 0x7b, 0x49, 0x00, 0x61, 0x07, 0x34, 0x92, 0x13, 0x78, 0xbf, 0x6e, 0x96, 0x8d, 0x5a,
+	0x85, 0xaa, 0x3c, 0x53, 0xb1, 0x34, 0x06, 0xfb, 0xf0, 0x20, 0x54, 0x2c, 0x59, 0x96, 0xb1, 0xa0,
+	0x79, 0x9a, 0xf4, 0x23, 0x84, 0xc7, 0xc4, 0x68, 0x81, 0xed, 0x4f, 0xe3, 0x5e, 0x48, 0xdb, 0x2e,
+	0x50, 0x5c, 0x88, 0x51, 0x0c, 0x0d, 0x14, 0x9e, 0xd2, 0x81, 0xde, 0xb0, 0x45, 0xe7, 0x58, 0xfd,
+	0x16, 0xc2, 0x33, 0x2d, 0x77, 0xa9, 0xf9, 0xfa, 0x45, 0x9f, 0xc6, 0xff, 0x1b, 0xcf, 0xd2, 0x1f,
+	0x10, 0x2e, 0xb5, 0x8b, 0x09, 0xd8, 0x7c, 0x05, 0x0f, 0x44, 0x62, 0xd7, 0xdd, 0xf6, 0xb6, 0xd9,
+	0xdf, 0x08, 0xdc, 0x0e, 0x92, 0xfb, 0x6e, 0x24, 0x08, 0x6e, 0xe8, 0xe5, 0xb5, 0x57, 0x83, 0x93,
+	0xcb, 0x27, 0x61, 0x53, 0xf8, 0x05, 0xc2, 0x87, 0x53, 0xc0, 0x01, 0xa9, 0x97, 0xf1, 0xbe, 0xf8,
+	0x81, 0x4b, 0x18, 0xa8, 0xb1, 0xb6, 0x40, 0xe7, 0x5e, 0x2f, 0x5a, 0xd8, 0x39, 0x42, 0xdf, 0x43,
+	0x78, 0x3a, 0xd8, 0xe5, 0x17, 0x4d, 0xad, 0xec, 0xe9, 0xf7, 0x68, 0x47, 0x77, 0xdc, 0x78, 0x82,
+	0xca, 0x35, 0x27, 0xa8, 0xcc, 0x2c, 0xf4, 0x6d, 0x84, 0x8f, 0xb7, 0x01, 0x10, 0x08, 0xa6, 0x78,
+	0x4c, 0x07, 0x23, 0xf5, 0x69, 0xf3, 0xd2, 0x41, 0x3d, 0x6d, 0x38, 0xc9, 0x01, 0xd2, 0x2e, 0x1a,
+	0x46, 0x26, 0x69, 0x9d, 0x3a, 0xfd, 0xfc, 0x3d, 0x20, 0xa2, 0xf5, 0xa0, 0x6d, 0x13, 0x91, 0xeb,
+	0x00, 0x11, 0x9d, 0x8b, 0xc3, 0x77, 0x22, 0xb9, 0x88, 0x6d, 0xf9, 0x0a, 0xdc, 0x59, 0x3e, 0x09,
+	0xeb, 0xfa, 0x67, 0x91, 0x4d, 0x27, 0x8e, 0x0d, 0xc8, 0x5e, 0xc0, 0x7b, 0x63, 0x17, 0x2d, 0x60,
+	0xf7, 0x60, 0xfc, 0xce, 0x13, 0x69, 0x09, 0xc4, 0x0e, 0xd8, 0x91, 0xb2, 0xce, 0x71, 0xf9, 0x66,
+	0xc0, 0xe5, 0x65, 0xea, 0x75, 0x8a, 0xcb, 0x8c, 0x65, 0x3c, 0x84, 0x73, 0x77, 0x28, 0xe5, 0xcb,
+	0xb7, 0x5b, 0x61, 0x3f, 0xa5, 0x0a, 0x70, 0x96, 0xc0, 0x90, 0xce, 0x19, 0xda, 0x36, 0x67, 0xd2,
+	0x4f, 0x72, 0x70, 0x50, 0x7c, 0xd9, 0xf5, 0xf4, 0xaa, 0xe6, 0xd1, 0xab, 0x35, 0xc3, 0xd3, 0xaf,
+	0x58, 0xf6, 0xf5, 0x75, 0xcd, 0x8e, 0xe4, 0xd7, 0xb2, 0x43, 0x35, 0xcf, 0x72, 0x82, 0xfc, 0x0a,
+	0x9f, 0xa4, 0x80, 0x7b, 0x1d, 0x5a, 0xa6, 0xfa, 0x3d, 0xea, 0x80, 0xc3, 0xe1, 0x37, 0x99, 0xc3,
+	0x3d, 0x8e, 0x55, 0xf3, 0xf8, 0xc5, 0x30, 0xb9, 0x47, 0x07, 0xe3, 0x28, 0xcc, 0x44, 0x01, 0x4b,
+	0xf2, 0x65, 0xdc, 0xa7, 0x55, 0xad, 0x9a, 0xe9, 0x31, 0x06, 0xf9, 0x5e, 0x36, 0xff, 0x19, 0x76,
+	0xc7, 0x6d, 0x75, 0x19, 0x6b, 0xb4, 0xd8, 0xda, 0x2c, 0x0e, 0xf9, 0x57, 0xb0, 0xb0, 0x48, 0x52,
+	0x7a, 0xfd, 0xdf, 0x8b, 0x26, 0xf9, 0x2e, 0xc2, 0x43, 0x74, 0x43, 0xf7, 0x60, 0x3d, 0xdb, 0x8e,
+	0x5e, 0xa6, 0xf9, 0xdd, 0x7c, 0x90, 0x35, 0x18, 0xe4, 0x53, 0x2b, 0xba, 0xb7, 0x5a, 0x5b, 0x2e,
+	0x95, 0xad, 0xaa, 0x0c, 0x68, 0x67, 0x2c, 0x67, 0x25, 0xf8, 0x2d, 0xdf, 0x3b, 0x23, 0xd7, 0x3c,
+	0xdd, 0x70, 0xfd, 0xf1, 0x97, 0x1c, 0x5a, 0x5e, 0xa0, 0xe5, 0x27, 0x9b, 0xc5, 0x44, 0xbf, 0x5b,
+	0x9b, 0xc5, 0x51, 0x1f, 0x4a, 0x73, 0x8d, 0xa4, 0xec, 0x63, 0x45, 0x7c, 0x2b, 0x58, 0x62, 0x05,
+	0xe4, 0x18, 0x1e, 0xb4, 0x59, 0x68, 0x2c, 0x53, 0xd7, 0x53, 0x39, 0x11, 0xf9, 0x1e, 0x7e, 0x84,
+	0xdb, 0xcb, 0x8a, 0xe7, 0xd9, 0x6a, 0x62, 0x85, 0xec, 0xa2, 0x33, 0xd9, 0x62, 0xae, 0x20, 0x2e,
+	0xee, 0xe2, 0xde, 0xb2, 0xa5, 0x9b, 0xaa, 0x55, 0xf3, 0xc2, 0x90, 0x88, 0xae, 0x81, 0x20, 0xfa,
+	0x5f, 0xb2, 0x74, 0x73, 0xfe, 0x02, 0xf8, 0x3d, 0x15, 0xf1, 0x1b, 0xb4, 0x23, 0xff, 0xcf, 0x8c,
+	0x5b, 0x59, 0x93, 0xbd, 0xba, 0x4d, 0x5d, 0xde, 0xe0, 0xc9, 0x66, 0x31, 0xec, 0x5d, 0xd9, 0xc3,
+	0x7e, 0x5d, 0xab, 0x79, 0xd2, 0xbb, 0xdd, 0xf8, 0xd9, 0x18, 0xb0, 0x25, 0x43, 0x2b, 0x47, 0x36,
+	0xbb, 0xa7, 0x8b, 0xa3, 0x16, 0x57, 0xb0, 0x43, 0xb8, 0xcf, 0xaf, 0x62, 0xce, 0xfa, 0xa9, 0xcf,
+	0xb7, 0xbd, 0x56, 0xf3, 0x48, 0x09, 0x8f, 0x34, 0x56, 0x9c, 0xaa, 0x9b, 0xaa, 0x67, 0x71, 0xbb,
+	0xdd, 0x7c, 0xed, 0x0d, 0x85, 0x6b, 0x6f, 0xd1, 0xbc, 0x61, 0x31, 0xfb, 0x58, 0xec, 0xf5, 0x74,
+	0x38, 0xf6, 0xce, 0x63, 0x0c, 0xf9, 0xa3, 0x6e, 0xd3, 0xfc, 0x9e, 0x09, 0x34, 0xbd, 0x6f, 0xee,
+	0x50, 0x5a, 0xf2, 0xa8, 0xdb, 0x54, 0xe9, 0xb3, 0x82, 0x9f, 0xe4, 0x2a, 0x1e, 0xa4, 0x1b, 0xb6,
+	0xee, 0xf0, 0xcd, 0x49, 0xf5, 0xf4, 0x2a, 0xcd, 0xf7, 0xf2, 0x89, 0x2d, 0x94, 0x7c, 0x4d, 0xae,
+	0x14, 0x68, 0x72, 0xa5, 0x1b, 0x81, 0x26, 0x37, 0xdf, 0xcb, 0x16, 0xfb, 0xc3, 0x7f, 0x14, 0x11,
+	0x0b, 0xb7, 0xa0, 0x31, 0xab, 0x26, 0x55, 0xbc, 0xb7, 0xaa, 0x6d, 0x5c, 0xf4, 0x51, 0x32, 0x42,
+	0xfa, 0xb8, 0xaf, 0x57, 0xb2, 0x44, 0x8f, 0x7d, 0x55, 0x6d, 0x43, 0xd5, 0xc2, 0x66, 0x5b, 0x9b,
+	0xc5, 0x03, 0xbe, 0xc3, 0xf1, 0x72, 0x49, 0x19, 0x08, 0xbb, 0x67, 0xc1, 0xf1, 0x9f, 0x1c, 0xa8,
+	0x1c, 0xa9, 0xc1, 0x01, 0x81, 0xfb, 0x7d, 0x84, 0xf7, 0x7a, 0x96, 0xa7, 0x19, 0x6c, 0xae, 0x58,
+	0x68, 0x65, 0x87, 0xef, 0xcd, 0xed, 0x87, 0x6f, 0x7c, 0x88, 0xad, 0xcd, 0xe2, 0x88, 0xef, 0x44,
+	0xac, 0x58, 0x52, 0xfa, 0xf9, 0xf7, 0xa2, 0xc9, 0x5a, 0x91, 0xb7, 0x11, 0x1e, 0x70, 0xd7, 0x35,
+	0x3b, 0x04, 0xd6, 0x95, 0x05, 0xec, 0xb5, 0xed, 0x03, 0x8b, 0x8d, 0xb0, 0xb5, 0x59, 0x1c, 0xf6,
+	0x71, 0x45, 0x4b, 0x25, 0x05, 0xb3, 0x4f, 0x40, 0xc5, 0xf8, 0xe2, 0xb5, 0x56, 0xcd, 0xf3, 0x61,
+	0xe5, 0xfe, 0x17, 0x7c, 0xc5, 0x86, 0x68, 0xf0, 0x15, 0x2b, 0x96, 0x94, 0x7e, 0xf6, 0x7d, 0xad,
+	0xe6, 0xb1, 0x56, 0xd2, 0x1b, 0x78, 0xc8, 0x97, 0x34, 0x79, 0xa6, 0x79, 0x3a, 0x01, 0x06, 0x12,
+	0x63, 0xae, 0x91, 0x18, 0x65, 0x3c, 0x12, 0xf6, 0x3e, 0x5f, 0x5f, 0x5c, 0x88, 0x8e, 0xc0, 0x12,
+	0x22, 0x8c, 0xd0, 0xad, 0xf4, 0xb0, 0xcf, 0xc5, 0x8a, 0xf4, 0x39, 0xbc, 0x3f, 0x02, 0x07, 0xa2,
+	0xed, 0x39, 0xdc, 0xcd, 0xaa, 0x21, 0xc6, 0xf6, 0x27, 0xb2, 0x26, 0x64, 0x4b, 0x6e, 0x24, 0xcd,
+	0xc4, 0xcf, 0x03, 0x57, 0x41, 0x30, 0x0e, 0x46, 0xde, 0x87, 0xbb, 0xc2, 0x41, 0xbb, 0xf4, 0x4a,
+	0x73, 0xea, 0x6e, 0x98, 0x37, 0x52, 0xf7, 0x52, 0x54, 0x78, 0x4e, 0x4d, 0xdd, 0x41, 0x4b, 0x10,
+	0x7a, 0x07, 0xa2, 0x65, 0x12, 0x8d, 0x1f, 0xf8, 0x9a, 0x41, 0x75, 0xea, 0xd8, 0xdc, 0x7c, 0x78,
+	0x13, 0x79, 0x63, 0x37, 0x79, 0x93, 0x6b, 0xcb, 0x1b, 0x3b, 0x52, 0xd6, 0xb9, 0xc3, 0xdb, 0x15,
+	0xa0, 0xe5, 0xba, 0x5e, 0xad, 0x19, 0x9a, 0x47, 0x43, 0xd5, 0xc2, 0xa7, 0xe5, 0x38, 0xce, 0x55,
+	0xdd, 0x15, 0xe0, 0x63, 0x34, 0x7e, 0x24, 0x71, 0x57, 0x02, 0x63, 0x66, 0x23, 0x5d, 0x07, 0xc7,
+	0x13, 0x3d, 0x81, 0xe3, 0xa7, 0x71, 0xb7, 0x43, 0x5d, 0x1b, 0xfa, 0x2a, 0xa6, 0xf5, 0x15, 0x80,
+	0xe4, 0xc6, 0xd2, 0x17, 0xf0, 0x78, 0xac, 0xd3, 0x50, 0x29, 0x0f, 0x57, 0xca, 0xc9, 0x28, 0xc2,
+	0x42, 0x73, 0xaf, 0x11, 0x7b, 0x0e, 0xf2, 0x16, 0x2e, 0xa6, 0xf6, 0x07, 0x38, 0xcf, 0xc6, 0x70,
+	0x4a, 0x2d, 0x7a, 0x8c, 0x43, 0xbd, 0x09, 0x59, 0x3d, 0xe8, 0x3a, 0x25, 0xab, 0xcf, 0x46, 0xf1,
+	0x26, 0x58, 0x68, 0x6e, 0xc4, 0x41, 0x97, 0x21, 0x25, 0xa4, 0xf6, 0x0c, 0xc8, 0x2f, 0xc4, 0x90,
+	0x4f, 0x65, 0xf5, 0x1d, 0x87, 0xff, 0x55, 0x7c, 0x52, 0xc8, 0xcc, 0x25, 0xdd, 0x30, 0x68, 0x25,
+	0xe9, 0xc7, 0xf9, 0xa8, 0x1f, 0xd3, 0x69, 0x2c, 0x25, 0x5a, 0x73, 0x87, 0x6a, 0x20, 0x59, 0x65,
+	0x8f, 0x15, 0x2e, 0x9a, 0xa8, 0x67, 0xa7, 0xda, 0x1e, 0x2d, 0xee, 0xe2, 0xed, 0x26, 0x1e, 0x5f,
+	0xd2, 0xcc, 0x32, 0x35, 0x92, 0xae, 0xcd, 0x45, 0x5d, 0x9b, 0x68, 0x1e, 0x2c, 0xd1, 0x8a, 0xbb,
+	0x44, 0xe1, 0xad, 0x20, 0xbd, 0xef, 0x50, 0x36, 0x8c, 0xba, 0x32, 0x9d, 0xd9, 0x7b, 0xdc, 0x05,
+	0x05, 0xee, 0x1f, 0xc1, 0x30, 0xa2, 0xfb, 0x47, 0x29, 0x0a, 0x7f, 0xac, 0x79, 0x80, 0x58, 0x0b,
+	0x0e, 0xfd, 0x2b, 0x70, 0x4e, 0x16, 0xf7, 0x09, 0xb0, 0xcf, 0xc5, 0x60, 0x1f, 0x69, 0xd9, 0x6b,
+	0x0c, 0xf2, 0xdc, 0x5b, 0x93, 0x78, 0x37, 0xef, 0x9f, 0xac, 0xe2, 0x1e, 0xff, 0x25, 0x8e, 0xc4,
+	0xe3, 0x3e, 0xf9, 0xcc, 0x57, 0x98, 0x48, 0x37, 0xf0, 0x3b, 0x97, 0x0e, 0xbd, 0xf9, 0xf1, 0xbf,
+	0xde, 0xee, 0x3a, 0x40, 0x86, 0xe5, 0xe4, 0x9b, 0x26, 0xf9, 0x3d, 0xc2, 0x07, 0x84, 0x6a, 0x21,
+	0x99, 0x4d, 0x76, 0x9c, 0xf1, 0xfe, 0x57, 0x98, 0xdb, 0x4e, 0x13, 0x40, 0xf7, 0x32, 0x47, 0xf7,
+	0x59, 0xf2, 0xa2, 0xdc, 0xce, 0xeb, 0xac, 0x7c, 0x1f, 0x14, 0xd8, 0x07, 0xf2, 0xfd, 0x88, 0x3c,
+	0xf5, 0x80, 0xfc, 0x1c, 0xe1, 0xbc, 0x70, 0xa0, 0x8b, 0x86, 0x21, 0x72, 0x25, 0xe3, 0x69, 0x4c,
+	0xe4, 0x4a, 0xd6, 0xe3, 0x96, 0x34, 0xc3, 0x5d, 0x99, 0x22, 0x47, 0xdb, 0x72, 0x85, 0xfc, 0x19,
+	0xe1, 0xc9, 0x34, 0xc8, 0xa1, 0xec, 0x4b, 0xce, 0xb7, 0x0f, 0xa4, 0x59, 0xbf, 0x2e, 0x5c, 0xd8,
+	0x51, 0x5b, 0xf0, 0xe6, 0x14, 0xf7, 0xe6, 0x04, 0x99, 0x8e, 0x79, 0xc3, 0x27, 0x21, 0xaa, 0x3f,
+	0x37, 0x66, 0x84, 0xfc, 0x09, 0xe1, 0xfd, 0x49, 0x25, 0x6a, 0xa6, 0xbd, 0xa0, 0x08, 0x30, 0x97,
+	0xda, 0x35, 0x07, 0x98, 0x37, 0x39, 0x4c, 0x85, 0x2c, 0x65, 0x91, 0x2e, 0xdf, 0x87, 0x73, 0x22,
+	0x0b, 0x1d, 0xb8, 0xf7, 0xb1, 0x9f, 0xe1, 0x19, 0xb1, 0x39, 0xa4, 0x7e, 0x8d, 0xf0, 0x48, 0x62,
+	0x5c, 0x16, 0x4e, 0x33, 0xed, 0xd1, 0xda, 0xc2, 0xa3, 0x56, 0x8f, 0x53, 0xd2, 0x8b, 0xdc, 0xa3,
+	0xe7, 0xc9, 0x99, 0x1d, 0x79, 0x44, 0xbe, 0x83, 0xf0, 0x60, 0xf4, 0x19, 0x86, 0x21, 0x9e, 0x16,
+	0x42, 0x10, 0x3c, 0x2d, 0x15, 0x8e, 0xb7, 0x61, 0x09, 0x38, 0x4f, 0x72, 0x9c, 0xc7, 0xc8, 0x91,
+	0x64, 0x80, 0x04, 0x8f, 0x37, 0x91, 0xe0, 0x78, 0x1f, 0xe1, 0xa1, 0x98, 0x7e, 0xce, 0x70, 0x89,
+	0x47, 0x13, 0xbd, 0x1f, 0x14, 0x4e, 0xb4, 0x63, 0x0a, 0xc8, 0xce, 0x71, 0x64, 0x73, 0xe4, 0x94,
+	0x9c, 0xfe, 0x1f, 0x15, 0x62, 0xf2, 0xfe, 0xd8, 0x85, 0x0f, 0xa6, 0x6a, 0xb8, 0xe4, 0x8c, 0x30,
+	0x36, 0xb3, 0x84, 0xe6, 0xc2, 0xd9, 0xed, 0x36, 0x03, 0x37, 0x7e, 0x8b, 0xb8, 0x1f, 0xbf, 0x41,
+	0xb7, 0x6f, 0x91, 0xd7, 0x63, 0xae, 0xdc, 0xe1, 0xe9, 0x5b, 0xed, 0x44, 0x94, 0xdf, 0x8a, 0x75,
+	0xdc, 0x4a, 0x9a, 0xde, 0x76, 0xd7, 0xff, 0x46, 0x78, 0x2c, 0xd5, 0x4b, 0x36, 0xfd, 0x67, 0x84,
+	0x73, 0xba, 0x13, 0x3e, 0xdb, 0x91, 0xde, 0xa5, 0x37, 0x38, 0x9d, 0xaf, 0xdd, 0x3e, 0x4e, 0xa6,
+	0xda, 0x64, 0x93, 0x1c, 0x6f, 0x9b, 0x1d, 0xf2, 0x43, 0x84, 0x07, 0xa3, 0xb2, 0x68, 0xfa, 0xba,
+	0x13, 0x48, 0xbf, 0x29, 0xeb, 0x4e, 0x24, 0xd0, 0x4a, 0xcf, 0x73, 0x37, 0x66, 0x89, 0x2c, 0xa7,
+	0xfe, 0x43, 0x91, 0x38, 0xb8, 0x3f, 0x40, 0x78, 0x20, 0xda, 0xa3, 0x08, 0x9e, 0x58, 0x99, 0x16,
+	0xc1, 0x4b, 0xd1, 0x8f, 0xa5, 0xcf, 0x73, 0x78, 0x0b, 0x64, 0x7e, 0x9b, 0xf0, 0x9a, 0x22, 0xe9,
+	0x0e, 0xa5, 0x0f, 0xc8, 0x8f, 0x11, 0x1e, 0x11, 0x89, 0x92, 0xa2, 0x2d, 0xb8, 0x85, 0xd0, 0x2c,
+	0xda, 0x82, 0x5b, 0x69, 0x9d, 0x92, 0x2c, 0xdc, 0xda, 0x28, 0x34, 0x51, 0xab, 0xac, 0x8d, 0xba,
+	0x6a, 0xd9, 0xaa, 0xbb, 0xae, 0xd9, 0x5f, 0xef, 0x42, 0xe4, 0x97, 0x08, 0x8f, 0xa6, 0xe8, 0x50,
+	0xe4, 0x54, 0xfa, 0xe0, 0xe2, 0x9b, 0x4f, 0x61, 0x76, 0x1b, 0x2d, 0x00, 0xf1, 0x1c, 0x47, 0xdc,
+	0x1c, 0xd9, 0x21, 0x62, 0x9b, 0x35, 0x8b, 0x86, 0x2d, 0x03, 0xfd, 0x00, 0x77, 0xb3, 0x19, 0x24,
+	0x87, 0x05, 0x47, 0xc8, 0x86, 0xc2, 0x52, 0x18, 0x4f, 0xab, 0x86, 0xa1, 0xcf, 0xf2, 0xa1, 0x4f,
+	0x91, 0x52, 0x62, 0xc2, 0x63, 0xf3, 0x9c, 0x98, 0x5c, 0x07, 0xf7, 0x06, 0x52, 0x0b, 0x99, 0x14,
+	0x8f, 0x11, 0x91, 0x61, 0x32, 0x61, 0x3c, 0xcb, 0x61, 0x1c, 0x26, 0x87, 0x44, 0x30, 0x7c, 0xfd,
+	0xe6, 0x01, 0xf9, 0x26, 0x2c, 0x81, 0x50, 0x1e, 0x48, 0x5f, 0x02, 0x4d, 0xba, 0x47, 0x8b, 0x25,
+	0xd0, 0xac, 0x5c, 0x48, 0x53, 0x1c, 0xca, 0x24, 0x29, 0xca, 0xa9, 0xff, 0x13, 0x28, 0xdf, 0x67,
+	0x70, 0xbe, 0x01, 0x7b, 0x46, 0xd0, 0x43, 0xeb, 0x3d, 0xa3, 0x0d, 0x44, 0x29, 0x5a, 0x8a, 0x24,
+	0x71, 0x44, 0x63, 0xa4, 0x90, 0x8e, 0x88, 0xbc, 0x85, 0xf0, 0x60, 0x93, 0x24, 0x21, 0x02, 0x23,
+	0xd6, 0x3f, 0x44, 0x60, 0x52, 0xf4, 0x0d, 0xe9, 0x28, 0x07, 0x53, 0x24, 0x87, 0x63, 0x60, 0x5c,
+	0xb0, 0x56, 0xe1, 0xf0, 0x40, 0xde, 0x41, 0x98, 0x24, 0xd5, 0x07, 0xf2, 0x5c, 0xfa, 0x40, 0x09,
+	0xcd, 0xa3, 0x70, 0xb2, 0x3d, 0x63, 0x00, 0x36, 0xcd, 0x81, 0x49, 0x64, 0x42, 0x0c, 0x6c, 0xbd,
+	0x01, 0xe2, 0x03, 0x84, 0x47, 0x53, 0x44, 0x06, 0xd1, 0x7a, 0x6f, 0xad, 0x74, 0x88, 0xd6, 0x7b,
+	0x86, 0x82, 0x01, 0x3b, 0x54, 0xf3, 0x7a, 0x0f, 0xa1, 0x26, 0xd6, 0x3b, 0xf9, 0x0b, 0xc2, 0x13,
+	0x59, 0x2a, 0x02, 0x79, 0x21, 0x9b, 0xae, 0x14, 0x95, 0xa3, 0x70, 0x7e, 0x27, 0x4d, 0xc1, 0x99,
+	0x17, 0xb8, 0x33, 0xa7, 0xc9, 0x6c, 0x6b, 0xde, 0xd5, 0x64, 0xa2, 0x26, 0xbf, 0x42, 0x38, 0x9f,
+	0xa6, 0x24, 0x90, 0x16, 0xbc, 0xa6, 0x28, 0x1a, 0xa2, 0x7b, 0x5f, 0x96, 0x50, 0x91, 0x72, 0x53,
+	0x0a, 0xe1, 0x97, 0x79, 0xbb, 0x18, 0xea, 0xf7, 0x11, 0x1e, 0x11, 0x89, 0x08, 0xa2, 0xbc, 0xd6,
+	0x42, 0xc0, 0x10, 0xe5, 0xb5, 0x56, 0xda, 0x44, 0xca, 0x91, 0x3d, 0x44, 0x1a, 0xcf, 0x6b, 0xf3,
+	0x97, 0x3f, 0x7c, 0x34, 0x8e, 0x3e, 0x7a, 0x34, 0x8e, 0xfe, 0xf9, 0x68, 0x1c, 0x3d, 0x7c, 0x3c,
+	0xbe, 0xeb, 0xa3, 0xc7, 0xe3, 0xbb, 0xfe, 0xfa, 0x78, 0x7c, 0xd7, 0xed, 0x99, 0xec, 0xe7, 0xcc,
+	0x0d, 0xff, 0xcc, 0x5d, 0xb7, 0xa9, 0xbb, 0xdc, 0xc3, 0xdf, 0x91, 0x4e, 0xff, 0x37, 0x00, 0x00,
+	0xff, 0xff, 0x02, 0x04, 0x07, 0xcf, 0x91, 0x2e, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/x/dex/types/query.pb.gw.go b/x/dex/types/query.pb.gw.go
index 072db61b8..d6f00e3b6 100644
--- a/x/dex/types/query.pb.gw.go
+++ b/x/dex/types/query.pb.gw.go
@@ -2908,7 +2908,7 @@ var (
 
 	pattern_Query_SimulateCancelLimitOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"neutron", "dex", "simulate_cancel_limit_order"}, "", runtime.AssumeColonVerbOpt(false)))
 
-	pattern_Query_SimulateMultiHopSwap_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"neutron", "dex", "pool_metadata"}, "", runtime.AssumeColonVerbOpt(false)))
+	pattern_Query_SimulateMultiHopSwap_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"neutron", "dex", "simulate_multi_hop_swap"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
diff --git a/x/interchaintxs/types/tx.go b/x/interchaintxs/types/tx.go
index 26f31e4b3..f416cc46f 100644
--- a/x/interchaintxs/types/tx.go
+++ b/x/interchaintxs/types/tx.go
@@ -18,8 +18,6 @@ const interchainAccountIDLimit = 128 -
 	len("neutron1unyuj8qnmygvzuex3dwmg9yzt9alhvyeat0uu0jedg2wj33efl5qmysp02") - // just a random contract address
 	len(".")
 
-var _ codectypes.UnpackInterfacesMessage = &MsgSubmitTx{}
-
 func (msg *MsgRegisterInterchainAccount) Validate() error {
 	if len(msg.ConnectionId) == 0 {
 		return ErrEmptyConnectionID
@@ -119,17 +117,6 @@ func PackTxMsgAny(sdkMsg sdk.Msg) (*codectypes.Any, error) {
 	return value, nil
 }
 
-// implements UnpackInterfacesMessage.UnpackInterfaces (https://github.com/cosmos/cosmos-sdk/blob/d07d35f29e0a0824b489c552753e8798710ff5a8/codec/types/interface_registry.go#L60)
-func (msg *MsgSubmitTx) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
-	var sdkMsg sdk.Msg
-	for _, m := range msg.Msgs {
-		if err := unpacker.UnpackAny(m, &sdkMsg); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 //----------------------------------------------------------------
 
 var _ sdk.Msg = &MsgUpdateParams{}
diff --git a/x/tokenfactory/keeper/grpc_query.go b/x/tokenfactory/keeper/grpc_query.go
index dbba4a595..0c6827d8e 100644
--- a/x/tokenfactory/keeper/grpc_query.go
+++ b/x/tokenfactory/keeper/grpc_query.go
@@ -44,3 +44,16 @@ func (k Keeper) BeforeSendHookAddress(ctx context.Context, req *types.QueryBefor
 
 	return &types.QueryBeforeSendHookAddressResponse{ContractAddr: contractAddr}, nil
 }
+
+func (k Keeper) FullDenom(_ context.Context, req *types.QueryFullDenomRequest) (*types.QueryFullDenomResponse, error) {
+	if _, err := sdk.AccAddressFromBech32(req.Creator); err != nil {
+		return nil, err
+	}
+
+	fullDenom, err := types.GetTokenDenom(req.Creator, req.Subdenom)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.QueryFullDenomResponse{FullDenom: fullDenom}, nil
+}
diff --git a/x/tokenfactory/types/query.pb.go b/x/tokenfactory/types/query.pb.go
index ebde7e9b6..9bdee336b 100644
--- a/x/tokenfactory/types/query.pb.go
+++ b/x/tokenfactory/types/query.pb.go
@@ -304,6 +304,8 @@ func (m *QueryDenomsFromCreatorResponse) GetDenoms() []string {
 	return nil
 }
 
+// QueryBeforeSendHookAddressRequest defines the request structure for the
+// BeforeSendHookAddress gRPC query.
 type QueryBeforeSendHookAddressRequest struct {
 	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
 	Subdenom string `protobuf:"bytes,2,opt,name=subdenom,proto3" json:"subdenom,omitempty" yaml:"subdenom"`
@@ -357,7 +359,7 @@ func (m *QueryBeforeSendHookAddressRequest) GetSubdenom() string {
 }
 
 // QueryBeforeSendHookAddressResponse defines the response structure for the
-// DenomBeforeSendHook gRPC query.
+// BeforeSendHookAddress gRPC query.
 type QueryBeforeSendHookAddressResponse struct {
 	ContractAddr string `protobuf:"bytes,1,opt,name=contract_addr,json=contractAddr,proto3" json:"contract_addr,omitempty" yaml:"contract_addr"`
 }
@@ -402,6 +404,106 @@ func (m *QueryBeforeSendHookAddressResponse) GetContractAddr() string {
 	return ""
 }
 
+// QueryFullDenomRequest defines the request structure for the
+// FullDenom gRPC query.
+type QueryFullDenomRequest struct {
+	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
+	Subdenom string `protobuf:"bytes,2,opt,name=subdenom,proto3" json:"subdenom,omitempty" yaml:"subdenom"`
+}
+
+func (m *QueryFullDenomRequest) Reset()         { *m = QueryFullDenomRequest{} }
+func (m *QueryFullDenomRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryFullDenomRequest) ProtoMessage()    {}
+func (*QueryFullDenomRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6f22013ad0f72e3f, []int{8}
+}
+func (m *QueryFullDenomRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFullDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFullDenomRequest.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 *QueryFullDenomRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFullDenomRequest.Merge(m, src)
+}
+func (m *QueryFullDenomRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFullDenomRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFullDenomRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFullDenomRequest proto.InternalMessageInfo
+
+func (m *QueryFullDenomRequest) GetCreator() string {
+	if m != nil {
+		return m.Creator
+	}
+	return ""
+}
+
+func (m *QueryFullDenomRequest) GetSubdenom() string {
+	if m != nil {
+		return m.Subdenom
+	}
+	return ""
+}
+
+// QueryFullDenomResponse defines the response structure for the
+// FullDenom gRPC query.
+type QueryFullDenomResponse struct {
+	FullDenom string `protobuf:"bytes,1,opt,name=full_denom,json=fullDenom,proto3" json:"full_denom,omitempty" yaml:"full_denom"`
+}
+
+func (m *QueryFullDenomResponse) Reset()         { *m = QueryFullDenomResponse{} }
+func (m *QueryFullDenomResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryFullDenomResponse) ProtoMessage()    {}
+func (*QueryFullDenomResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6f22013ad0f72e3f, []int{9}
+}
+func (m *QueryFullDenomResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryFullDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryFullDenomResponse.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 *QueryFullDenomResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryFullDenomResponse.Merge(m, src)
+}
+func (m *QueryFullDenomResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryFullDenomResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryFullDenomResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryFullDenomResponse proto.InternalMessageInfo
+
+func (m *QueryFullDenomResponse) GetFullDenom() string {
+	if m != nil {
+		return m.FullDenom
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterType((*QueryParamsRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryParamsRequest")
 	proto.RegisterType((*QueryParamsResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryParamsResponse")
@@ -411,6 +513,8 @@ func init() {
 	proto.RegisterType((*QueryDenomsFromCreatorResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorResponse")
 	proto.RegisterType((*QueryBeforeSendHookAddressRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryBeforeSendHookAddressRequest")
 	proto.RegisterType((*QueryBeforeSendHookAddressResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryBeforeSendHookAddressResponse")
+	proto.RegisterType((*QueryFullDenomRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryFullDenomRequest")
+	proto.RegisterType((*QueryFullDenomResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryFullDenomResponse")
 }
 
 func init() {
@@ -418,50 +522,55 @@ func init() {
 }
 
 var fileDescriptor_6f22013ad0f72e3f = []byte{
-	// 675 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcf, 0x4f, 0x13, 0x41,
-	0x14, 0xee, 0xa2, 0x56, 0x19, 0x45, 0xc3, 0x80, 0x06, 0x1b, 0xdc, 0xca, 0x68, 0x0c, 0x26, 0xb8,
-	0x23, 0x88, 0x1e, 0x40, 0x22, 0x14, 0x63, 0x4c, 0x0c, 0x09, 0xac, 0xc4, 0x03, 0x31, 0x69, 0xa6,
-	0xdd, 0xa1, 0x34, 0xb0, 0xfb, 0xca, 0xcc, 0x94, 0xd8, 0x10, 0x2e, 0x98, 0x78, 0x36, 0xf1, 0xe8,
-	0xff, 0xe0, 0xdf, 0xc1, 0x91, 0x84, 0x8b, 0xa7, 0xc6, 0x80, 0x7f, 0x41, 0x0f, 0x5e, 0xbc, 0x98,
-	0xce, 0xcc, 0xf2, 0xc3, 0x96, 0x4d, 0x85, 0xc4, 0xdb, 0x76, 0xde, 0xf7, 0xbe, 0xf7, 0x7d, 0xef,
-	0x47, 0x8a, 0x86, 0x41, 0x86, 0x20, 0xcb, 0x92, 0x2a, 0x58, 0xe5, 0xd1, 0x32, 0x2b, 0x2a, 0x10,
-	0x35, 0xba, 0x31, 0x5a, 0xe0, 0x8a, 0x8d, 0xd2, 0xf5, 0x2a, 0x17, 0x35, 0xaf, 0x22, 0x40, 0x01,
-	0x1e, 0xb4, 0x48, 0xef, 0x38, 0xd2, 0xb3, 0xc8, 0x4c, 0x7f, 0x09, 0x4a, 0xa0, 0x81, 0xb4, 0xf9,
-	0x65, 0x72, 0x32, 0x83, 0x25, 0x80, 0xd2, 0x1a, 0xa7, 0xac, 0x52, 0xa6, 0x2c, 0x8a, 0x40, 0x31,
-	0x55, 0x86, 0x48, 0xda, 0xe8, 0x50, 0xdb, 0xda, 0x15, 0x26, 0x58, 0x18, 0x43, 0xc6, 0x13, 0xe5,
-	0xb1, 0xaa, 0x5a, 0x01, 0x51, 0x56, 0xb5, 0x39, 0xae, 0x58, 0xc0, 0x14, 0x33, 0x59, 0xa4, 0x1f,
-	0xe1, 0x85, 0xa6, 0xf2, 0x79, 0x4d, 0xe5, 0xf3, 0xf5, 0x2a, 0x97, 0x8a, 0x2c, 0xa0, 0xbe, 0x13,
-	0xaf, 0xb2, 0x02, 0x91, 0xe4, 0x78, 0x02, 0xa5, 0x4d, 0xc9, 0x01, 0xe7, 0xae, 0x33, 0x7c, 0x75,
-	0x6c, 0xd0, 0x6b, 0x6b, 0xd4, 0x64, 0xe5, 0x2e, 0xee, 0xd4, 0xb3, 0x29, 0xdf, 0x66, 0x90, 0x8f,
-	0x0e, 0x22, 0x9a, 0xf3, 0x25, 0x8f, 0x20, 0x9c, 0xf9, 0x5b, 0x8e, 0xad, 0x8c, 0x47, 0xd0, 0xe5,
-	0xa2, 0xe0, 0x4c, 0x81, 0xd0, 0x35, 0xba, 0x73, 0xb8, 0x51, 0xcf, 0x5e, 0xaf, 0xb1, 0x70, 0x6d,
-	0x82, 0xd8, 0x00, 0xf1, 0x63, 0x08, 0xa6, 0xe8, 0x8a, 0xac, 0x16, 0x82, 0x26, 0xe3, 0x40, 0x97,
-	0x86, 0xf7, 0x35, 0xea, 0xd9, 0x1b, 0x06, 0x1e, 0x47, 0x88, 0x7f, 0x08, 0x22, 0xdf, 0x1c, 0x74,
-	0x2f, 0x51, 0x85, 0x75, 0xfa, 0xc9, 0x41, 0xf8, 0xb0, 0x65, 0xf9, 0xd0, 0x86, 0xad, 0xed, 0x71,
-	0x2f, 0x69, 0xbe, 0x5e, 0x7b, 0xea, 0xdc, 0x50, 0xb3, 0x1d, 0x8d, 0x7a, 0xf6, 0xb6, 0x51, 0xd7,
-	0xca, 0x4e, 0xfc, 0xde, 0x96, 0x29, 0x91, 0x39, 0x74, 0xe7, 0x48, 0xaf, 0x7c, 0x25, 0x20, 0x9c,
-	0x35, 0xde, 0xcf, 0xd4, 0x30, 0xf2, 0x06, 0xb9, 0xa7, 0xd1, 0x59, 0xe7, 0x0f, 0x51, 0x5a, 0xb7,
-	0xaa, 0x39, 0xe3, 0x0b, 0xc3, 0xdd, 0xb9, 0xde, 0x46, 0x3d, 0xdb, 0x63, 0xe8, 0xcc, 0x3b, 0xf1,
-	0x2d, 0x80, 0x6c, 0x3b, 0x68, 0x48, 0xb3, 0xe5, 0xf8, 0x32, 0x08, 0xfe, 0x96, 0x47, 0xc1, 0x6b,
-	0x80, 0xd5, 0x99, 0x20, 0x10, 0x5c, 0xca, 0xff, 0x34, 0xd1, 0xa2, 0x5d, 0xab, 0x53, 0x34, 0x58,
-	0x57, 0x53, 0xa8, 0xa7, 0x08, 0x91, 0x12, 0xac, 0xa8, 0xf2, 0x2c, 0x08, 0x62, 0x29, 0x03, 0x8d,
-	0x7a, 0xb6, 0xdf, 0x4a, 0x39, 0x1e, 0x26, 0xfe, 0xb5, 0xf8, 0x77, 0x93, 0x69, 0xac, 0x91, 0x46,
-	0x97, 0x74, 0x15, 0xfc, 0xd5, 0x41, 0x69, 0xb3, 0xdf, 0xf8, 0x71, 0xf2, 0x1a, 0xb4, 0x9e, 0x55,
-	0x66, 0xf4, 0x1f, 0x32, 0x8c, 0x70, 0x32, 0xb2, 0xbd, 0xf7, 0xf3, 0x4b, 0xd7, 0x03, 0x7c, 0x9f,
-	0x26, 0x9e, 0xb7, 0x39, 0x32, 0xfc, 0xdb, 0x41, 0xb7, 0xda, 0xaf, 0x1f, 0x9e, 0xee, 0xa0, 0x76,
-	0xe2, 0x69, 0x66, 0x66, 0xce, 0xc1, 0x60, 0xdd, 0xbc, 0xd7, 0x6e, 0xde, 0xe1, 0xc5, 0x64, 0x37,
-	0x66, 0xbf, 0x68, 0xfc, 0xbc, 0x69, 0x97, 0x63, 0x8b, 0x6e, 0xc6, 0x63, 0xdf, 0xa2, 0xad, 0xf7,
-	0x83, 0xf7, 0x1c, 0xd4, 0xdb, 0xb2, 0xd8, 0x78, 0xb2, 0x53, 0xd9, 0x6d, 0xae, 0x2b, 0xf3, 0xfc,
-	0x6c, 0xc9, 0xd6, 0xee, 0xac, 0xb6, 0x3b, 0x85, 0x27, 0x3b, 0xb1, 0x9b, 0x5f, 0x16, 0x10, 0xe6,
-	0xad, 0xd5, 0x23, 0xcf, 0xf8, 0x97, 0x83, 0x6e, 0xb6, 0x5d, 0x6e, 0xfc, 0xa2, 0x03, 0x71, 0x49,
-	0xa7, 0x99, 0x99, 0x3e, 0x3b, 0x81, 0x75, 0xb8, 0xa4, 0x1d, 0x2e, 0x62, 0xff, 0xfc, 0x03, 0x2d,
-	0xe8, 0x42, 0x79, 0xc9, 0xa3, 0x20, 0xbf, 0x02, 0xb0, 0x9a, 0x9b, 0xdf, 0xd9, 0x77, 0x9d, 0xdd,
-	0x7d, 0xd7, 0xf9, 0xb1, 0xef, 0x3a, 0x9f, 0x0f, 0xdc, 0xd4, 0xee, 0x81, 0x9b, 0xfa, 0x7e, 0xe0,
-	0xa6, 0x96, 0x9e, 0x95, 0xca, 0x6a, 0xa5, 0x5a, 0xf0, 0x8a, 0x10, 0xd2, 0x88, 0x57, 0x95, 0x80,
-	0xe8, 0x11, 0x88, 0x52, 0xfc, 0x4d, 0x37, 0x9e, 0xd2, 0x0f, 0x27, 0x85, 0xa8, 0x5a, 0x85, 0xcb,
-	0x42, 0x5a, 0xff, 0xe7, 0x3d, 0xf9, 0x13, 0x00, 0x00, 0xff, 0xff, 0x77, 0x13, 0xa4, 0xf3, 0xca,
-	0x07, 0x00, 0x00,
+	// 757 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x4f, 0x13, 0x4f,
+	0x18, 0xee, 0xf2, 0xfb, 0x59, 0xe9, 0x28, 0x9a, 0x0e, 0x7f, 0x82, 0x0d, 0xb6, 0x32, 0x1a, 0x83,
+	0x09, 0x76, 0x04, 0xaa, 0x07, 0x90, 0x08, 0xc5, 0x10, 0x13, 0x85, 0xc0, 0x4a, 0x3c, 0x10, 0x93,
+	0x66, 0xda, 0x9d, 0x96, 0x86, 0xee, 0x4e, 0x99, 0x9d, 0x25, 0x36, 0x84, 0x0b, 0x26, 0x9e, 0x4d,
+	0x3c, 0xfa, 0x1d, 0xfc, 0x0e, 0xde, 0x38, 0x78, 0x20, 0xe1, 0xe2, 0x69, 0x63, 0xc0, 0x4f, 0xd0,
+	0x83, 0x17, 0x2f, 0xa6, 0x33, 0xb3, 0x14, 0x68, 0xd9, 0x14, 0x48, 0xb8, 0x6d, 0xe7, 0x7d, 0xde,
+	0xe7, 0x7d, 0x9e, 0x79, 0xe7, 0x7d, 0x53, 0x30, 0xc2, 0x5c, 0x9b, 0xb9, 0x65, 0x17, 0x0b, 0xb6,
+	0x4e, 0x9d, 0x22, 0x29, 0x08, 0xc6, 0x6b, 0x78, 0x73, 0x2c, 0x4f, 0x05, 0x19, 0xc3, 0x1b, 0x1e,
+	0xe5, 0xb5, 0x74, 0x95, 0x33, 0xc1, 0xe0, 0x90, 0x46, 0xa6, 0x8f, 0x23, 0xd3, 0x1a, 0x99, 0xe8,
+	0x2b, 0xb1, 0x12, 0x93, 0x40, 0xdc, 0xf8, 0x52, 0x39, 0x89, 0xa1, 0x12, 0x63, 0xa5, 0x0a, 0xc5,
+	0xa4, 0x5a, 0xc6, 0xc4, 0x71, 0x98, 0x20, 0xa2, 0xcc, 0x1c, 0x57, 0x47, 0x87, 0xdb, 0xd6, 0xae,
+	0x12, 0x4e, 0xec, 0x00, 0x92, 0x09, 0x95, 0x47, 0x3c, 0xb1, 0xc6, 0x78, 0x59, 0xd4, 0x16, 0xa8,
+	0x20, 0x16, 0x11, 0x44, 0x65, 0xa1, 0x3e, 0x00, 0x97, 0x1b, 0xca, 0x97, 0x24, 0x95, 0x49, 0x37,
+	0x3c, 0xea, 0x0a, 0xb4, 0x0c, 0x7a, 0x4f, 0x9c, 0xba, 0x55, 0xe6, 0xb8, 0x14, 0x4e, 0x82, 0xa8,
+	0x2a, 0x39, 0x68, 0xdc, 0x33, 0x46, 0x6e, 0x8c, 0x0f, 0xa5, 0xdb, 0x1a, 0x55, 0x59, 0xd9, 0xff,
+	0x77, 0xfd, 0x54, 0xc4, 0xd4, 0x19, 0xe8, 0xa3, 0x01, 0x90, 0xe4, 0x7c, 0x49, 0x1d, 0x66, 0xcf,
+	0x9e, 0x96, 0xa3, 0x2b, 0xc3, 0x51, 0x70, 0xbd, 0xc0, 0x29, 0x11, 0x8c, 0xcb, 0x1a, 0xb1, 0x2c,
+	0xac, 0xfb, 0xa9, 0x5b, 0x35, 0x62, 0x57, 0x26, 0x91, 0x0e, 0x20, 0x33, 0x80, 0x40, 0x0c, 0xba,
+	0x5d, 0x2f, 0x6f, 0x35, 0x18, 0x07, 0xbb, 0x24, 0xbc, 0xb7, 0xee, 0xa7, 0x6e, 0x2b, 0x78, 0x10,
+	0x41, 0xe6, 0x11, 0x08, 0x7d, 0x33, 0xc0, 0xfd, 0x50, 0x15, 0xda, 0xe9, 0x27, 0x03, 0xc0, 0xa3,
+	0x2b, 0xcb, 0xd9, 0x3a, 0xac, 0x6d, 0x67, 0xd2, 0x61, 0xfd, 0x4d, 0xb7, 0xa7, 0xce, 0x0e, 0x37,
+	0xae, 0xa3, 0xee, 0xa7, 0xee, 0x28, 0x75, 0xad, 0xec, 0xc8, 0x8c, 0xb7, 0x74, 0x09, 0x2d, 0x80,
+	0xbb, 0x4d, 0xbd, 0xee, 0x3c, 0x67, 0xf6, 0x9c, 0xf2, 0x7e, 0xa1, 0x0b, 0x43, 0xaf, 0x41, 0xf2,
+	0x2c, 0x3a, 0xed, 0xfc, 0x11, 0x88, 0xca, 0xab, 0x6a, 0xf4, 0xf8, 0xbf, 0x91, 0x58, 0x36, 0x5e,
+	0xf7, 0x53, 0x3d, 0x8a, 0x4e, 0x9d, 0x23, 0x53, 0x03, 0xd0, 0x8e, 0x01, 0x86, 0x25, 0x5b, 0x96,
+	0x16, 0x19, 0xa7, 0x6f, 0xa9, 0x63, 0xbd, 0x62, 0x6c, 0x7d, 0xd6, 0xb2, 0x38, 0x75, 0xdd, 0x2b,
+	0xea, 0x68, 0x41, 0x3f, 0xab, 0x33, 0x34, 0x68, 0x57, 0xd3, 0xa0, 0xa7, 0xc0, 0x1c, 0xc1, 0x49,
+	0x41, 0xe4, 0x88, 0x65, 0x05, 0x52, 0x06, 0xeb, 0x7e, 0xaa, 0x4f, 0x4b, 0x39, 0x1e, 0x46, 0xe6,
+	0xcd, 0xe0, 0x77, 0x83, 0x09, 0x6d, 0x82, 0x7e, 0x59, 0x64, 0xde, 0xab, 0x54, 0xe4, 0xd5, 0x5d,
+	0x91, 0xb9, 0x45, 0x30, 0x70, 0xba, 0xae, 0x36, 0x94, 0x01, 0xa0, 0xe8, 0x55, 0x2a, 0x39, 0x45,
+	0xa6, 0x6a, 0xf7, 0xd7, 0xfd, 0x54, 0x5c, 0x91, 0x35, 0x63, 0xc8, 0x8c, 0x15, 0x83, 0xec, 0xf1,
+	0xef, 0xdd, 0xe0, 0x9a, 0x24, 0x84, 0x5f, 0x0d, 0x10, 0x55, 0x73, 0x0a, 0x9f, 0x84, 0x3f, 0xe7,
+	0xd6, 0xf5, 0x90, 0x18, 0x3b, 0x47, 0x86, 0xd2, 0x8b, 0x46, 0x77, 0xf6, 0x7f, 0x7f, 0xe9, 0x7a,
+	0x08, 0x1f, 0xe0, 0xd0, 0x35, 0xa5, 0x96, 0x05, 0xfc, 0x6b, 0x80, 0x81, 0xf6, 0x63, 0x04, 0x67,
+	0x3a, 0xa8, 0x1d, 0xba, 0x62, 0x12, 0xb3, 0x97, 0x60, 0xd0, 0x6e, 0xde, 0x4b, 0x37, 0xef, 0xe0,
+	0x4a, 0xb8, 0x1b, 0x35, 0x27, 0x38, 0x38, 0xde, 0xd2, 0xef, 0x60, 0x1b, 0x6f, 0x05, 0x1d, 0xde,
+	0xc6, 0xad, 0x7b, 0x00, 0xee, 0x1b, 0x20, 0xde, 0x32, 0xa0, 0x70, 0xaa, 0x53, 0xd9, 0x6d, 0xb6,
+	0x44, 0xe2, 0xf9, 0xc5, 0x92, 0xb5, 0xdd, 0x39, 0x69, 0x77, 0x1a, 0x4e, 0x75, 0x62, 0x37, 0x57,
+	0xe4, 0xcc, 0xce, 0x69, 0xab, 0x4d, 0xcf, 0xf0, 0x8f, 0x01, 0xfa, 0xdb, 0x0e, 0x29, 0x7c, 0xd1,
+	0x81, 0xb8, 0xb0, 0x15, 0x93, 0x98, 0xb9, 0x38, 0x81, 0x76, 0xb8, 0x2a, 0x1d, 0xae, 0x40, 0xf3,
+	0xf2, 0x0d, 0xcd, 0xcb, 0x42, 0x39, 0x97, 0x3a, 0x56, 0x6e, 0x8d, 0xb1, 0x75, 0xf8, 0xc3, 0x00,
+	0xb1, 0xa3, 0x01, 0x86, 0x13, 0x1d, 0x68, 0x3d, 0xbd, 0x66, 0x12, 0x99, 0xf3, 0x25, 0x69, 0x53,
+	0x2b, 0xd2, 0xd4, 0x22, 0x7c, 0x73, 0x79, 0x53, 0xcd, 0x7d, 0x92, 0x5d, 0xda, 0x3d, 0x48, 0x1a,
+	0x7b, 0x07, 0x49, 0xe3, 0xd7, 0x41, 0xd2, 0xf8, 0x7c, 0x98, 0x8c, 0xec, 0x1d, 0x26, 0x23, 0x3f,
+	0x0f, 0x93, 0x91, 0xd5, 0x67, 0xa5, 0xb2, 0x58, 0xf3, 0xf2, 0xe9, 0x02, 0xb3, 0xb1, 0x43, 0x3d,
+	0xc1, 0x99, 0xf3, 0x98, 0xf1, 0x52, 0xf0, 0x8d, 0x37, 0x9f, 0xe2, 0x0f, 0x27, 0x25, 0x88, 0x5a,
+	0x95, 0xba, 0xf9, 0xa8, 0xfc, 0x2b, 0x32, 0xf1, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x68, 0xcf, 0x46,
+	0xd0, 0x61, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -488,6 +597,9 @@ type QueryClient interface {
 	// BeforeSendHookAddress defines a gRPC query method for
 	// getting the address registered for the before send hook.
 	BeforeSendHookAddress(ctx context.Context, in *QueryBeforeSendHookAddressRequest, opts ...grpc.CallOption) (*QueryBeforeSendHookAddressResponse, error)
+	// FullDenom defines a gRPC query method for getting full denom name
+	// from the creator and subdenom strings.
+	FullDenom(ctx context.Context, in *QueryFullDenomRequest, opts ...grpc.CallOption) (*QueryFullDenomResponse, error)
 }
 
 type queryClient struct {
@@ -534,6 +646,15 @@ func (c *queryClient) BeforeSendHookAddress(ctx context.Context, in *QueryBefore
 	return out, nil
 }
 
+func (c *queryClient) FullDenom(ctx context.Context, in *QueryFullDenomRequest, opts ...grpc.CallOption) (*QueryFullDenomResponse, error) {
+	out := new(QueryFullDenomResponse)
+	err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Query/FullDenom", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// Params defines a gRPC query method that returns the tokenfactory module's
@@ -548,6 +669,9 @@ type QueryServer interface {
 	// BeforeSendHookAddress defines a gRPC query method for
 	// getting the address registered for the before send hook.
 	BeforeSendHookAddress(context.Context, *QueryBeforeSendHookAddressRequest) (*QueryBeforeSendHookAddressResponse, error)
+	// FullDenom defines a gRPC query method for getting full denom name
+	// from the creator and subdenom strings.
+	FullDenom(context.Context, *QueryFullDenomRequest) (*QueryFullDenomResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -566,6 +690,9 @@ func (*UnimplementedQueryServer) DenomsFromCreator(ctx context.Context, req *Que
 func (*UnimplementedQueryServer) BeforeSendHookAddress(ctx context.Context, req *QueryBeforeSendHookAddressRequest) (*QueryBeforeSendHookAddressResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method BeforeSendHookAddress not implemented")
 }
+func (*UnimplementedQueryServer) FullDenom(ctx context.Context, req *QueryFullDenomRequest) (*QueryFullDenomResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method FullDenom not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -643,6 +770,24 @@ func _Query_BeforeSendHookAddress_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_FullDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryFullDenomRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).FullDenom(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/osmosis.tokenfactory.v1beta1.Query/FullDenom",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).FullDenom(ctx, req.(*QueryFullDenomRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "osmosis.tokenfactory.v1beta1.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -663,6 +808,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "BeforeSendHookAddress",
 			Handler:    _Query_BeforeSendHookAddress_Handler,
 		},
+		{
+			MethodName: "FullDenom",
+			Handler:    _Query_FullDenom_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "osmosis/tokenfactory/v1beta1/query.proto",
@@ -923,6 +1072,73 @@ func (m *QueryBeforeSendHookAddressResponse) MarshalToSizedBuffer(dAtA []byte) (
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryFullDenomRequest) 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 *QueryFullDenomRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFullDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Subdenom) > 0 {
+		i -= len(m.Subdenom)
+		copy(dAtA[i:], m.Subdenom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Subdenom)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Creator) > 0 {
+		i -= len(m.Creator)
+		copy(dAtA[i:], m.Creator)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryFullDenomResponse) 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 *QueryFullDenomResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryFullDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.FullDenom) > 0 {
+		i -= len(m.FullDenom)
+		copy(dAtA[i:], m.FullDenom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.FullDenom)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQuery(v)
 	base := offset
@@ -1040,6 +1256,36 @@ func (m *QueryBeforeSendHookAddressResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryFullDenomRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Creator)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.Subdenom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryFullDenomResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.FullDenom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
 func sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1736,6 +1982,202 @@ func (m *QueryBeforeSendHookAddressResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryFullDenomRequest) 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: QueryFullDenomRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFullDenomRequest: 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 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.Creator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Subdenom", 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.Subdenom = 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 *QueryFullDenomResponse) 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: QueryFullDenomResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryFullDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FullDenom", 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.FullDenom = 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 skipQuery(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/tokenfactory/types/query.pb.gw.go b/x/tokenfactory/types/query.pb.gw.go
index 3da3e9e6d..ba0c18113 100644
--- a/x/tokenfactory/types/query.pb.gw.go
+++ b/x/tokenfactory/types/query.pb.gw.go
@@ -257,6 +257,82 @@ func local_request_Query_BeforeSendHookAddress_0(ctx context.Context, marshaler
 
 }
 
+func request_Query_FullDenom_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFullDenomRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["creator"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator")
+	}
+
+	protoReq.Creator, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err)
+	}
+
+	val, ok = pathParams["subdenom"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "subdenom")
+	}
+
+	protoReq.Subdenom, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "subdenom", err)
+	}
+
+	msg, err := client.FullDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_FullDenom_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryFullDenomRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["creator"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator")
+	}
+
+	protoReq.Creator, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err)
+	}
+
+	val, ok = pathParams["subdenom"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "subdenom")
+	}
+
+	protoReq.Subdenom, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "subdenom", err)
+	}
+
+	msg, err := server.FullDenom(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
 // UnaryRPC     :call QueryServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -355,6 +431,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_FullDenom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_FullDenom_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FullDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -476,6 +575,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_FullDenom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_FullDenom_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_FullDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -487,6 +606,8 @@ var (
 	pattern_Query_DenomsFromCreator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "tokenfactory", "v1beta1", "denoms_from_creator", "creator"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_BeforeSendHookAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"osmosis", "tokenfactory", "v1beta1", "denoms", "factory", "creator", "subdenom", "before_send_hook"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_FullDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"osmosis", "tokenfactory", "v1beta1", "denoms", "factory", "creator", "subdenom", "full_denom"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
@@ -497,4 +618,6 @@ var (
 	forward_Query_DenomsFromCreator_0 = runtime.ForwardResponseMessage
 
 	forward_Query_BeforeSendHookAddress_0 = runtime.ForwardResponseMessage
+
+	forward_Query_FullDenom_0 = runtime.ForwardResponseMessage
 )