@ritbit/v4-client-js 1.3.17

package/src/clients/lib/cctpProto.ts

@@ -0,0 +1,4197 @@
+/* eslint-disable */
+import Long from 'long';
+import _m0 from 'protobufjs/minimal';
+
+export const protobufPackage = 'circle.cctp.v1';
+
+/**
+ * Copyright (c) 2023, © Circle Internet Financial, LTD.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** TODO add comments */
+export interface MsgUpdateOwner {
+  from: string;
+  newOwner: string;
+}
+
+export interface MsgUpdateOwnerResponse {}
+
+export interface MsgUpdateAttesterManager {
+  from: string;
+  newAttesterManager: string;
+}
+
+export interface MsgUpdateAttesterManagerResponse {}
+
+export interface MsgUpdateTokenController {
+  from: string;
+  newTokenController: string;
+}
+
+export interface MsgUpdateTokenControllerResponse {}
+
+export interface MsgUpdatePauser {
+  from: string;
+  newPauser: string;
+}
+
+export interface MsgUpdatePauserResponse {}
+
+export interface MsgAcceptOwner {
+  from: string;
+}
+
+export interface MsgAcceptOwnerResponse {}
+
+export interface MsgEnableAttester {
+  from: string;
+  attester: string;
+}
+
+export interface MsgEnableAttesterResponse {}
+
+export interface MsgDisableAttester {
+  from: string;
+  attester: string;
+}
+
+export interface MsgDisableAttesterResponse {}
+
+export interface MsgPauseBurningAndMinting {
+  from: string;
+}
+
+export interface MsgPauseBurningAndMintingResponse {}
+
+export interface MsgUnpauseBurningAndMinting {
+  from: string;
+}
+
+export interface MsgUnpauseBurningAndMintingResponse {}
+
+export interface MsgPauseSendingAndReceivingMessages {
+  from: string;
+}
+
+export interface MsgPauseSendingAndReceivingMessagesResponse {}
+
+export interface MsgUnpauseSendingAndReceivingMessages {
+  from: string;
+}
+
+export interface MsgUnpauseSendingAndReceivingMessagesResponse {}
+
+export interface MsgUpdateMaxMessageBodySize {
+  from: string;
+  messageSize: Long;
+}
+
+export interface MsgUpdateMaxMessageBodySizeResponse {}
+
+export interface MsgSetMaxBurnAmountPerMessage {
+  from: string;
+  localToken: string;
+  amount: string;
+}
+
+export interface MsgSetMaxBurnAmountPerMessageResponse {}
+
+export interface MsgDepositForBurn {
+  from: string;
+  amount: string;
+  destinationDomain: number;
+  mintRecipient: Uint8Array;
+  burnToken: string;
+}
+
+export interface MsgDepositForBurnResponse {
+  nonce: Long;
+}
+
+export interface MsgDepositForBurnWithCaller {
+  from: string;
+  amount: string;
+  destinationDomain: number;
+  mintRecipient: Uint8Array;
+  burnToken: string;
+  destinationCaller: Uint8Array;
+}
+
+export interface MsgDepositForBurnWithCallerResponse {
+  nonce: Long;
+}
+
+export interface MsgReplaceDepositForBurn {
+  from: string;
+  originalMessage: Uint8Array;
+  originalAttestation: Uint8Array;
+  newDestinationCaller: Uint8Array;
+  newMintRecipient: Uint8Array;
+}
+
+export interface MsgReplaceDepositForBurnResponse {}
+
+export interface MsgReceiveMessage {
+  from: string;
+  message: Uint8Array;
+  attestation: Uint8Array;
+}
+
+export interface MsgReceiveMessageResponse {
+  success: boolean;
+}
+
+export interface MsgSendMessage {
+  from: string;
+  destinationDomain: number;
+  recipient: Uint8Array;
+  messageBody: Uint8Array;
+}
+
+export interface MsgSendMessageResponse {
+  nonce: Long;
+}
+
+export interface MsgSendMessageWithCaller {
+  from: string;
+  destinationDomain: number;
+  recipient: Uint8Array;
+  messageBody: Uint8Array;
+  destinationCaller: Uint8Array;
+}
+
+export interface MsgSendMessageWithCallerResponse {
+  nonce: Long;
+}
+
+export interface MsgReplaceMessage {
+  from: string;
+  originalMessage: Uint8Array;
+  originalAttestation: Uint8Array;
+  newMessageBody: Uint8Array;
+  newDestinationCaller: Uint8Array;
+}
+
+export interface MsgReplaceMessageResponse {}
+
+export interface MsgUpdateSignatureThreshold {
+  from: string;
+  amount: number;
+}
+
+export interface MsgUpdateSignatureThresholdResponse {}
+
+export interface MsgLinkTokenPair {
+  from: string;
+  remoteDomain: number;
+  remoteToken: Uint8Array;
+  localToken: string;
+}
+
+export interface MsgLinkTokenPairResponse {}
+
+export interface MsgUnlinkTokenPair {
+  from: string;
+  remoteDomain: number;
+  remoteToken: Uint8Array;
+  localToken: string;
+}
+
+export interface MsgUnlinkTokenPairResponse {}
+
+export interface MsgAddRemoteTokenMessenger {
+  from: string;
+  domainId: number;
+  address: Uint8Array;
+}
+
+export interface MsgAddRemoteTokenMessengerResponse {}
+
+export interface MsgRemoveRemoteTokenMessenger {
+  from: string;
+  domainId: number;
+}
+
+export interface MsgRemoveRemoteTokenMessengerResponse {}
+
+function createBaseMsgUpdateOwner(): MsgUpdateOwner {
+  return { from: '', newOwner: '' };
+}
+
+export const MsgUpdateOwner = {
+  encode(message: MsgUpdateOwner, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.newOwner !== '') {
+      writer.uint32(18).string(message.newOwner);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateOwner {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateOwner();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.newOwner = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateOwner {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      newOwner: isSet(object.newOwner) ? gt.String(object.newOwner) : '',
+    };
+  },
+
+  toJSON(message: MsgUpdateOwner): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.newOwner !== '') {
+      obj.newOwner = message.newOwner;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateOwner>, I>>(base?: I): MsgUpdateOwner {
+    return MsgUpdateOwner.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateOwner>, I>>(object: I): MsgUpdateOwner {
+    const message = createBaseMsgUpdateOwner();
+    message.from = object.from ?? '';
+    message.newOwner = object.newOwner ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUpdateOwnerResponse(): MsgUpdateOwnerResponse {
+  return {};
+}
+
+export const MsgUpdateOwnerResponse = {
+  encode(_: MsgUpdateOwnerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateOwnerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateOwnerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateOwnerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateOwnerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateOwnerResponse>, I>>(
+    base?: I,
+  ): MsgUpdateOwnerResponse {
+    return MsgUpdateOwnerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateOwnerResponse>, I>>(
+    _: I,
+  ): MsgUpdateOwnerResponse {
+    const message = createBaseMsgUpdateOwnerResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUpdateAttesterManager(): MsgUpdateAttesterManager {
+  return { from: '', newAttesterManager: '' };
+}
+
+export const MsgUpdateAttesterManager = {
+  encode(message: MsgUpdateAttesterManager, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.newAttesterManager !== '') {
+      writer.uint32(18).string(message.newAttesterManager);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateAttesterManager {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateAttesterManager();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.newAttesterManager = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateAttesterManager {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      newAttesterManager: isSet(object.newAttesterManager)
+        ? gt.String(object.newAttesterManager)
+        : '',
+    };
+  },
+
+  toJSON(message: MsgUpdateAttesterManager): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.newAttesterManager !== '') {
+      obj.newAttesterManager = message.newAttesterManager;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateAttesterManager>, I>>(
+    base?: I,
+  ): MsgUpdateAttesterManager {
+    return MsgUpdateAttesterManager.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateAttesterManager>, I>>(
+    object: I,
+  ): MsgUpdateAttesterManager {
+    const message = createBaseMsgUpdateAttesterManager();
+    message.from = object.from ?? '';
+    message.newAttesterManager = object.newAttesterManager ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUpdateAttesterManagerResponse(): MsgUpdateAttesterManagerResponse {
+  return {};
+}
+
+export const MsgUpdateAttesterManagerResponse = {
+  encode(
+    _: MsgUpdateAttesterManagerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateAttesterManagerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateAttesterManagerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateAttesterManagerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateAttesterManagerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateAttesterManagerResponse>, I>>(
+    base?: I,
+  ): MsgUpdateAttesterManagerResponse {
+    return MsgUpdateAttesterManagerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateAttesterManagerResponse>, I>>(
+    _: I,
+  ): MsgUpdateAttesterManagerResponse {
+    const message = createBaseMsgUpdateAttesterManagerResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUpdateTokenController(): MsgUpdateTokenController {
+  return { from: '', newTokenController: '' };
+}
+
+export const MsgUpdateTokenController = {
+  encode(message: MsgUpdateTokenController, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.newTokenController !== '') {
+      writer.uint32(18).string(message.newTokenController);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateTokenController {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateTokenController();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.newTokenController = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateTokenController {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      newTokenController: isSet(object.newTokenController)
+        ? gt.String(object.newTokenController)
+        : '',
+    };
+  },
+
+  toJSON(message: MsgUpdateTokenController): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.newTokenController !== '') {
+      obj.newTokenController = message.newTokenController;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateTokenController>, I>>(
+    base?: I,
+  ): MsgUpdateTokenController {
+    return MsgUpdateTokenController.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateTokenController>, I>>(
+    object: I,
+  ): MsgUpdateTokenController {
+    const message = createBaseMsgUpdateTokenController();
+    message.from = object.from ?? '';
+    message.newTokenController = object.newTokenController ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUpdateTokenControllerResponse(): MsgUpdateTokenControllerResponse {
+  return {};
+}
+
+export const MsgUpdateTokenControllerResponse = {
+  encode(
+    _: MsgUpdateTokenControllerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateTokenControllerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateTokenControllerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateTokenControllerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateTokenControllerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateTokenControllerResponse>, I>>(
+    base?: I,
+  ): MsgUpdateTokenControllerResponse {
+    return MsgUpdateTokenControllerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateTokenControllerResponse>, I>>(
+    _: I,
+  ): MsgUpdateTokenControllerResponse {
+    const message = createBaseMsgUpdateTokenControllerResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUpdatePauser(): MsgUpdatePauser {
+  return { from: '', newPauser: '' };
+}
+
+export const MsgUpdatePauser = {
+  encode(message: MsgUpdatePauser, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.newPauser !== '') {
+      writer.uint32(18).string(message.newPauser);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdatePauser {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdatePauser();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.newPauser = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdatePauser {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      newPauser: isSet(object.newPauser) ? gt.String(object.newPauser) : '',
+    };
+  },
+
+  toJSON(message: MsgUpdatePauser): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.newPauser !== '') {
+      obj.newPauser = message.newPauser;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdatePauser>, I>>(base?: I): MsgUpdatePauser {
+    return MsgUpdatePauser.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdatePauser>, I>>(object: I): MsgUpdatePauser {
+    const message = createBaseMsgUpdatePauser();
+    message.from = object.from ?? '';
+    message.newPauser = object.newPauser ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUpdatePauserResponse(): MsgUpdatePauserResponse {
+  return {};
+}
+
+export const MsgUpdatePauserResponse = {
+  encode(_: MsgUpdatePauserResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdatePauserResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdatePauserResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdatePauserResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdatePauserResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdatePauserResponse>, I>>(
+    base?: I,
+  ): MsgUpdatePauserResponse {
+    return MsgUpdatePauserResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdatePauserResponse>, I>>(
+    _: I,
+  ): MsgUpdatePauserResponse {
+    const message = createBaseMsgUpdatePauserResponse();
+    return message;
+  },
+};
+
+function createBaseMsgAcceptOwner(): MsgAcceptOwner {
+  return { from: '' };
+}
+
+export const MsgAcceptOwner = {
+  encode(message: MsgAcceptOwner, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAcceptOwner {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAcceptOwner();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgAcceptOwner {
+    return { from: isSet(object.from) ? gt.String(object.from) : '' };
+  },
+
+  toJSON(message: MsgAcceptOwner): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgAcceptOwner>, I>>(base?: I): MsgAcceptOwner {
+    return MsgAcceptOwner.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgAcceptOwner>, I>>(object: I): MsgAcceptOwner {
+    const message = createBaseMsgAcceptOwner();
+    message.from = object.from ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgAcceptOwnerResponse(): MsgAcceptOwnerResponse {
+  return {};
+}
+
+export const MsgAcceptOwnerResponse = {
+  encode(_: MsgAcceptOwnerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAcceptOwnerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAcceptOwnerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgAcceptOwnerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgAcceptOwnerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgAcceptOwnerResponse>, I>>(
+    base?: I,
+  ): MsgAcceptOwnerResponse {
+    return MsgAcceptOwnerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgAcceptOwnerResponse>, I>>(
+    _: I,
+  ): MsgAcceptOwnerResponse {
+    const message = createBaseMsgAcceptOwnerResponse();
+    return message;
+  },
+};
+
+function createBaseMsgEnableAttester(): MsgEnableAttester {
+  return { from: '', attester: '' };
+}
+
+export const MsgEnableAttester = {
+  encode(message: MsgEnableAttester, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.attester !== '') {
+      writer.uint32(18).string(message.attester);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgEnableAttester {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgEnableAttester();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.attester = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgEnableAttester {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      attester: isSet(object.attester) ? gt.String(object.attester) : '',
+    };
+  },
+
+  toJSON(message: MsgEnableAttester): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.attester !== '') {
+      obj.attester = message.attester;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgEnableAttester>, I>>(base?: I): MsgEnableAttester {
+    return MsgEnableAttester.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgEnableAttester>, I>>(object: I): MsgEnableAttester {
+    const message = createBaseMsgEnableAttester();
+    message.from = object.from ?? '';
+    message.attester = object.attester ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgEnableAttesterResponse(): MsgEnableAttesterResponse {
+  return {};
+}
+
+export const MsgEnableAttesterResponse = {
+  encode(_: MsgEnableAttesterResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgEnableAttesterResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgEnableAttesterResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgEnableAttesterResponse {
+    return {};
+  },
+
+  toJSON(_: MsgEnableAttesterResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgEnableAttesterResponse>, I>>(
+    base?: I,
+  ): MsgEnableAttesterResponse {
+    return MsgEnableAttesterResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgEnableAttesterResponse>, I>>(
+    _: I,
+  ): MsgEnableAttesterResponse {
+    const message = createBaseMsgEnableAttesterResponse();
+    return message;
+  },
+};
+
+function createBaseMsgDisableAttester(): MsgDisableAttester {
+  return { from: '', attester: '' };
+}
+
+export const MsgDisableAttester = {
+  encode(message: MsgDisableAttester, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.attester !== '') {
+      writer.uint32(18).string(message.attester);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDisableAttester {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDisableAttester();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.attester = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDisableAttester {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      attester: isSet(object.attester) ? gt.String(object.attester) : '',
+    };
+  },
+
+  toJSON(message: MsgDisableAttester): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.attester !== '') {
+      obj.attester = message.attester;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDisableAttester>, I>>(base?: I): MsgDisableAttester {
+    return MsgDisableAttester.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDisableAttester>, I>>(object: I): MsgDisableAttester {
+    const message = createBaseMsgDisableAttester();
+    message.from = object.from ?? '';
+    message.attester = object.attester ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgDisableAttesterResponse(): MsgDisableAttesterResponse {
+  return {};
+}
+
+export const MsgDisableAttesterResponse = {
+  encode(_: MsgDisableAttesterResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDisableAttesterResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDisableAttesterResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgDisableAttesterResponse {
+    return {};
+  },
+
+  toJSON(_: MsgDisableAttesterResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDisableAttesterResponse>, I>>(
+    base?: I,
+  ): MsgDisableAttesterResponse {
+    return MsgDisableAttesterResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDisableAttesterResponse>, I>>(
+    _: I,
+  ): MsgDisableAttesterResponse {
+    const message = createBaseMsgDisableAttesterResponse();
+    return message;
+  },
+};
+
+function createBaseMsgPauseBurningAndMinting(): MsgPauseBurningAndMinting {
+  return { from: '' };
+}
+
+export const MsgPauseBurningAndMinting = {
+  encode(message: MsgPauseBurningAndMinting, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgPauseBurningAndMinting {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgPauseBurningAndMinting();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgPauseBurningAndMinting {
+    return { from: isSet(object.from) ? gt.String(object.from) : '' };
+  },
+
+  toJSON(message: MsgPauseBurningAndMinting): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgPauseBurningAndMinting>, I>>(
+    base?: I,
+  ): MsgPauseBurningAndMinting {
+    return MsgPauseBurningAndMinting.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgPauseBurningAndMinting>, I>>(
+    object: I,
+  ): MsgPauseBurningAndMinting {
+    const message = createBaseMsgPauseBurningAndMinting();
+    message.from = object.from ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgPauseBurningAndMintingResponse(): MsgPauseBurningAndMintingResponse {
+  return {};
+}
+
+export const MsgPauseBurningAndMintingResponse = {
+  encode(
+    _: MsgPauseBurningAndMintingResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgPauseBurningAndMintingResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgPauseBurningAndMintingResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgPauseBurningAndMintingResponse {
+    return {};
+  },
+
+  toJSON(_: MsgPauseBurningAndMintingResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgPauseBurningAndMintingResponse>, I>>(
+    base?: I,
+  ): MsgPauseBurningAndMintingResponse {
+    return MsgPauseBurningAndMintingResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgPauseBurningAndMintingResponse>, I>>(
+    _: I,
+  ): MsgPauseBurningAndMintingResponse {
+    const message = createBaseMsgPauseBurningAndMintingResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUnpauseBurningAndMinting(): MsgUnpauseBurningAndMinting {
+  return { from: '' };
+}
+
+export const MsgUnpauseBurningAndMinting = {
+  encode(
+    message: MsgUnpauseBurningAndMinting,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUnpauseBurningAndMinting {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnpauseBurningAndMinting();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUnpauseBurningAndMinting {
+    return { from: isSet(object.from) ? gt.String(object.from) : '' };
+  },
+
+  toJSON(message: MsgUnpauseBurningAndMinting): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnpauseBurningAndMinting>, I>>(
+    base?: I,
+  ): MsgUnpauseBurningAndMinting {
+    return MsgUnpauseBurningAndMinting.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnpauseBurningAndMinting>, I>>(
+    object: I,
+  ): MsgUnpauseBurningAndMinting {
+    const message = createBaseMsgUnpauseBurningAndMinting();
+    message.from = object.from ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUnpauseBurningAndMintingResponse(): MsgUnpauseBurningAndMintingResponse {
+  return {};
+}
+
+export const MsgUnpauseBurningAndMintingResponse = {
+  encode(
+    _: MsgUnpauseBurningAndMintingResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUnpauseBurningAndMintingResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnpauseBurningAndMintingResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUnpauseBurningAndMintingResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUnpauseBurningAndMintingResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnpauseBurningAndMintingResponse>, I>>(
+    base?: I,
+  ): MsgUnpauseBurningAndMintingResponse {
+    return MsgUnpauseBurningAndMintingResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnpauseBurningAndMintingResponse>, I>>(
+    _: I,
+  ): MsgUnpauseBurningAndMintingResponse {
+    const message = createBaseMsgUnpauseBurningAndMintingResponse();
+    return message;
+  },
+};
+
+function createBaseMsgPauseSendingAndReceivingMessages(): MsgPauseSendingAndReceivingMessages {
+  return { from: '' };
+}
+
+export const MsgPauseSendingAndReceivingMessages = {
+  encode(
+    message: MsgPauseSendingAndReceivingMessages,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgPauseSendingAndReceivingMessages {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgPauseSendingAndReceivingMessages();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgPauseSendingAndReceivingMessages {
+    return { from: isSet(object.from) ? gt.String(object.from) : '' };
+  },
+
+  toJSON(message: MsgPauseSendingAndReceivingMessages): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgPauseSendingAndReceivingMessages>, I>>(
+    base?: I,
+  ): MsgPauseSendingAndReceivingMessages {
+    return MsgPauseSendingAndReceivingMessages.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgPauseSendingAndReceivingMessages>, I>>(
+    object: I,
+  ): MsgPauseSendingAndReceivingMessages {
+    const message = createBaseMsgPauseSendingAndReceivingMessages();
+    message.from = object.from ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgPauseSendingAndReceivingMessagesResponse(): MsgPauseSendingAndReceivingMessagesResponse {
+  return {};
+}
+
+export const MsgPauseSendingAndReceivingMessagesResponse = {
+  encode(
+    _: MsgPauseSendingAndReceivingMessagesResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number,
+  ): MsgPauseSendingAndReceivingMessagesResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgPauseSendingAndReceivingMessagesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgPauseSendingAndReceivingMessagesResponse {
+    return {};
+  },
+
+  toJSON(_: MsgPauseSendingAndReceivingMessagesResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgPauseSendingAndReceivingMessagesResponse>, I>>(
+    base?: I,
+  ): MsgPauseSendingAndReceivingMessagesResponse {
+    return MsgPauseSendingAndReceivingMessagesResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgPauseSendingAndReceivingMessagesResponse>, I>>(
+    _: I,
+  ): MsgPauseSendingAndReceivingMessagesResponse {
+    const message = createBaseMsgPauseSendingAndReceivingMessagesResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUnpauseSendingAndReceivingMessages(): MsgUnpauseSendingAndReceivingMessages {
+  return { from: '' };
+}
+
+export const MsgUnpauseSendingAndReceivingMessages = {
+  encode(
+    message: MsgUnpauseSendingAndReceivingMessages,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUnpauseSendingAndReceivingMessages {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnpauseSendingAndReceivingMessages();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUnpauseSendingAndReceivingMessages {
+    return { from: isSet(object.from) ? gt.String(object.from) : '' };
+  },
+
+  toJSON(message: MsgUnpauseSendingAndReceivingMessages): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnpauseSendingAndReceivingMessages>, I>>(
+    base?: I,
+  ): MsgUnpauseSendingAndReceivingMessages {
+    return MsgUnpauseSendingAndReceivingMessages.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnpauseSendingAndReceivingMessages>, I>>(
+    object: I,
+  ): MsgUnpauseSendingAndReceivingMessages {
+    const message = createBaseMsgUnpauseSendingAndReceivingMessages();
+    message.from = object.from ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUnpauseSendingAndReceivingMessagesResponse(): MsgUnpauseSendingAndReceivingMessagesResponse {
+  return {};
+}
+
+export const MsgUnpauseSendingAndReceivingMessagesResponse = {
+  encode(
+    _: MsgUnpauseSendingAndReceivingMessagesResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number,
+  ): MsgUnpauseSendingAndReceivingMessagesResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnpauseSendingAndReceivingMessagesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUnpauseSendingAndReceivingMessagesResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUnpauseSendingAndReceivingMessagesResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnpauseSendingAndReceivingMessagesResponse>, I>>(
+    base?: I,
+  ): MsgUnpauseSendingAndReceivingMessagesResponse {
+    return MsgUnpauseSendingAndReceivingMessagesResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnpauseSendingAndReceivingMessagesResponse>, I>>(
+    _: I,
+  ): MsgUnpauseSendingAndReceivingMessagesResponse {
+    const message = createBaseMsgUnpauseSendingAndReceivingMessagesResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUpdateMaxMessageBodySize(): MsgUpdateMaxMessageBodySize {
+  return { from: '', messageSize: Long.UZERO };
+}
+
+export const MsgUpdateMaxMessageBodySize = {
+  encode(
+    message: MsgUpdateMaxMessageBodySize,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (!message.messageSize.isZero()) {
+      writer.uint32(16).uint64(message.messageSize);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMaxMessageBodySize {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMaxMessageBodySize();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.messageSize = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateMaxMessageBodySize {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      messageSize: isSet(object.messageSize) ? Long.fromValue(object.messageSize) : Long.UZERO,
+    };
+  },
+
+  toJSON(message: MsgUpdateMaxMessageBodySize): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (!message.messageSize.isZero()) {
+      obj.messageSize = (message.messageSize || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateMaxMessageBodySize>, I>>(
+    base?: I,
+  ): MsgUpdateMaxMessageBodySize {
+    return MsgUpdateMaxMessageBodySize.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateMaxMessageBodySize>, I>>(
+    object: I,
+  ): MsgUpdateMaxMessageBodySize {
+    const message = createBaseMsgUpdateMaxMessageBodySize();
+    message.from = object.from ?? '';
+    message.messageSize =
+      object.messageSize !== undefined && object.messageSize !== null
+        ? Long.fromValue(object.messageSize)
+        : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseMsgUpdateMaxMessageBodySizeResponse(): MsgUpdateMaxMessageBodySizeResponse {
+  return {};
+}
+
+export const MsgUpdateMaxMessageBodySizeResponse = {
+  encode(
+    _: MsgUpdateMaxMessageBodySizeResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateMaxMessageBodySizeResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateMaxMessageBodySizeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateMaxMessageBodySizeResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateMaxMessageBodySizeResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateMaxMessageBodySizeResponse>, I>>(
+    base?: I,
+  ): MsgUpdateMaxMessageBodySizeResponse {
+    return MsgUpdateMaxMessageBodySizeResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateMaxMessageBodySizeResponse>, I>>(
+    _: I,
+  ): MsgUpdateMaxMessageBodySizeResponse {
+    const message = createBaseMsgUpdateMaxMessageBodySizeResponse();
+    return message;
+  },
+};
+
+function createBaseMsgSetMaxBurnAmountPerMessage(): MsgSetMaxBurnAmountPerMessage {
+  return { from: '', localToken: '', amount: '' };
+}
+
+export const MsgSetMaxBurnAmountPerMessage = {
+  encode(
+    message: MsgSetMaxBurnAmountPerMessage,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.localToken !== '') {
+      writer.uint32(18).string(message.localToken);
+    }
+    if (message.amount !== '') {
+      writer.uint32(26).string(message.amount);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetMaxBurnAmountPerMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetMaxBurnAmountPerMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.localToken = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.amount = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSetMaxBurnAmountPerMessage {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      localToken: isSet(object.localToken) ? gt.String(object.localToken) : '',
+      amount: isSet(object.amount) ? gt.String(object.amount) : '',
+    };
+  },
+
+  toJSON(message: MsgSetMaxBurnAmountPerMessage): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.localToken !== '') {
+      obj.localToken = message.localToken;
+    }
+    if (message.amount !== '') {
+      obj.amount = message.amount;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSetMaxBurnAmountPerMessage>, I>>(
+    base?: I,
+  ): MsgSetMaxBurnAmountPerMessage {
+    return MsgSetMaxBurnAmountPerMessage.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSetMaxBurnAmountPerMessage>, I>>(
+    object: I,
+  ): MsgSetMaxBurnAmountPerMessage {
+    const message = createBaseMsgSetMaxBurnAmountPerMessage();
+    message.from = object.from ?? '';
+    message.localToken = object.localToken ?? '';
+    message.amount = object.amount ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgSetMaxBurnAmountPerMessageResponse(): MsgSetMaxBurnAmountPerMessageResponse {
+  return {};
+}
+
+export const MsgSetMaxBurnAmountPerMessageResponse = {
+  encode(
+    _: MsgSetMaxBurnAmountPerMessageResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetMaxBurnAmountPerMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetMaxBurnAmountPerMessageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgSetMaxBurnAmountPerMessageResponse {
+    return {};
+  },
+
+  toJSON(_: MsgSetMaxBurnAmountPerMessageResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSetMaxBurnAmountPerMessageResponse>, I>>(
+    base?: I,
+  ): MsgSetMaxBurnAmountPerMessageResponse {
+    return MsgSetMaxBurnAmountPerMessageResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSetMaxBurnAmountPerMessageResponse>, I>>(
+    _: I,
+  ): MsgSetMaxBurnAmountPerMessageResponse {
+    const message = createBaseMsgSetMaxBurnAmountPerMessageResponse();
+    return message;
+  },
+};
+
+function createBaseMsgDepositForBurn(): MsgDepositForBurn {
+  return {
+    from: '',
+    amount: '',
+    destinationDomain: 0,
+    mintRecipient: new Uint8Array(0),
+    burnToken: '',
+  };
+}
+
+export const MsgDepositForBurn = {
+  encode(message: MsgDepositForBurn, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.amount !== '') {
+      writer.uint32(18).string(message.amount);
+    }
+    if (message.destinationDomain !== 0) {
+      writer.uint32(24).uint32(message.destinationDomain);
+    }
+    if (message.mintRecipient.length !== 0) {
+      writer.uint32(34).bytes(message.mintRecipient);
+    }
+    if (message.burnToken !== '') {
+      writer.uint32(42).string(message.burnToken);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDepositForBurn {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositForBurn();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.amount = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.destinationDomain = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.mintRecipient = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.burnToken = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDepositForBurn {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      amount: isSet(object.amount) ? gt.String(object.amount) : '',
+      destinationDomain: isSet(object.destinationDomain) ? gt.Number(object.destinationDomain) : 0,
+      mintRecipient: isSet(object.mintRecipient)
+        ? bytesFromBase64(object.mintRecipient)
+        : new Uint8Array(0),
+      burnToken: isSet(object.burnToken) ? gt.String(object.burnToken) : '',
+    };
+  },
+
+  toJSON(message: MsgDepositForBurn): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.amount !== '') {
+      obj.amount = message.amount;
+    }
+    if (message.destinationDomain !== 0) {
+      obj.destinationDomain = Math.round(message.destinationDomain);
+    }
+    if (message.mintRecipient.length !== 0) {
+      obj.mintRecipient = base64FromBytes(message.mintRecipient);
+    }
+    if (message.burnToken !== '') {
+      obj.burnToken = message.burnToken;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDepositForBurn>, I>>(base?: I): MsgDepositForBurn {
+    return MsgDepositForBurn.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDepositForBurn>, I>>(object: I): MsgDepositForBurn {
+    const message = createBaseMsgDepositForBurn();
+    message.from = object.from ?? '';
+    message.amount = object.amount ?? '';
+    message.destinationDomain = object.destinationDomain ?? 0;
+    message.mintRecipient = object.mintRecipient ?? new Uint8Array(0);
+    message.burnToken = object.burnToken ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgDepositForBurnResponse(): MsgDepositForBurnResponse {
+  return { nonce: Long.UZERO };
+}
+
+export const MsgDepositForBurnResponse = {
+  encode(message: MsgDepositForBurnResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.nonce.isZero()) {
+      writer.uint32(8).uint64(message.nonce);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDepositForBurnResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositForBurnResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.nonce = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDepositForBurnResponse {
+    return { nonce: isSet(object.nonce) ? Long.fromValue(object.nonce) : Long.UZERO };
+  },
+
+  toJSON(message: MsgDepositForBurnResponse): unknown {
+    const obj: any = {};
+    if (!message.nonce.isZero()) {
+      obj.nonce = (message.nonce || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDepositForBurnResponse>, I>>(
+    base?: I,
+  ): MsgDepositForBurnResponse {
+    return MsgDepositForBurnResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDepositForBurnResponse>, I>>(
+    object: I,
+  ): MsgDepositForBurnResponse {
+    const message = createBaseMsgDepositForBurnResponse();
+    message.nonce =
+      object.nonce !== undefined && object.nonce !== null
+        ? Long.fromValue(object.nonce)
+        : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseMsgDepositForBurnWithCaller(): MsgDepositForBurnWithCaller {
+  return {
+    from: '',
+    amount: '',
+    destinationDomain: 0,
+    mintRecipient: new Uint8Array(0),
+    burnToken: '',
+    destinationCaller: new Uint8Array(0),
+  };
+}
+
+export const MsgDepositForBurnWithCaller = {
+  encode(
+    message: MsgDepositForBurnWithCaller,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.amount !== '') {
+      writer.uint32(18).string(message.amount);
+    }
+    if (message.destinationDomain !== 0) {
+      writer.uint32(24).uint32(message.destinationDomain);
+    }
+    if (message.mintRecipient.length !== 0) {
+      writer.uint32(34).bytes(message.mintRecipient);
+    }
+    if (message.burnToken !== '') {
+      writer.uint32(42).string(message.burnToken);
+    }
+    if (message.destinationCaller.length !== 0) {
+      writer.uint32(50).bytes(message.destinationCaller);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDepositForBurnWithCaller {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositForBurnWithCaller();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.amount = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.destinationDomain = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.mintRecipient = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.burnToken = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.destinationCaller = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDepositForBurnWithCaller {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      amount: isSet(object.amount) ? gt.String(object.amount) : '',
+      destinationDomain: isSet(object.destinationDomain) ? gt.Number(object.destinationDomain) : 0,
+      mintRecipient: isSet(object.mintRecipient)
+        ? bytesFromBase64(object.mintRecipient)
+        : new Uint8Array(0),
+      burnToken: isSet(object.burnToken) ? gt.String(object.burnToken) : '',
+      destinationCaller: isSet(object.destinationCaller)
+        ? bytesFromBase64(object.destinationCaller)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgDepositForBurnWithCaller): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.amount !== '') {
+      obj.amount = message.amount;
+    }
+    if (message.destinationDomain !== 0) {
+      obj.destinationDomain = Math.round(message.destinationDomain);
+    }
+    if (message.mintRecipient.length !== 0) {
+      obj.mintRecipient = base64FromBytes(message.mintRecipient);
+    }
+    if (message.burnToken !== '') {
+      obj.burnToken = message.burnToken;
+    }
+    if (message.destinationCaller.length !== 0) {
+      obj.destinationCaller = base64FromBytes(message.destinationCaller);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDepositForBurnWithCaller>, I>>(
+    base?: I,
+  ): MsgDepositForBurnWithCaller {
+    return MsgDepositForBurnWithCaller.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDepositForBurnWithCaller>, I>>(
+    object: I,
+  ): MsgDepositForBurnWithCaller {
+    const message = createBaseMsgDepositForBurnWithCaller();
+    message.from = object.from ?? '';
+    message.amount = object.amount ?? '';
+    message.destinationDomain = object.destinationDomain ?? 0;
+    message.mintRecipient = object.mintRecipient ?? new Uint8Array(0);
+    message.burnToken = object.burnToken ?? '';
+    message.destinationCaller = object.destinationCaller ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgDepositForBurnWithCallerResponse(): MsgDepositForBurnWithCallerResponse {
+  return { nonce: Long.UZERO };
+}
+
+export const MsgDepositForBurnWithCallerResponse = {
+  encode(
+    message: MsgDepositForBurnWithCallerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (!message.nonce.isZero()) {
+      writer.uint32(8).uint64(message.nonce);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDepositForBurnWithCallerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositForBurnWithCallerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.nonce = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDepositForBurnWithCallerResponse {
+    return { nonce: isSet(object.nonce) ? Long.fromValue(object.nonce) : Long.UZERO };
+  },
+
+  toJSON(message: MsgDepositForBurnWithCallerResponse): unknown {
+    const obj: any = {};
+    if (!message.nonce.isZero()) {
+      obj.nonce = (message.nonce || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgDepositForBurnWithCallerResponse>, I>>(
+    base?: I,
+  ): MsgDepositForBurnWithCallerResponse {
+    return MsgDepositForBurnWithCallerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgDepositForBurnWithCallerResponse>, I>>(
+    object: I,
+  ): MsgDepositForBurnWithCallerResponse {
+    const message = createBaseMsgDepositForBurnWithCallerResponse();
+    message.nonce =
+      object.nonce !== undefined && object.nonce !== null
+        ? Long.fromValue(object.nonce)
+        : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseMsgReplaceDepositForBurn(): MsgReplaceDepositForBurn {
+  return {
+    from: '',
+    originalMessage: new Uint8Array(0),
+    originalAttestation: new Uint8Array(0),
+    newDestinationCaller: new Uint8Array(0),
+    newMintRecipient: new Uint8Array(0),
+  };
+}
+
+export const MsgReplaceDepositForBurn = {
+  encode(message: MsgReplaceDepositForBurn, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.originalMessage.length !== 0) {
+      writer.uint32(18).bytes(message.originalMessage);
+    }
+    if (message.originalAttestation.length !== 0) {
+      writer.uint32(26).bytes(message.originalAttestation);
+    }
+    if (message.newDestinationCaller.length !== 0) {
+      writer.uint32(34).bytes(message.newDestinationCaller);
+    }
+    if (message.newMintRecipient.length !== 0) {
+      writer.uint32(42).bytes(message.newMintRecipient);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReplaceDepositForBurn {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReplaceDepositForBurn();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.originalMessage = reader.bytes();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.originalAttestation = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.newDestinationCaller = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.newMintRecipient = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgReplaceDepositForBurn {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      originalMessage: isSet(object.originalMessage)
+        ? bytesFromBase64(object.originalMessage)
+        : new Uint8Array(0),
+      originalAttestation: isSet(object.originalAttestation)
+        ? bytesFromBase64(object.originalAttestation)
+        : new Uint8Array(0),
+      newDestinationCaller: isSet(object.newDestinationCaller)
+        ? bytesFromBase64(object.newDestinationCaller)
+        : new Uint8Array(0),
+      newMintRecipient: isSet(object.newMintRecipient)
+        ? bytesFromBase64(object.newMintRecipient)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgReplaceDepositForBurn): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.originalMessage.length !== 0) {
+      obj.originalMessage = base64FromBytes(message.originalMessage);
+    }
+    if (message.originalAttestation.length !== 0) {
+      obj.originalAttestation = base64FromBytes(message.originalAttestation);
+    }
+    if (message.newDestinationCaller.length !== 0) {
+      obj.newDestinationCaller = base64FromBytes(message.newDestinationCaller);
+    }
+    if (message.newMintRecipient.length !== 0) {
+      obj.newMintRecipient = base64FromBytes(message.newMintRecipient);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReplaceDepositForBurn>, I>>(
+    base?: I,
+  ): MsgReplaceDepositForBurn {
+    return MsgReplaceDepositForBurn.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReplaceDepositForBurn>, I>>(
+    object: I,
+  ): MsgReplaceDepositForBurn {
+    const message = createBaseMsgReplaceDepositForBurn();
+    message.from = object.from ?? '';
+    message.originalMessage = object.originalMessage ?? new Uint8Array(0);
+    message.originalAttestation = object.originalAttestation ?? new Uint8Array(0);
+    message.newDestinationCaller = object.newDestinationCaller ?? new Uint8Array(0);
+    message.newMintRecipient = object.newMintRecipient ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgReplaceDepositForBurnResponse(): MsgReplaceDepositForBurnResponse {
+  return {};
+}
+
+export const MsgReplaceDepositForBurnResponse = {
+  encode(
+    _: MsgReplaceDepositForBurnResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReplaceDepositForBurnResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReplaceDepositForBurnResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgReplaceDepositForBurnResponse {
+    return {};
+  },
+
+  toJSON(_: MsgReplaceDepositForBurnResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReplaceDepositForBurnResponse>, I>>(
+    base?: I,
+  ): MsgReplaceDepositForBurnResponse {
+    return MsgReplaceDepositForBurnResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReplaceDepositForBurnResponse>, I>>(
+    _: I,
+  ): MsgReplaceDepositForBurnResponse {
+    const message = createBaseMsgReplaceDepositForBurnResponse();
+    return message;
+  },
+};
+
+function createBaseMsgReceiveMessage(): MsgReceiveMessage {
+  return { from: '', message: new Uint8Array(0), attestation: new Uint8Array(0) };
+}
+
+export const MsgReceiveMessage = {
+  encode(message: MsgReceiveMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.message.length !== 0) {
+      writer.uint32(18).bytes(message.message);
+    }
+    if (message.attestation.length !== 0) {
+      writer.uint32(26).bytes(message.attestation);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReceiveMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReceiveMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = reader.bytes();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.attestation = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgReceiveMessage {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      message: isSet(object.message) ? bytesFromBase64(object.message) : new Uint8Array(0),
+      attestation: isSet(object.attestation)
+        ? bytesFromBase64(object.attestation)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgReceiveMessage): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.message.length !== 0) {
+      obj.message = base64FromBytes(message.message);
+    }
+    if (message.attestation.length !== 0) {
+      obj.attestation = base64FromBytes(message.attestation);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReceiveMessage>, I>>(base?: I): MsgReceiveMessage {
+    return MsgReceiveMessage.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReceiveMessage>, I>>(object: I): MsgReceiveMessage {
+    const message = createBaseMsgReceiveMessage();
+    message.from = object.from ?? '';
+    message.message = object.message ?? new Uint8Array(0);
+    message.attestation = object.attestation ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgReceiveMessageResponse(): MsgReceiveMessageResponse {
+  return { success: false };
+}
+
+export const MsgReceiveMessageResponse = {
+  encode(message: MsgReceiveMessageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReceiveMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReceiveMessageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgReceiveMessageResponse {
+    return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
+  },
+
+  toJSON(message: MsgReceiveMessageResponse): unknown {
+    const obj: any = {};
+    if (message.success === true) {
+      obj.success = message.success;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReceiveMessageResponse>, I>>(
+    base?: I,
+  ): MsgReceiveMessageResponse {
+    return MsgReceiveMessageResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReceiveMessageResponse>, I>>(
+    object: I,
+  ): MsgReceiveMessageResponse {
+    const message = createBaseMsgReceiveMessageResponse();
+    message.success = object.success ?? false;
+    return message;
+  },
+};
+
+function createBaseMsgSendMessage(): MsgSendMessage {
+  return {
+    from: '',
+    destinationDomain: 0,
+    recipient: new Uint8Array(0),
+    messageBody: new Uint8Array(0),
+  };
+}
+
+export const MsgSendMessage = {
+  encode(message: MsgSendMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.destinationDomain !== 0) {
+      writer.uint32(16).uint32(message.destinationDomain);
+    }
+    if (message.recipient.length !== 0) {
+      writer.uint32(26).bytes(message.recipient);
+    }
+    if (message.messageBody.length !== 0) {
+      writer.uint32(34).bytes(message.messageBody);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.destinationDomain = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.recipient = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.messageBody = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendMessage {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      destinationDomain: isSet(object.destinationDomain) ? gt.Number(object.destinationDomain) : 0,
+      recipient: isSet(object.recipient) ? bytesFromBase64(object.recipient) : new Uint8Array(0),
+      messageBody: isSet(object.messageBody)
+        ? bytesFromBase64(object.messageBody)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgSendMessage): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.destinationDomain !== 0) {
+      obj.destinationDomain = Math.round(message.destinationDomain);
+    }
+    if (message.recipient.length !== 0) {
+      obj.recipient = base64FromBytes(message.recipient);
+    }
+    if (message.messageBody.length !== 0) {
+      obj.messageBody = base64FromBytes(message.messageBody);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSendMessage>, I>>(base?: I): MsgSendMessage {
+    return MsgSendMessage.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSendMessage>, I>>(object: I): MsgSendMessage {
+    const message = createBaseMsgSendMessage();
+    message.from = object.from ?? '';
+    message.destinationDomain = object.destinationDomain ?? 0;
+    message.recipient = object.recipient ?? new Uint8Array(0);
+    message.messageBody = object.messageBody ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgSendMessageResponse(): MsgSendMessageResponse {
+  return { nonce: Long.UZERO };
+}
+
+export const MsgSendMessageResponse = {
+  encode(message: MsgSendMessageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.nonce.isZero()) {
+      writer.uint32(8).uint64(message.nonce);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendMessageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.nonce = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendMessageResponse {
+    return { nonce: isSet(object.nonce) ? Long.fromValue(object.nonce) : Long.UZERO };
+  },
+
+  toJSON(message: MsgSendMessageResponse): unknown {
+    const obj: any = {};
+    if (!message.nonce.isZero()) {
+      obj.nonce = (message.nonce || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSendMessageResponse>, I>>(
+    base?: I,
+  ): MsgSendMessageResponse {
+    return MsgSendMessageResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSendMessageResponse>, I>>(
+    object: I,
+  ): MsgSendMessageResponse {
+    const message = createBaseMsgSendMessageResponse();
+    message.nonce =
+      object.nonce !== undefined && object.nonce !== null
+        ? Long.fromValue(object.nonce)
+        : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseMsgSendMessageWithCaller(): MsgSendMessageWithCaller {
+  return {
+    from: '',
+    destinationDomain: 0,
+    recipient: new Uint8Array(0),
+    messageBody: new Uint8Array(0),
+    destinationCaller: new Uint8Array(0),
+  };
+}
+
+export const MsgSendMessageWithCaller = {
+  encode(message: MsgSendMessageWithCaller, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.destinationDomain !== 0) {
+      writer.uint32(16).uint32(message.destinationDomain);
+    }
+    if (message.recipient.length !== 0) {
+      writer.uint32(26).bytes(message.recipient);
+    }
+    if (message.messageBody.length !== 0) {
+      writer.uint32(34).bytes(message.messageBody);
+    }
+    if (message.destinationCaller.length !== 0) {
+      writer.uint32(42).bytes(message.destinationCaller);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendMessageWithCaller {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendMessageWithCaller();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.destinationDomain = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.recipient = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.messageBody = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.destinationCaller = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendMessageWithCaller {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      destinationDomain: isSet(object.destinationDomain) ? gt.Number(object.destinationDomain) : 0,
+      recipient: isSet(object.recipient) ? bytesFromBase64(object.recipient) : new Uint8Array(0),
+      messageBody: isSet(object.messageBody)
+        ? bytesFromBase64(object.messageBody)
+        : new Uint8Array(0),
+      destinationCaller: isSet(object.destinationCaller)
+        ? bytesFromBase64(object.destinationCaller)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgSendMessageWithCaller): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.destinationDomain !== 0) {
+      obj.destinationDomain = Math.round(message.destinationDomain);
+    }
+    if (message.recipient.length !== 0) {
+      obj.recipient = base64FromBytes(message.recipient);
+    }
+    if (message.messageBody.length !== 0) {
+      obj.messageBody = base64FromBytes(message.messageBody);
+    }
+    if (message.destinationCaller.length !== 0) {
+      obj.destinationCaller = base64FromBytes(message.destinationCaller);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSendMessageWithCaller>, I>>(
+    base?: I,
+  ): MsgSendMessageWithCaller {
+    return MsgSendMessageWithCaller.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSendMessageWithCaller>, I>>(
+    object: I,
+  ): MsgSendMessageWithCaller {
+    const message = createBaseMsgSendMessageWithCaller();
+    message.from = object.from ?? '';
+    message.destinationDomain = object.destinationDomain ?? 0;
+    message.recipient = object.recipient ?? new Uint8Array(0);
+    message.messageBody = object.messageBody ?? new Uint8Array(0);
+    message.destinationCaller = object.destinationCaller ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgSendMessageWithCallerResponse(): MsgSendMessageWithCallerResponse {
+  return { nonce: Long.UZERO };
+}
+
+export const MsgSendMessageWithCallerResponse = {
+  encode(
+    message: MsgSendMessageWithCallerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (!message.nonce.isZero()) {
+      writer.uint32(8).uint64(message.nonce);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendMessageWithCallerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendMessageWithCallerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.nonce = reader.uint64() as Long;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendMessageWithCallerResponse {
+    return { nonce: isSet(object.nonce) ? Long.fromValue(object.nonce) : Long.UZERO };
+  },
+
+  toJSON(message: MsgSendMessageWithCallerResponse): unknown {
+    const obj: any = {};
+    if (!message.nonce.isZero()) {
+      obj.nonce = (message.nonce || Long.UZERO).toString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgSendMessageWithCallerResponse>, I>>(
+    base?: I,
+  ): MsgSendMessageWithCallerResponse {
+    return MsgSendMessageWithCallerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgSendMessageWithCallerResponse>, I>>(
+    object: I,
+  ): MsgSendMessageWithCallerResponse {
+    const message = createBaseMsgSendMessageWithCallerResponse();
+    message.nonce =
+      object.nonce !== undefined && object.nonce !== null
+        ? Long.fromValue(object.nonce)
+        : Long.UZERO;
+    return message;
+  },
+};
+
+function createBaseMsgReplaceMessage(): MsgReplaceMessage {
+  return {
+    from: '',
+    originalMessage: new Uint8Array(0),
+    originalAttestation: new Uint8Array(0),
+    newMessageBody: new Uint8Array(0),
+    newDestinationCaller: new Uint8Array(0),
+  };
+}
+
+export const MsgReplaceMessage = {
+  encode(message: MsgReplaceMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.originalMessage.length !== 0) {
+      writer.uint32(18).bytes(message.originalMessage);
+    }
+    if (message.originalAttestation.length !== 0) {
+      writer.uint32(26).bytes(message.originalAttestation);
+    }
+    if (message.newMessageBody.length !== 0) {
+      writer.uint32(34).bytes(message.newMessageBody);
+    }
+    if (message.newDestinationCaller.length !== 0) {
+      writer.uint32(42).bytes(message.newDestinationCaller);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReplaceMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReplaceMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.originalMessage = reader.bytes();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.originalAttestation = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.newMessageBody = reader.bytes();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.newDestinationCaller = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgReplaceMessage {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      originalMessage: isSet(object.originalMessage)
+        ? bytesFromBase64(object.originalMessage)
+        : new Uint8Array(0),
+      originalAttestation: isSet(object.originalAttestation)
+        ? bytesFromBase64(object.originalAttestation)
+        : new Uint8Array(0),
+      newMessageBody: isSet(object.newMessageBody)
+        ? bytesFromBase64(object.newMessageBody)
+        : new Uint8Array(0),
+      newDestinationCaller: isSet(object.newDestinationCaller)
+        ? bytesFromBase64(object.newDestinationCaller)
+        : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgReplaceMessage): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.originalMessage.length !== 0) {
+      obj.originalMessage = base64FromBytes(message.originalMessage);
+    }
+    if (message.originalAttestation.length !== 0) {
+      obj.originalAttestation = base64FromBytes(message.originalAttestation);
+    }
+    if (message.newMessageBody.length !== 0) {
+      obj.newMessageBody = base64FromBytes(message.newMessageBody);
+    }
+    if (message.newDestinationCaller.length !== 0) {
+      obj.newDestinationCaller = base64FromBytes(message.newDestinationCaller);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReplaceMessage>, I>>(base?: I): MsgReplaceMessage {
+    return MsgReplaceMessage.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReplaceMessage>, I>>(object: I): MsgReplaceMessage {
+    const message = createBaseMsgReplaceMessage();
+    message.from = object.from ?? '';
+    message.originalMessage = object.originalMessage ?? new Uint8Array(0);
+    message.originalAttestation = object.originalAttestation ?? new Uint8Array(0);
+    message.newMessageBody = object.newMessageBody ?? new Uint8Array(0);
+    message.newDestinationCaller = object.newDestinationCaller ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgReplaceMessageResponse(): MsgReplaceMessageResponse {
+  return {};
+}
+
+export const MsgReplaceMessageResponse = {
+  encode(_: MsgReplaceMessageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgReplaceMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgReplaceMessageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgReplaceMessageResponse {
+    return {};
+  },
+
+  toJSON(_: MsgReplaceMessageResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgReplaceMessageResponse>, I>>(
+    base?: I,
+  ): MsgReplaceMessageResponse {
+    return MsgReplaceMessageResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgReplaceMessageResponse>, I>>(
+    _: I,
+  ): MsgReplaceMessageResponse {
+    const message = createBaseMsgReplaceMessageResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUpdateSignatureThreshold(): MsgUpdateSignatureThreshold {
+  return { from: '', amount: 0 };
+}
+
+export const MsgUpdateSignatureThreshold = {
+  encode(
+    message: MsgUpdateSignatureThreshold,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.amount !== 0) {
+      writer.uint32(16).uint32(message.amount);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateSignatureThreshold {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateSignatureThreshold();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.amount = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUpdateSignatureThreshold {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      amount: isSet(object.amount) ? gt.Number(object.amount) : 0,
+    };
+  },
+
+  toJSON(message: MsgUpdateSignatureThreshold): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.amount !== 0) {
+      obj.amount = Math.round(message.amount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateSignatureThreshold>, I>>(
+    base?: I,
+  ): MsgUpdateSignatureThreshold {
+    return MsgUpdateSignatureThreshold.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateSignatureThreshold>, I>>(
+    object: I,
+  ): MsgUpdateSignatureThreshold {
+    const message = createBaseMsgUpdateSignatureThreshold();
+    message.from = object.from ?? '';
+    message.amount = object.amount ?? 0;
+    return message;
+  },
+};
+
+function createBaseMsgUpdateSignatureThresholdResponse(): MsgUpdateSignatureThresholdResponse {
+  return {};
+}
+
+export const MsgUpdateSignatureThresholdResponse = {
+  encode(
+    _: MsgUpdateSignatureThresholdResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateSignatureThresholdResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateSignatureThresholdResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUpdateSignatureThresholdResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUpdateSignatureThresholdResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUpdateSignatureThresholdResponse>, I>>(
+    base?: I,
+  ): MsgUpdateSignatureThresholdResponse {
+    return MsgUpdateSignatureThresholdResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUpdateSignatureThresholdResponse>, I>>(
+    _: I,
+  ): MsgUpdateSignatureThresholdResponse {
+    const message = createBaseMsgUpdateSignatureThresholdResponse();
+    return message;
+  },
+};
+
+function createBaseMsgLinkTokenPair(): MsgLinkTokenPair {
+  return { from: '', remoteDomain: 0, remoteToken: new Uint8Array(0), localToken: '' };
+}
+
+export const MsgLinkTokenPair = {
+  encode(message: MsgLinkTokenPair, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.remoteDomain !== 0) {
+      writer.uint32(16).uint32(message.remoteDomain);
+    }
+    if (message.remoteToken.length !== 0) {
+      writer.uint32(26).bytes(message.remoteToken);
+    }
+    if (message.localToken !== '') {
+      writer.uint32(34).string(message.localToken);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgLinkTokenPair {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgLinkTokenPair();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.remoteDomain = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.remoteToken = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.localToken = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgLinkTokenPair {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      remoteDomain: isSet(object.remoteDomain) ? gt.Number(object.remoteDomain) : 0,
+      remoteToken: isSet(object.remoteToken)
+        ? bytesFromBase64(object.remoteToken)
+        : new Uint8Array(0),
+      localToken: isSet(object.localToken) ? gt.String(object.localToken) : '',
+    };
+  },
+
+  toJSON(message: MsgLinkTokenPair): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.remoteDomain !== 0) {
+      obj.remoteDomain = Math.round(message.remoteDomain);
+    }
+    if (message.remoteToken.length !== 0) {
+      obj.remoteToken = base64FromBytes(message.remoteToken);
+    }
+    if (message.localToken !== '') {
+      obj.localToken = message.localToken;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgLinkTokenPair>, I>>(base?: I): MsgLinkTokenPair {
+    return MsgLinkTokenPair.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgLinkTokenPair>, I>>(object: I): MsgLinkTokenPair {
+    const message = createBaseMsgLinkTokenPair();
+    message.from = object.from ?? '';
+    message.remoteDomain = object.remoteDomain ?? 0;
+    message.remoteToken = object.remoteToken ?? new Uint8Array(0);
+    message.localToken = object.localToken ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgLinkTokenPairResponse(): MsgLinkTokenPairResponse {
+  return {};
+}
+
+export const MsgLinkTokenPairResponse = {
+  encode(_: MsgLinkTokenPairResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgLinkTokenPairResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgLinkTokenPairResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgLinkTokenPairResponse {
+    return {};
+  },
+
+  toJSON(_: MsgLinkTokenPairResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgLinkTokenPairResponse>, I>>(
+    base?: I,
+  ): MsgLinkTokenPairResponse {
+    return MsgLinkTokenPairResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgLinkTokenPairResponse>, I>>(
+    _: I,
+  ): MsgLinkTokenPairResponse {
+    const message = createBaseMsgLinkTokenPairResponse();
+    return message;
+  },
+};
+
+function createBaseMsgUnlinkTokenPair(): MsgUnlinkTokenPair {
+  return { from: '', remoteDomain: 0, remoteToken: new Uint8Array(0), localToken: '' };
+}
+
+export const MsgUnlinkTokenPair = {
+  encode(message: MsgUnlinkTokenPair, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.remoteDomain !== 0) {
+      writer.uint32(16).uint32(message.remoteDomain);
+    }
+    if (message.remoteToken.length !== 0) {
+      writer.uint32(26).bytes(message.remoteToken);
+    }
+    if (message.localToken !== '') {
+      writer.uint32(34).string(message.localToken);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUnlinkTokenPair {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnlinkTokenPair();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.remoteDomain = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.remoteToken = reader.bytes();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.localToken = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgUnlinkTokenPair {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      remoteDomain: isSet(object.remoteDomain) ? gt.Number(object.remoteDomain) : 0,
+      remoteToken: isSet(object.remoteToken)
+        ? bytesFromBase64(object.remoteToken)
+        : new Uint8Array(0),
+      localToken: isSet(object.localToken) ? gt.String(object.localToken) : '',
+    };
+  },
+
+  toJSON(message: MsgUnlinkTokenPair): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.remoteDomain !== 0) {
+      obj.remoteDomain = Math.round(message.remoteDomain);
+    }
+    if (message.remoteToken.length !== 0) {
+      obj.remoteToken = base64FromBytes(message.remoteToken);
+    }
+    if (message.localToken !== '') {
+      obj.localToken = message.localToken;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnlinkTokenPair>, I>>(base?: I): MsgUnlinkTokenPair {
+    return MsgUnlinkTokenPair.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnlinkTokenPair>, I>>(object: I): MsgUnlinkTokenPair {
+    const message = createBaseMsgUnlinkTokenPair();
+    message.from = object.from ?? '';
+    message.remoteDomain = object.remoteDomain ?? 0;
+    message.remoteToken = object.remoteToken ?? new Uint8Array(0);
+    message.localToken = object.localToken ?? '';
+    return message;
+  },
+};
+
+function createBaseMsgUnlinkTokenPairResponse(): MsgUnlinkTokenPairResponse {
+  return {};
+}
+
+export const MsgUnlinkTokenPairResponse = {
+  encode(_: MsgUnlinkTokenPairResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUnlinkTokenPairResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUnlinkTokenPairResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgUnlinkTokenPairResponse {
+    return {};
+  },
+
+  toJSON(_: MsgUnlinkTokenPairResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgUnlinkTokenPairResponse>, I>>(
+    base?: I,
+  ): MsgUnlinkTokenPairResponse {
+    return MsgUnlinkTokenPairResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgUnlinkTokenPairResponse>, I>>(
+    _: I,
+  ): MsgUnlinkTokenPairResponse {
+    const message = createBaseMsgUnlinkTokenPairResponse();
+    return message;
+  },
+};
+
+function createBaseMsgAddRemoteTokenMessenger(): MsgAddRemoteTokenMessenger {
+  return { from: '', domainId: 0, address: new Uint8Array(0) };
+}
+
+export const MsgAddRemoteTokenMessenger = {
+  encode(
+    message: MsgAddRemoteTokenMessenger,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.domainId !== 0) {
+      writer.uint32(16).uint32(message.domainId);
+    }
+    if (message.address.length !== 0) {
+      writer.uint32(26).bytes(message.address);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAddRemoteTokenMessenger {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAddRemoteTokenMessenger();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.domainId = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.address = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgAddRemoteTokenMessenger {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      domainId: isSet(object.domainId) ? gt.Number(object.domainId) : 0,
+      address: isSet(object.address) ? bytesFromBase64(object.address) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: MsgAddRemoteTokenMessenger): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.domainId !== 0) {
+      obj.domainId = Math.round(message.domainId);
+    }
+    if (message.address.length !== 0) {
+      obj.address = base64FromBytes(message.address);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgAddRemoteTokenMessenger>, I>>(
+    base?: I,
+  ): MsgAddRemoteTokenMessenger {
+    return MsgAddRemoteTokenMessenger.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgAddRemoteTokenMessenger>, I>>(
+    object: I,
+  ): MsgAddRemoteTokenMessenger {
+    const message = createBaseMsgAddRemoteTokenMessenger();
+    message.from = object.from ?? '';
+    message.domainId = object.domainId ?? 0;
+    message.address = object.address ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseMsgAddRemoteTokenMessengerResponse(): MsgAddRemoteTokenMessengerResponse {
+  return {};
+}
+
+export const MsgAddRemoteTokenMessengerResponse = {
+  encode(
+    _: MsgAddRemoteTokenMessengerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAddRemoteTokenMessengerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAddRemoteTokenMessengerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgAddRemoteTokenMessengerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgAddRemoteTokenMessengerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgAddRemoteTokenMessengerResponse>, I>>(
+    base?: I,
+  ): MsgAddRemoteTokenMessengerResponse {
+    return MsgAddRemoteTokenMessengerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgAddRemoteTokenMessengerResponse>, I>>(
+    _: I,
+  ): MsgAddRemoteTokenMessengerResponse {
+    const message = createBaseMsgAddRemoteTokenMessengerResponse();
+    return message;
+  },
+};
+
+function createBaseMsgRemoveRemoteTokenMessenger(): MsgRemoveRemoteTokenMessenger {
+  return { from: '', domainId: 0 };
+}
+
+export const MsgRemoveRemoteTokenMessenger = {
+  encode(
+    message: MsgRemoveRemoteTokenMessenger,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.from !== '') {
+      writer.uint32(10).string(message.from);
+    }
+    if (message.domainId !== 0) {
+      writer.uint32(16).uint32(message.domainId);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRemoveRemoteTokenMessenger {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRemoveRemoteTokenMessenger();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.from = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.domainId = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgRemoveRemoteTokenMessenger {
+    return {
+      from: isSet(object.from) ? gt.String(object.from) : '',
+      domainId: isSet(object.domainId) ? gt.Number(object.domainId) : 0,
+    };
+  },
+
+  toJSON(message: MsgRemoveRemoteTokenMessenger): unknown {
+    const obj: any = {};
+    if (message.from !== '') {
+      obj.from = message.from;
+    }
+    if (message.domainId !== 0) {
+      obj.domainId = Math.round(message.domainId);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgRemoveRemoteTokenMessenger>, I>>(
+    base?: I,
+  ): MsgRemoveRemoteTokenMessenger {
+    return MsgRemoveRemoteTokenMessenger.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgRemoveRemoteTokenMessenger>, I>>(
+    object: I,
+  ): MsgRemoveRemoteTokenMessenger {
+    const message = createBaseMsgRemoveRemoteTokenMessenger();
+    message.from = object.from ?? '';
+    message.domainId = object.domainId ?? 0;
+    return message;
+  },
+};
+
+function createBaseMsgRemoveRemoteTokenMessengerResponse(): MsgRemoveRemoteTokenMessengerResponse {
+  return {};
+}
+
+export const MsgRemoveRemoteTokenMessengerResponse = {
+  encode(
+    _: MsgRemoveRemoteTokenMessengerResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRemoveRemoteTokenMessengerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRemoveRemoteTokenMessengerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgRemoveRemoteTokenMessengerResponse {
+    return {};
+  },
+
+  toJSON(_: MsgRemoveRemoteTokenMessengerResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MsgRemoveRemoteTokenMessengerResponse>, I>>(
+    base?: I,
+  ): MsgRemoveRemoteTokenMessengerResponse {
+    return MsgRemoveRemoteTokenMessengerResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MsgRemoveRemoteTokenMessengerResponse>, I>>(
+    _: I,
+  ): MsgRemoveRemoteTokenMessengerResponse {
+    const message = createBaseMsgRemoveRemoteTokenMessengerResponse();
+    return message;
+  },
+};
+
+/** Msg defines the Msg service. */
+export interface Msg {
+  AcceptOwner(request: MsgAcceptOwner): Promise<MsgAcceptOwnerResponse>;
+  AddRemoteTokenMessenger(
+    request: MsgAddRemoteTokenMessenger,
+  ): Promise<MsgAddRemoteTokenMessengerResponse>;
+  DepositForBurn(request: MsgDepositForBurn): Promise<MsgDepositForBurnResponse>;
+  DepositForBurnWithCaller(
+    request: MsgDepositForBurnWithCaller,
+  ): Promise<MsgDepositForBurnWithCallerResponse>;
+  DisableAttester(request: MsgDisableAttester): Promise<MsgDisableAttesterResponse>;
+  EnableAttester(request: MsgEnableAttester): Promise<MsgEnableAttesterResponse>;
+  LinkTokenPair(request: MsgLinkTokenPair): Promise<MsgLinkTokenPairResponse>;
+  PauseBurningAndMinting(
+    request: MsgPauseBurningAndMinting,
+  ): Promise<MsgPauseBurningAndMintingResponse>;
+  PauseSendingAndReceivingMessages(
+    request: MsgPauseSendingAndReceivingMessages,
+  ): Promise<MsgPauseSendingAndReceivingMessagesResponse>;
+  ReceiveMessage(request: MsgReceiveMessage): Promise<MsgReceiveMessageResponse>;
+  RemoveRemoteTokenMessenger(
+    request: MsgRemoveRemoteTokenMessenger,
+  ): Promise<MsgRemoveRemoteTokenMessengerResponse>;
+  ReplaceDepositForBurn(
+    request: MsgReplaceDepositForBurn,
+  ): Promise<MsgReplaceDepositForBurnResponse>;
+  ReplaceMessage(request: MsgReplaceMessage): Promise<MsgReplaceMessageResponse>;
+  SendMessage(request: MsgSendMessage): Promise<MsgSendMessageResponse>;
+  SendMessageWithCaller(
+    request: MsgSendMessageWithCaller,
+  ): Promise<MsgSendMessageWithCallerResponse>;
+  UnlinkTokenPair(request: MsgUnlinkTokenPair): Promise<MsgUnlinkTokenPairResponse>;
+  UnpauseBurningAndMinting(
+    request: MsgUnpauseBurningAndMinting,
+  ): Promise<MsgUnpauseBurningAndMintingResponse>;
+  UnpauseSendingAndReceivingMessages(
+    request: MsgUnpauseSendingAndReceivingMessages,
+  ): Promise<MsgUnpauseSendingAndReceivingMessagesResponse>;
+  UpdateOwner(request: MsgUpdateOwner): Promise<MsgUpdateOwnerResponse>;
+  UpdateAttesterManager(
+    request: MsgUpdateAttesterManager,
+  ): Promise<MsgUpdateAttesterManagerResponse>;
+  UpdateTokenController(
+    request: MsgUpdateTokenController,
+  ): Promise<MsgUpdateTokenControllerResponse>;
+  UpdatePauser(request: MsgUpdatePauser): Promise<MsgUpdatePauserResponse>;
+  UpdateMaxMessageBodySize(
+    request: MsgUpdateMaxMessageBodySize,
+  ): Promise<MsgUpdateMaxMessageBodySizeResponse>;
+  SetMaxBurnAmountPerMessage(
+    request: MsgSetMaxBurnAmountPerMessage,
+  ): Promise<MsgSetMaxBurnAmountPerMessageResponse>;
+  UpdateSignatureThreshold(
+    request: MsgUpdateSignatureThreshold,
+  ): Promise<MsgUpdateSignatureThresholdResponse>;
+}
+
+export const MsgServiceName = 'circle.cctp.v1.Msg';
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || MsgServiceName;
+    this.rpc = rpc;
+    this.AcceptOwner = this.AcceptOwner.bind(this);
+    this.AddRemoteTokenMessenger = this.AddRemoteTokenMessenger.bind(this);
+    this.DepositForBurn = this.DepositForBurn.bind(this);
+    this.DepositForBurnWithCaller = this.DepositForBurnWithCaller.bind(this);
+    this.DisableAttester = this.DisableAttester.bind(this);
+    this.EnableAttester = this.EnableAttester.bind(this);
+    this.LinkTokenPair = this.LinkTokenPair.bind(this);
+    this.PauseBurningAndMinting = this.PauseBurningAndMinting.bind(this);
+    this.PauseSendingAndReceivingMessages = this.PauseSendingAndReceivingMessages.bind(this);
+    this.ReceiveMessage = this.ReceiveMessage.bind(this);
+    this.RemoveRemoteTokenMessenger = this.RemoveRemoteTokenMessenger.bind(this);
+    this.ReplaceDepositForBurn = this.ReplaceDepositForBurn.bind(this);
+    this.ReplaceMessage = this.ReplaceMessage.bind(this);
+    this.SendMessage = this.SendMessage.bind(this);
+    this.SendMessageWithCaller = this.SendMessageWithCaller.bind(this);
+    this.UnlinkTokenPair = this.UnlinkTokenPair.bind(this);
+    this.UnpauseBurningAndMinting = this.UnpauseBurningAndMinting.bind(this);
+    this.UnpauseSendingAndReceivingMessages = this.UnpauseSendingAndReceivingMessages.bind(this);
+    this.UpdateOwner = this.UpdateOwner.bind(this);
+    this.UpdateAttesterManager = this.UpdateAttesterManager.bind(this);
+    this.UpdateTokenController = this.UpdateTokenController.bind(this);
+    this.UpdatePauser = this.UpdatePauser.bind(this);
+    this.UpdateMaxMessageBodySize = this.UpdateMaxMessageBodySize.bind(this);
+    this.SetMaxBurnAmountPerMessage = this.SetMaxBurnAmountPerMessage.bind(this);
+    this.UpdateSignatureThreshold = this.UpdateSignatureThreshold.bind(this);
+  }
+  AcceptOwner(request: MsgAcceptOwner): Promise<MsgAcceptOwnerResponse> {
+    const data = MsgAcceptOwner.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'AcceptOwner', data);
+    return promise.then((data) => MsgAcceptOwnerResponse.decode(_m0.Reader.create(data)));
+  }
+
+  AddRemoteTokenMessenger(
+    request: MsgAddRemoteTokenMessenger,
+  ): Promise<MsgAddRemoteTokenMessengerResponse> {
+    const data = MsgAddRemoteTokenMessenger.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'AddRemoteTokenMessenger', data);
+    return promise.then((data) =>
+      MsgAddRemoteTokenMessengerResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  DepositForBurn(request: MsgDepositForBurn): Promise<MsgDepositForBurnResponse> {
+    const data = MsgDepositForBurn.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'DepositForBurn', data);
+    return promise.then((data) => MsgDepositForBurnResponse.decode(_m0.Reader.create(data)));
+  }
+
+  DepositForBurnWithCaller(
+    request: MsgDepositForBurnWithCaller,
+  ): Promise<MsgDepositForBurnWithCallerResponse> {
+    const data = MsgDepositForBurnWithCaller.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'DepositForBurnWithCaller', data);
+    return promise.then((data) =>
+      MsgDepositForBurnWithCallerResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  DisableAttester(request: MsgDisableAttester): Promise<MsgDisableAttesterResponse> {
+    const data = MsgDisableAttester.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'DisableAttester', data);
+    return promise.then((data) => MsgDisableAttesterResponse.decode(_m0.Reader.create(data)));
+  }
+
+  EnableAttester(request: MsgEnableAttester): Promise<MsgEnableAttesterResponse> {
+    const data = MsgEnableAttester.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'EnableAttester', data);
+    return promise.then((data) => MsgEnableAttesterResponse.decode(_m0.Reader.create(data)));
+  }
+
+  LinkTokenPair(request: MsgLinkTokenPair): Promise<MsgLinkTokenPairResponse> {
+    const data = MsgLinkTokenPair.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'LinkTokenPair', data);
+    return promise.then((data) => MsgLinkTokenPairResponse.decode(_m0.Reader.create(data)));
+  }
+
+  PauseBurningAndMinting(
+    request: MsgPauseBurningAndMinting,
+  ): Promise<MsgPauseBurningAndMintingResponse> {
+    const data = MsgPauseBurningAndMinting.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'PauseBurningAndMinting', data);
+    return promise.then((data) =>
+      MsgPauseBurningAndMintingResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  PauseSendingAndReceivingMessages(
+    request: MsgPauseSendingAndReceivingMessages,
+  ): Promise<MsgPauseSendingAndReceivingMessagesResponse> {
+    const data = MsgPauseSendingAndReceivingMessages.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'PauseSendingAndReceivingMessages', data);
+    return promise.then((data) =>
+      MsgPauseSendingAndReceivingMessagesResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  ReceiveMessage(request: MsgReceiveMessage): Promise<MsgReceiveMessageResponse> {
+    const data = MsgReceiveMessage.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'ReceiveMessage', data);
+    return promise.then((data) => MsgReceiveMessageResponse.decode(_m0.Reader.create(data)));
+  }
+
+  RemoveRemoteTokenMessenger(
+    request: MsgRemoveRemoteTokenMessenger,
+  ): Promise<MsgRemoveRemoteTokenMessengerResponse> {
+    const data = MsgRemoveRemoteTokenMessenger.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'RemoveRemoteTokenMessenger', data);
+    return promise.then((data) =>
+      MsgRemoveRemoteTokenMessengerResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  ReplaceDepositForBurn(
+    request: MsgReplaceDepositForBurn,
+  ): Promise<MsgReplaceDepositForBurnResponse> {
+    const data = MsgReplaceDepositForBurn.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'ReplaceDepositForBurn', data);
+    return promise.then((data) => MsgReplaceDepositForBurnResponse.decode(_m0.Reader.create(data)));
+  }
+
+  ReplaceMessage(request: MsgReplaceMessage): Promise<MsgReplaceMessageResponse> {
+    const data = MsgReplaceMessage.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'ReplaceMessage', data);
+    return promise.then((data) => MsgReplaceMessageResponse.decode(_m0.Reader.create(data)));
+  }
+
+  SendMessage(request: MsgSendMessage): Promise<MsgSendMessageResponse> {
+    const data = MsgSendMessage.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'SendMessage', data);
+    return promise.then((data) => MsgSendMessageResponse.decode(_m0.Reader.create(data)));
+  }
+
+  SendMessageWithCaller(
+    request: MsgSendMessageWithCaller,
+  ): Promise<MsgSendMessageWithCallerResponse> {
+    const data = MsgSendMessageWithCaller.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'SendMessageWithCaller', data);
+    return promise.then((data) => MsgSendMessageWithCallerResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UnlinkTokenPair(request: MsgUnlinkTokenPair): Promise<MsgUnlinkTokenPairResponse> {
+    const data = MsgUnlinkTokenPair.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UnlinkTokenPair', data);
+    return promise.then((data) => MsgUnlinkTokenPairResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UnpauseBurningAndMinting(
+    request: MsgUnpauseBurningAndMinting,
+  ): Promise<MsgUnpauseBurningAndMintingResponse> {
+    const data = MsgUnpauseBurningAndMinting.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UnpauseBurningAndMinting', data);
+    return promise.then((data) =>
+      MsgUnpauseBurningAndMintingResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  UnpauseSendingAndReceivingMessages(
+    request: MsgUnpauseSendingAndReceivingMessages,
+  ): Promise<MsgUnpauseSendingAndReceivingMessagesResponse> {
+    const data = MsgUnpauseSendingAndReceivingMessages.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UnpauseSendingAndReceivingMessages', data);
+    return promise.then((data) =>
+      MsgUnpauseSendingAndReceivingMessagesResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  UpdateOwner(request: MsgUpdateOwner): Promise<MsgUpdateOwnerResponse> {
+    const data = MsgUpdateOwner.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdateOwner', data);
+    return promise.then((data) => MsgUpdateOwnerResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UpdateAttesterManager(
+    request: MsgUpdateAttesterManager,
+  ): Promise<MsgUpdateAttesterManagerResponse> {
+    const data = MsgUpdateAttesterManager.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdateAttesterManager', data);
+    return promise.then((data) => MsgUpdateAttesterManagerResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UpdateTokenController(
+    request: MsgUpdateTokenController,
+  ): Promise<MsgUpdateTokenControllerResponse> {
+    const data = MsgUpdateTokenController.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdateTokenController', data);
+    return promise.then((data) => MsgUpdateTokenControllerResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UpdatePauser(request: MsgUpdatePauser): Promise<MsgUpdatePauserResponse> {
+    const data = MsgUpdatePauser.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdatePauser', data);
+    return promise.then((data) => MsgUpdatePauserResponse.decode(_m0.Reader.create(data)));
+  }
+
+  UpdateMaxMessageBodySize(
+    request: MsgUpdateMaxMessageBodySize,
+  ): Promise<MsgUpdateMaxMessageBodySizeResponse> {
+    const data = MsgUpdateMaxMessageBodySize.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdateMaxMessageBodySize', data);
+    return promise.then((data) =>
+      MsgUpdateMaxMessageBodySizeResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  SetMaxBurnAmountPerMessage(
+    request: MsgSetMaxBurnAmountPerMessage,
+  ): Promise<MsgSetMaxBurnAmountPerMessageResponse> {
+    const data = MsgSetMaxBurnAmountPerMessage.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'SetMaxBurnAmountPerMessage', data);
+    return promise.then((data) =>
+      MsgSetMaxBurnAmountPerMessageResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+
+  UpdateSignatureThreshold(
+    request: MsgUpdateSignatureThreshold,
+  ): Promise<MsgUpdateSignatureThresholdResponse> {
+    const data = MsgUpdateSignatureThreshold.encode(request).finish();
+    const promise = this.rpc.request(this.service, 'UpdateSignatureThreshold', data);
+    return promise.then((data) =>
+      MsgUpdateSignatureThresholdResponse.decode(_m0.Reader.create(data)),
+    );
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const gt: any = (() => {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  }
+  if (typeof self !== 'undefined') {
+    return self;
+  }
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+  if (typeof global !== 'undefined') {
+    return global;
+  }
+  throw 'Unable to locate global object';
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (gt.Buffer) {
+    return Uint8Array.from(gt.Buffer.from(b64, 'base64'));
+  } else {
+    const bin = gt.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (gt.Buffer) {
+    return gt.Buffer.from(arr).toString('base64');
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(gt.String.fromCharCode(byte));
+    });
+    return gt.btoa(bin.join(''));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+    ? string | number | Long
+    : T extends globalThis.Array<infer U>
+      ? globalThis.Array<DeepPartial<U>>
+      : T extends ReadonlyArray<infer U>
+        ? ReadonlyArray<DeepPartial<U>>
+        : T extends {}
+          ? { [K in keyof T]?: DeepPartial<T[K]> }
+          : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}