juno-network 0.5.2 → 0.6.0

package/src/codegen/ibc/core/channel/v1/tx.ts

@@ -0,0 +1,1492 @@
+import { Channel, ChannelSDKType, Packet, PacketSDKType } from "./channel";
+import { Height, HeightSDKType } from "../../client/v1/client";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "@osmonauts/helpers";
+/**
+ * MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It
+ * is called by a relayer on Chain A.
+ */
+
+export interface MsgChannelOpenInit {
+  portId: string;
+  channel: Channel;
+  signer: string;
+}
+/**
+ * MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It
+ * is called by a relayer on Chain A.
+ */
+
+export interface MsgChannelOpenInitSDKType {
+  port_id: string;
+  channel: ChannelSDKType;
+  signer: string;
+}
+/** MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. */
+
+export interface MsgChannelOpenInitResponse {}
+/** MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. */
+
+export interface MsgChannelOpenInitResponseSDKType {}
+/**
+ * MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel
+ * on Chain B.
+ */
+
+export interface MsgChannelOpenTry {
+  portId: string;
+  /**
+   * in the case of crossing hello's, when both chains call OpenInit, we need
+   * the channel identifier of the previous channel in state INIT
+   */
+
+  previousChannelId: string;
+  channel: Channel;
+  counterpartyVersion: string;
+  proofInit: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/**
+ * MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel
+ * on Chain B.
+ */
+
+export interface MsgChannelOpenTrySDKType {
+  port_id: string;
+  /**
+   * in the case of crossing hello's, when both chains call OpenInit, we need
+   * the channel identifier of the previous channel in state INIT
+   */
+
+  previous_channel_id: string;
+  channel: ChannelSDKType;
+  counterparty_version: string;
+  proof_init: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/** MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. */
+
+export interface MsgChannelOpenTryResponse {}
+/** MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. */
+
+export interface MsgChannelOpenTryResponseSDKType {}
+/**
+ * MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge
+ * the change of channel state to TRYOPEN on Chain B.
+ */
+
+export interface MsgChannelOpenAck {
+  portId: string;
+  channelId: string;
+  counterpartyChannelId: string;
+  counterpartyVersion: string;
+  proofTry: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/**
+ * MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge
+ * the change of channel state to TRYOPEN on Chain B.
+ */
+
+export interface MsgChannelOpenAckSDKType {
+  port_id: string;
+  channel_id: string;
+  counterparty_channel_id: string;
+  counterparty_version: string;
+  proof_try: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/** MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. */
+
+export interface MsgChannelOpenAckResponse {}
+/** MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. */
+
+export interface MsgChannelOpenAckResponseSDKType {}
+/**
+ * MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to
+ * acknowledge the change of channel state to OPEN on Chain A.
+ */
+
+export interface MsgChannelOpenConfirm {
+  portId: string;
+  channelId: string;
+  proofAck: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/**
+ * MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to
+ * acknowledge the change of channel state to OPEN on Chain A.
+ */
+
+export interface MsgChannelOpenConfirmSDKType {
+  port_id: string;
+  channel_id: string;
+  proof_ack: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/**
+ * MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response
+ * type.
+ */
+
+export interface MsgChannelOpenConfirmResponse {}
+/**
+ * MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response
+ * type.
+ */
+
+export interface MsgChannelOpenConfirmResponseSDKType {}
+/**
+ * MsgChannelCloseInit defines a msg sent by a Relayer to Chain A
+ * to close a channel with Chain B.
+ */
+
+export interface MsgChannelCloseInit {
+  portId: string;
+  channelId: string;
+  signer: string;
+}
+/**
+ * MsgChannelCloseInit defines a msg sent by a Relayer to Chain A
+ * to close a channel with Chain B.
+ */
+
+export interface MsgChannelCloseInitSDKType {
+  port_id: string;
+  channel_id: string;
+  signer: string;
+}
+/** MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. */
+
+export interface MsgChannelCloseInitResponse {}
+/** MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. */
+
+export interface MsgChannelCloseInitResponseSDKType {}
+/**
+ * MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B
+ * to acknowledge the change of channel state to CLOSED on Chain A.
+ */
+
+export interface MsgChannelCloseConfirm {
+  portId: string;
+  channelId: string;
+  proofInit: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/**
+ * MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B
+ * to acknowledge the change of channel state to CLOSED on Chain A.
+ */
+
+export interface MsgChannelCloseConfirmSDKType {
+  port_id: string;
+  channel_id: string;
+  proof_init: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/**
+ * MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response
+ * type.
+ */
+
+export interface MsgChannelCloseConfirmResponse {}
+/**
+ * MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response
+ * type.
+ */
+
+export interface MsgChannelCloseConfirmResponseSDKType {}
+/** MsgRecvPacket receives incoming IBC packet */
+
+export interface MsgRecvPacket {
+  packet: Packet;
+  proofCommitment: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/** MsgRecvPacket receives incoming IBC packet */
+
+export interface MsgRecvPacketSDKType {
+  packet: PacketSDKType;
+  proof_commitment: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/** MsgRecvPacketResponse defines the Msg/RecvPacket response type. */
+
+export interface MsgRecvPacketResponse {}
+/** MsgRecvPacketResponse defines the Msg/RecvPacket response type. */
+
+export interface MsgRecvPacketResponseSDKType {}
+/** MsgTimeout receives timed-out packet */
+
+export interface MsgTimeout {
+  packet: Packet;
+  proofUnreceived: Uint8Array;
+  proofHeight: Height;
+  nextSequenceRecv: Long;
+  signer: string;
+}
+/** MsgTimeout receives timed-out packet */
+
+export interface MsgTimeoutSDKType {
+  packet: PacketSDKType;
+  proof_unreceived: Uint8Array;
+  proof_height: HeightSDKType;
+  next_sequence_recv: Long;
+  signer: string;
+}
+/** MsgTimeoutResponse defines the Msg/Timeout response type. */
+
+export interface MsgTimeoutResponse {}
+/** MsgTimeoutResponse defines the Msg/Timeout response type. */
+
+export interface MsgTimeoutResponseSDKType {}
+/** MsgTimeoutOnClose timed-out packet upon counterparty channel closure. */
+
+export interface MsgTimeoutOnClose {
+  packet: Packet;
+  proofUnreceived: Uint8Array;
+  proofClose: Uint8Array;
+  proofHeight: Height;
+  nextSequenceRecv: Long;
+  signer: string;
+}
+/** MsgTimeoutOnClose timed-out packet upon counterparty channel closure. */
+
+export interface MsgTimeoutOnCloseSDKType {
+  packet: PacketSDKType;
+  proof_unreceived: Uint8Array;
+  proof_close: Uint8Array;
+  proof_height: HeightSDKType;
+  next_sequence_recv: Long;
+  signer: string;
+}
+/** MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. */
+
+export interface MsgTimeoutOnCloseResponse {}
+/** MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. */
+
+export interface MsgTimeoutOnCloseResponseSDKType {}
+/** MsgAcknowledgement receives incoming IBC acknowledgement */
+
+export interface MsgAcknowledgement {
+  packet: Packet;
+  acknowledgement: Uint8Array;
+  proofAcked: Uint8Array;
+  proofHeight: Height;
+  signer: string;
+}
+/** MsgAcknowledgement receives incoming IBC acknowledgement */
+
+export interface MsgAcknowledgementSDKType {
+  packet: PacketSDKType;
+  acknowledgement: Uint8Array;
+  proof_acked: Uint8Array;
+  proof_height: HeightSDKType;
+  signer: string;
+}
+/** MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. */
+
+export interface MsgAcknowledgementResponse {}
+/** MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. */
+
+export interface MsgAcknowledgementResponseSDKType {}
+
+function createBaseMsgChannelOpenInit(): MsgChannelOpenInit {
+  return {
+    portId: "",
+    channel: undefined,
+    signer: ""
+  };
+}
+
+export const MsgChannelOpenInit = {
+  encode(message: MsgChannelOpenInit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channel !== undefined) {
+      Channel.encode(message.channel, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(26).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenInit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenInit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.channel = Channel.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelOpenInit>): MsgChannelOpenInit {
+    const message = createBaseMsgChannelOpenInit();
+    message.portId = object.portId ?? "";
+    message.channel = object.channel !== undefined && object.channel !== null ? Channel.fromPartial(object.channel) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenInitResponse(): MsgChannelOpenInitResponse {
+  return {};
+}
+
+export const MsgChannelOpenInitResponse = {
+  encode(_: MsgChannelOpenInitResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenInitResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenInitResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelOpenInitResponse>): MsgChannelOpenInitResponse {
+    const message = createBaseMsgChannelOpenInitResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenTry(): MsgChannelOpenTry {
+  return {
+    portId: "",
+    previousChannelId: "",
+    channel: undefined,
+    counterpartyVersion: "",
+    proofInit: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgChannelOpenTry = {
+  encode(message: MsgChannelOpenTry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.previousChannelId !== "") {
+      writer.uint32(18).string(message.previousChannelId);
+    }
+
+    if (message.channel !== undefined) {
+      Channel.encode(message.channel, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.counterpartyVersion !== "") {
+      writer.uint32(34).string(message.counterpartyVersion);
+    }
+
+    if (message.proofInit.length !== 0) {
+      writer.uint32(42).bytes(message.proofInit);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(58).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenTry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenTry();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.previousChannelId = reader.string();
+          break;
+
+        case 3:
+          message.channel = Channel.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.counterpartyVersion = reader.string();
+          break;
+
+        case 5:
+          message.proofInit = reader.bytes();
+          break;
+
+        case 6:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 7:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelOpenTry>): MsgChannelOpenTry {
+    const message = createBaseMsgChannelOpenTry();
+    message.portId = object.portId ?? "";
+    message.previousChannelId = object.previousChannelId ?? "";
+    message.channel = object.channel !== undefined && object.channel !== null ? Channel.fromPartial(object.channel) : undefined;
+    message.counterpartyVersion = object.counterpartyVersion ?? "";
+    message.proofInit = object.proofInit ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenTryResponse(): MsgChannelOpenTryResponse {
+  return {};
+}
+
+export const MsgChannelOpenTryResponse = {
+  encode(_: MsgChannelOpenTryResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenTryResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenTryResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelOpenTryResponse>): MsgChannelOpenTryResponse {
+    const message = createBaseMsgChannelOpenTryResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenAck(): MsgChannelOpenAck {
+  return {
+    portId: "",
+    channelId: "",
+    counterpartyChannelId: "",
+    counterpartyVersion: "",
+    proofTry: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgChannelOpenAck = {
+  encode(message: MsgChannelOpenAck, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+
+    if (message.counterpartyChannelId !== "") {
+      writer.uint32(26).string(message.counterpartyChannelId);
+    }
+
+    if (message.counterpartyVersion !== "") {
+      writer.uint32(34).string(message.counterpartyVersion);
+    }
+
+    if (message.proofTry.length !== 0) {
+      writer.uint32(42).bytes(message.proofTry);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(58).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenAck {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenAck();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.channelId = reader.string();
+          break;
+
+        case 3:
+          message.counterpartyChannelId = reader.string();
+          break;
+
+        case 4:
+          message.counterpartyVersion = reader.string();
+          break;
+
+        case 5:
+          message.proofTry = reader.bytes();
+          break;
+
+        case 6:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 7:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelOpenAck>): MsgChannelOpenAck {
+    const message = createBaseMsgChannelOpenAck();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.counterpartyChannelId = object.counterpartyChannelId ?? "";
+    message.counterpartyVersion = object.counterpartyVersion ?? "";
+    message.proofTry = object.proofTry ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenAckResponse(): MsgChannelOpenAckResponse {
+  return {};
+}
+
+export const MsgChannelOpenAckResponse = {
+  encode(_: MsgChannelOpenAckResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenAckResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenAckResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelOpenAckResponse>): MsgChannelOpenAckResponse {
+    const message = createBaseMsgChannelOpenAckResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenConfirm(): MsgChannelOpenConfirm {
+  return {
+    portId: "",
+    channelId: "",
+    proofAck: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgChannelOpenConfirm = {
+  encode(message: MsgChannelOpenConfirm, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+
+    if (message.proofAck.length !== 0) {
+      writer.uint32(26).bytes(message.proofAck);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(42).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenConfirm {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenConfirm();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.channelId = reader.string();
+          break;
+
+        case 3:
+          message.proofAck = reader.bytes();
+          break;
+
+        case 4:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelOpenConfirm>): MsgChannelOpenConfirm {
+    const message = createBaseMsgChannelOpenConfirm();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.proofAck = object.proofAck ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelOpenConfirmResponse(): MsgChannelOpenConfirmResponse {
+  return {};
+}
+
+export const MsgChannelOpenConfirmResponse = {
+  encode(_: MsgChannelOpenConfirmResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelOpenConfirmResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelOpenConfirmResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelOpenConfirmResponse>): MsgChannelOpenConfirmResponse {
+    const message = createBaseMsgChannelOpenConfirmResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelCloseInit(): MsgChannelCloseInit {
+  return {
+    portId: "",
+    channelId: "",
+    signer: ""
+  };
+}
+
+export const MsgChannelCloseInit = {
+  encode(message: MsgChannelCloseInit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(26).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelCloseInit {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelCloseInit();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.channelId = reader.string();
+          break;
+
+        case 3:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelCloseInit>): MsgChannelCloseInit {
+    const message = createBaseMsgChannelCloseInit();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelCloseInitResponse(): MsgChannelCloseInitResponse {
+  return {};
+}
+
+export const MsgChannelCloseInitResponse = {
+  encode(_: MsgChannelCloseInitResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelCloseInitResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelCloseInitResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelCloseInitResponse>): MsgChannelCloseInitResponse {
+    const message = createBaseMsgChannelCloseInitResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelCloseConfirm(): MsgChannelCloseConfirm {
+  return {
+    portId: "",
+    channelId: "",
+    proofInit: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgChannelCloseConfirm = {
+  encode(message: MsgChannelCloseConfirm, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+
+    if (message.proofInit.length !== 0) {
+      writer.uint32(26).bytes(message.proofInit);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(42).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelCloseConfirm {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelCloseConfirm();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+
+        case 2:
+          message.channelId = reader.string();
+          break;
+
+        case 3:
+          message.proofInit = reader.bytes();
+          break;
+
+        case 4:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgChannelCloseConfirm>): MsgChannelCloseConfirm {
+    const message = createBaseMsgChannelCloseConfirm();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.proofInit = object.proofInit ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgChannelCloseConfirmResponse(): MsgChannelCloseConfirmResponse {
+  return {};
+}
+
+export const MsgChannelCloseConfirmResponse = {
+  encode(_: MsgChannelCloseConfirmResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgChannelCloseConfirmResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgChannelCloseConfirmResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgChannelCloseConfirmResponse>): MsgChannelCloseConfirmResponse {
+    const message = createBaseMsgChannelCloseConfirmResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgRecvPacket(): MsgRecvPacket {
+  return {
+    packet: undefined,
+    proofCommitment: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgRecvPacket = {
+  encode(message: MsgRecvPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.packet !== undefined) {
+      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.proofCommitment.length !== 0) {
+      writer.uint32(18).bytes(message.proofCommitment);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(34).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRecvPacket {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRecvPacket();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.packet = Packet.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.proofCommitment = reader.bytes();
+          break;
+
+        case 3:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgRecvPacket>): MsgRecvPacket {
+    const message = createBaseMsgRecvPacket();
+    message.packet = object.packet !== undefined && object.packet !== null ? Packet.fromPartial(object.packet) : undefined;
+    message.proofCommitment = object.proofCommitment ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgRecvPacketResponse(): MsgRecvPacketResponse {
+  return {};
+}
+
+export const MsgRecvPacketResponse = {
+  encode(_: MsgRecvPacketResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRecvPacketResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRecvPacketResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgRecvPacketResponse>): MsgRecvPacketResponse {
+    const message = createBaseMsgRecvPacketResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgTimeout(): MsgTimeout {
+  return {
+    packet: undefined,
+    proofUnreceived: new Uint8Array(),
+    proofHeight: undefined,
+    nextSequenceRecv: Long.UZERO,
+    signer: ""
+  };
+}
+
+export const MsgTimeout = {
+  encode(message: MsgTimeout, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.packet !== undefined) {
+      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.proofUnreceived.length !== 0) {
+      writer.uint32(18).bytes(message.proofUnreceived);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (!message.nextSequenceRecv.isZero()) {
+      writer.uint32(32).uint64(message.nextSequenceRecv);
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(42).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTimeout {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTimeout();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.packet = Packet.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.proofUnreceived = reader.bytes();
+          break;
+
+        case 3:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.nextSequenceRecv = (reader.uint64() as Long);
+          break;
+
+        case 5:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgTimeout>): MsgTimeout {
+    const message = createBaseMsgTimeout();
+    message.packet = object.packet !== undefined && object.packet !== null ? Packet.fromPartial(object.packet) : undefined;
+    message.proofUnreceived = object.proofUnreceived ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.nextSequenceRecv = object.nextSequenceRecv !== undefined && object.nextSequenceRecv !== null ? Long.fromValue(object.nextSequenceRecv) : Long.UZERO;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgTimeoutResponse(): MsgTimeoutResponse {
+  return {};
+}
+
+export const MsgTimeoutResponse = {
+  encode(_: MsgTimeoutResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTimeoutResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTimeoutResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgTimeoutResponse>): MsgTimeoutResponse {
+    const message = createBaseMsgTimeoutResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgTimeoutOnClose(): MsgTimeoutOnClose {
+  return {
+    packet: undefined,
+    proofUnreceived: new Uint8Array(),
+    proofClose: new Uint8Array(),
+    proofHeight: undefined,
+    nextSequenceRecv: Long.UZERO,
+    signer: ""
+  };
+}
+
+export const MsgTimeoutOnClose = {
+  encode(message: MsgTimeoutOnClose, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.packet !== undefined) {
+      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.proofUnreceived.length !== 0) {
+      writer.uint32(18).bytes(message.proofUnreceived);
+    }
+
+    if (message.proofClose.length !== 0) {
+      writer.uint32(26).bytes(message.proofClose);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (!message.nextSequenceRecv.isZero()) {
+      writer.uint32(40).uint64(message.nextSequenceRecv);
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(50).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTimeoutOnClose {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTimeoutOnClose();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.packet = Packet.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.proofUnreceived = reader.bytes();
+          break;
+
+        case 3:
+          message.proofClose = reader.bytes();
+          break;
+
+        case 4:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.nextSequenceRecv = (reader.uint64() as Long);
+          break;
+
+        case 6:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgTimeoutOnClose>): MsgTimeoutOnClose {
+    const message = createBaseMsgTimeoutOnClose();
+    message.packet = object.packet !== undefined && object.packet !== null ? Packet.fromPartial(object.packet) : undefined;
+    message.proofUnreceived = object.proofUnreceived ?? new Uint8Array();
+    message.proofClose = object.proofClose ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.nextSequenceRecv = object.nextSequenceRecv !== undefined && object.nextSequenceRecv !== null ? Long.fromValue(object.nextSequenceRecv) : Long.UZERO;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgTimeoutOnCloseResponse(): MsgTimeoutOnCloseResponse {
+  return {};
+}
+
+export const MsgTimeoutOnCloseResponse = {
+  encode(_: MsgTimeoutOnCloseResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgTimeoutOnCloseResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgTimeoutOnCloseResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgTimeoutOnCloseResponse>): MsgTimeoutOnCloseResponse {
+    const message = createBaseMsgTimeoutOnCloseResponse();
+    return message;
+  }
+
+};
+
+function createBaseMsgAcknowledgement(): MsgAcknowledgement {
+  return {
+    packet: undefined,
+    acknowledgement: new Uint8Array(),
+    proofAcked: new Uint8Array(),
+    proofHeight: undefined,
+    signer: ""
+  };
+}
+
+export const MsgAcknowledgement = {
+  encode(message: MsgAcknowledgement, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.packet !== undefined) {
+      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.acknowledgement.length !== 0) {
+      writer.uint32(18).bytes(message.acknowledgement);
+    }
+
+    if (message.proofAcked.length !== 0) {
+      writer.uint32(26).bytes(message.proofAcked);
+    }
+
+    if (message.proofHeight !== undefined) {
+      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.signer !== "") {
+      writer.uint32(42).string(message.signer);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAcknowledgement {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAcknowledgement();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.packet = Packet.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.acknowledgement = reader.bytes();
+          break;
+
+        case 3:
+          message.proofAcked = reader.bytes();
+          break;
+
+        case 4:
+          message.proofHeight = Height.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.signer = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgAcknowledgement>): MsgAcknowledgement {
+    const message = createBaseMsgAcknowledgement();
+    message.packet = object.packet !== undefined && object.packet !== null ? Packet.fromPartial(object.packet) : undefined;
+    message.acknowledgement = object.acknowledgement ?? new Uint8Array();
+    message.proofAcked = object.proofAcked ?? new Uint8Array();
+    message.proofHeight = object.proofHeight !== undefined && object.proofHeight !== null ? Height.fromPartial(object.proofHeight) : undefined;
+    message.signer = object.signer ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgAcknowledgementResponse(): MsgAcknowledgementResponse {
+  return {};
+}
+
+export const MsgAcknowledgementResponse = {
+  encode(_: MsgAcknowledgementResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgAcknowledgementResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgAcknowledgementResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgAcknowledgementResponse>): MsgAcknowledgementResponse {
+    const message = createBaseMsgAcknowledgementResponse();
+    return message;
+  }
+
+};