@xpla/xplajs 1.7.0-beta.6 → 1.7.0-beta.7

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

@@ -0,0 +1,98 @@
+import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement, MsgChannelUpgradeInit, MsgChannelUpgradeTry, MsgChannelUpgradeAck, MsgChannelUpgradeConfirm, MsgChannelUpgradeOpen, MsgChannelUpgradeTimeout, MsgChannelUpgradeCancel, MsgUpdateParams, MsgPruneAcknowledgements } from "./tx";
+export const AminoConverter = {
+  "/ibc.core.channel.v1.MsgChannelOpenInit": {
+    aminoType: "cosmos-sdk/MsgChannelOpenInit",
+    toAmino: MsgChannelOpenInit.toAmino,
+    fromAmino: MsgChannelOpenInit.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelOpenTry": {
+    aminoType: "cosmos-sdk/MsgChannelOpenTry",
+    toAmino: MsgChannelOpenTry.toAmino,
+    fromAmino: MsgChannelOpenTry.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelOpenAck": {
+    aminoType: "cosmos-sdk/MsgChannelOpenAck",
+    toAmino: MsgChannelOpenAck.toAmino,
+    fromAmino: MsgChannelOpenAck.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelOpenConfirm": {
+    aminoType: "cosmos-sdk/MsgChannelOpenConfirm",
+    toAmino: MsgChannelOpenConfirm.toAmino,
+    fromAmino: MsgChannelOpenConfirm.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelCloseInit": {
+    aminoType: "cosmos-sdk/MsgChannelCloseInit",
+    toAmino: MsgChannelCloseInit.toAmino,
+    fromAmino: MsgChannelCloseInit.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelCloseConfirm": {
+    aminoType: "cosmos-sdk/MsgChannelCloseConfirm",
+    toAmino: MsgChannelCloseConfirm.toAmino,
+    fromAmino: MsgChannelCloseConfirm.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgRecvPacket": {
+    aminoType: "cosmos-sdk/MsgRecvPacket",
+    toAmino: MsgRecvPacket.toAmino,
+    fromAmino: MsgRecvPacket.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgTimeout": {
+    aminoType: "cosmos-sdk/MsgTimeout",
+    toAmino: MsgTimeout.toAmino,
+    fromAmino: MsgTimeout.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgTimeoutOnClose": {
+    aminoType: "cosmos-sdk/MsgTimeoutOnClose",
+    toAmino: MsgTimeoutOnClose.toAmino,
+    fromAmino: MsgTimeoutOnClose.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgAcknowledgement": {
+    aminoType: "cosmos-sdk/MsgAcknowledgement",
+    toAmino: MsgAcknowledgement.toAmino,
+    fromAmino: MsgAcknowledgement.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeInit": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeInit",
+    toAmino: MsgChannelUpgradeInit.toAmino,
+    fromAmino: MsgChannelUpgradeInit.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeTry": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeTry",
+    toAmino: MsgChannelUpgradeTry.toAmino,
+    fromAmino: MsgChannelUpgradeTry.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeAck": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeAck",
+    toAmino: MsgChannelUpgradeAck.toAmino,
+    fromAmino: MsgChannelUpgradeAck.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeConfirm": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeConfirm",
+    toAmino: MsgChannelUpgradeConfirm.toAmino,
+    fromAmino: MsgChannelUpgradeConfirm.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeOpen": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeOpen",
+    toAmino: MsgChannelUpgradeOpen.toAmino,
+    fromAmino: MsgChannelUpgradeOpen.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeTimeout": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeTimeout",
+    toAmino: MsgChannelUpgradeTimeout.toAmino,
+    fromAmino: MsgChannelUpgradeTimeout.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgChannelUpgradeCancel": {
+    aminoType: "cosmos-sdk/MsgChannelUpgradeCancel",
+    toAmino: MsgChannelUpgradeCancel.toAmino,
+    fromAmino: MsgChannelUpgradeCancel.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgUpdateParams": {
+    aminoType: "cosmos-sdk/MsgUpdateParams",
+    toAmino: MsgUpdateParams.toAmino,
+    fromAmino: MsgUpdateParams.fromAmino
+  },
+  "/ibc.core.channel.v1.MsgPruneAcknowledgements": {
+    aminoType: "cosmos-sdk/MsgPruneAcknowledgements",
+    toAmino: MsgPruneAcknowledgements.toAmino,
+    fromAmino: MsgPruneAcknowledgements.fromAmino
+  }
+};

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

@@ -0,0 +1,3 @@
+import { TelescopeGeneratedType } from "../../../../types";
+import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement, MsgChannelUpgradeInit, MsgChannelUpgradeTry, MsgChannelUpgradeAck, MsgChannelUpgradeConfirm, MsgChannelUpgradeOpen, MsgChannelUpgradeTimeout, MsgChannelUpgradeCancel, MsgUpdateParams, MsgPruneAcknowledgements } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/ibc.core.channel.v1.MsgChannelOpenInit", MsgChannelOpenInit], ["/ibc.core.channel.v1.MsgChannelOpenTry", MsgChannelOpenTry], ["/ibc.core.channel.v1.MsgChannelOpenAck", MsgChannelOpenAck], ["/ibc.core.channel.v1.MsgChannelOpenConfirm", MsgChannelOpenConfirm], ["/ibc.core.channel.v1.MsgChannelCloseInit", MsgChannelCloseInit], ["/ibc.core.channel.v1.MsgChannelCloseConfirm", MsgChannelCloseConfirm], ["/ibc.core.channel.v1.MsgRecvPacket", MsgRecvPacket], ["/ibc.core.channel.v1.MsgTimeout", MsgTimeout], ["/ibc.core.channel.v1.MsgTimeoutOnClose", MsgTimeoutOnClose], ["/ibc.core.channel.v1.MsgAcknowledgement", MsgAcknowledgement], ["/ibc.core.channel.v1.MsgChannelUpgradeInit", MsgChannelUpgradeInit], ["/ibc.core.channel.v1.MsgChannelUpgradeTry", MsgChannelUpgradeTry], ["/ibc.core.channel.v1.MsgChannelUpgradeAck", MsgChannelUpgradeAck], ["/ibc.core.channel.v1.MsgChannelUpgradeConfirm", MsgChannelUpgradeConfirm], ["/ibc.core.channel.v1.MsgChannelUpgradeOpen", MsgChannelUpgradeOpen], ["/ibc.core.channel.v1.MsgChannelUpgradeTimeout", MsgChannelUpgradeTimeout], ["/ibc.core.channel.v1.MsgChannelUpgradeCancel", MsgChannelUpgradeCancel], ["/ibc.core.channel.v1.MsgUpdateParams", MsgUpdateParams], ["/ibc.core.channel.v1.MsgPruneAcknowledgements", MsgPruneAcknowledgements]];

package/src/ibc/core/channel/v1/tx.rpc.func.ts

@@ -0,0 +1,117 @@
+import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement, MsgChannelUpgradeInit, MsgChannelUpgradeTry, MsgChannelUpgradeAck, MsgChannelUpgradeConfirm, MsgChannelUpgradeOpen, MsgChannelUpgradeTimeout, MsgChannelUpgradeCancel, MsgUpdateParams, MsgPruneAcknowledgements } from "./tx";
+export const createChannelOpenInit = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelOpenInit>({
+  clientResolver,
+  typeUrl: MsgChannelOpenInit.typeUrl,
+  encoders: toEncoders(MsgChannelOpenInit),
+  converters: toConverters(MsgChannelOpenInit)
+});
+export const createChannelOpenTry = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelOpenTry>({
+  clientResolver,
+  typeUrl: MsgChannelOpenTry.typeUrl,
+  encoders: toEncoders(MsgChannelOpenTry),
+  converters: toConverters(MsgChannelOpenTry)
+});
+export const createChannelOpenAck = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelOpenAck>({
+  clientResolver,
+  typeUrl: MsgChannelOpenAck.typeUrl,
+  encoders: toEncoders(MsgChannelOpenAck),
+  converters: toConverters(MsgChannelOpenAck)
+});
+export const createChannelOpenConfirm = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelOpenConfirm>({
+  clientResolver,
+  typeUrl: MsgChannelOpenConfirm.typeUrl,
+  encoders: toEncoders(MsgChannelOpenConfirm),
+  converters: toConverters(MsgChannelOpenConfirm)
+});
+export const createChannelCloseInit = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelCloseInit>({
+  clientResolver,
+  typeUrl: MsgChannelCloseInit.typeUrl,
+  encoders: toEncoders(MsgChannelCloseInit),
+  converters: toConverters(MsgChannelCloseInit)
+});
+export const createChannelCloseConfirm = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelCloseConfirm>({
+  clientResolver,
+  typeUrl: MsgChannelCloseConfirm.typeUrl,
+  encoders: toEncoders(MsgChannelCloseConfirm),
+  converters: toConverters(MsgChannelCloseConfirm)
+});
+export const createRecvPacket = (clientResolver?: SigningClientResolver) => buildTx<MsgRecvPacket>({
+  clientResolver,
+  typeUrl: MsgRecvPacket.typeUrl,
+  encoders: toEncoders(MsgRecvPacket),
+  converters: toConverters(MsgRecvPacket)
+});
+export const createTimeout = (clientResolver?: SigningClientResolver) => buildTx<MsgTimeout>({
+  clientResolver,
+  typeUrl: MsgTimeout.typeUrl,
+  encoders: toEncoders(MsgTimeout),
+  converters: toConverters(MsgTimeout)
+});
+export const createTimeoutOnClose = (clientResolver?: SigningClientResolver) => buildTx<MsgTimeoutOnClose>({
+  clientResolver,
+  typeUrl: MsgTimeoutOnClose.typeUrl,
+  encoders: toEncoders(MsgTimeoutOnClose),
+  converters: toConverters(MsgTimeoutOnClose)
+});
+export const createAcknowledgement = (clientResolver?: SigningClientResolver) => buildTx<MsgAcknowledgement>({
+  clientResolver,
+  typeUrl: MsgAcknowledgement.typeUrl,
+  encoders: toEncoders(MsgAcknowledgement),
+  converters: toConverters(MsgAcknowledgement)
+});
+export const createChannelUpgradeInit = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeInit>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeInit.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeInit),
+  converters: toConverters(MsgChannelUpgradeInit)
+});
+export const createChannelUpgradeTry = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeTry>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeTry.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeTry),
+  converters: toConverters(MsgChannelUpgradeTry)
+});
+export const createChannelUpgradeAck = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeAck>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeAck.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeAck),
+  converters: toConverters(MsgChannelUpgradeAck)
+});
+export const createChannelUpgradeConfirm = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeConfirm>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeConfirm.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeConfirm),
+  converters: toConverters(MsgChannelUpgradeConfirm)
+});
+export const createChannelUpgradeOpen = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeOpen>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeOpen.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeOpen),
+  converters: toConverters(MsgChannelUpgradeOpen)
+});
+export const createChannelUpgradeTimeout = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeTimeout>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeTimeout.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeTimeout),
+  converters: toConverters(MsgChannelUpgradeTimeout)
+});
+export const createChannelUpgradeCancel = (clientResolver?: SigningClientResolver) => buildTx<MsgChannelUpgradeCancel>({
+  clientResolver,
+  typeUrl: MsgChannelUpgradeCancel.typeUrl,
+  encoders: toEncoders(MsgChannelUpgradeCancel),
+  converters: toConverters(MsgChannelUpgradeCancel)
+});
+export const createUpdateChannelParams = (clientResolver?: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
+  typeUrl: MsgUpdateParams.typeUrl,
+  encoders: toEncoders(MsgUpdateParams),
+  converters: toConverters(MsgUpdateParams)
+});
+export const createPruneAcknowledgements = (clientResolver?: SigningClientResolver) => buildTx<MsgPruneAcknowledgements>({
+  clientResolver,
+  typeUrl: MsgPruneAcknowledgements.typeUrl,
+  encoders: toEncoders(MsgPruneAcknowledgements),
+  converters: toConverters(MsgPruneAcknowledgements)
+});

package/src/ibc/core/channel/v1/tx.rpc.msg.ts

@@ -0,0 +1,171 @@
+import { TxRpc } from "../../../../types";
+import { BinaryReader } from "../../../../binary";
+import { MsgChannelOpenInit, MsgChannelOpenInitResponse, MsgChannelOpenTry, MsgChannelOpenTryResponse, MsgChannelOpenAck, MsgChannelOpenAckResponse, MsgChannelOpenConfirm, MsgChannelOpenConfirmResponse, MsgChannelCloseInit, MsgChannelCloseInitResponse, MsgChannelCloseConfirm, MsgChannelCloseConfirmResponse, MsgRecvPacket, MsgRecvPacketResponse, MsgTimeout, MsgTimeoutResponse, MsgTimeoutOnClose, MsgTimeoutOnCloseResponse, MsgAcknowledgement, MsgAcknowledgementResponse, MsgChannelUpgradeInit, MsgChannelUpgradeInitResponse, MsgChannelUpgradeTry, MsgChannelUpgradeTryResponse, MsgChannelUpgradeAck, MsgChannelUpgradeAckResponse, MsgChannelUpgradeConfirm, MsgChannelUpgradeConfirmResponse, MsgChannelUpgradeOpen, MsgChannelUpgradeOpenResponse, MsgChannelUpgradeTimeout, MsgChannelUpgradeTimeoutResponse, MsgChannelUpgradeCancel, MsgChannelUpgradeCancelResponse, MsgUpdateParams, MsgUpdateParamsResponse, MsgPruneAcknowledgements, MsgPruneAcknowledgementsResponse } from "./tx";
+/** Msg defines the ibc/channel Msg service. */
+export interface Msg {
+  /** ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. */
+  channelOpenInit(request: MsgChannelOpenInit): Promise<MsgChannelOpenInitResponse>;
+  /** ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry. */
+  channelOpenTry(request: MsgChannelOpenTry): Promise<MsgChannelOpenTryResponse>;
+  /** ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck. */
+  channelOpenAck(request: MsgChannelOpenAck): Promise<MsgChannelOpenAckResponse>;
+  /** ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm. */
+  channelOpenConfirm(request: MsgChannelOpenConfirm): Promise<MsgChannelOpenConfirmResponse>;
+  /** ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit. */
+  channelCloseInit(request: MsgChannelCloseInit): Promise<MsgChannelCloseInitResponse>;
+  /**
+   * ChannelCloseConfirm defines a rpc handler method for
+   * MsgChannelCloseConfirm.
+   */
+  channelCloseConfirm(request: MsgChannelCloseConfirm): Promise<MsgChannelCloseConfirmResponse>;
+  /** RecvPacket defines a rpc handler method for MsgRecvPacket. */
+  recvPacket(request: MsgRecvPacket): Promise<MsgRecvPacketResponse>;
+  /** Timeout defines a rpc handler method for MsgTimeout. */
+  timeout(request: MsgTimeout): Promise<MsgTimeoutResponse>;
+  /** TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. */
+  timeoutOnClose(request: MsgTimeoutOnClose): Promise<MsgTimeoutOnCloseResponse>;
+  /** Acknowledgement defines a rpc handler method for MsgAcknowledgement. */
+  acknowledgement(request: MsgAcknowledgement): Promise<MsgAcknowledgementResponse>;
+  /** ChannelUpgradeInit defines a rpc handler method for MsgChannelUpgradeInit. */
+  channelUpgradeInit(request: MsgChannelUpgradeInit): Promise<MsgChannelUpgradeInitResponse>;
+  /** ChannelUpgradeTry defines a rpc handler method for MsgChannelUpgradeTry. */
+  channelUpgradeTry(request: MsgChannelUpgradeTry): Promise<MsgChannelUpgradeTryResponse>;
+  /** ChannelUpgradeAck defines a rpc handler method for MsgChannelUpgradeAck. */
+  channelUpgradeAck(request: MsgChannelUpgradeAck): Promise<MsgChannelUpgradeAckResponse>;
+  /** ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm. */
+  channelUpgradeConfirm(request: MsgChannelUpgradeConfirm): Promise<MsgChannelUpgradeConfirmResponse>;
+  /** ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. */
+  channelUpgradeOpen(request: MsgChannelUpgradeOpen): Promise<MsgChannelUpgradeOpenResponse>;
+  /** ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. */
+  channelUpgradeTimeout(request: MsgChannelUpgradeTimeout): Promise<MsgChannelUpgradeTimeoutResponse>;
+  /** ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. */
+  channelUpgradeCancel(request: MsgChannelUpgradeCancel): Promise<MsgChannelUpgradeCancelResponse>;
+  /** UpdateChannelParams defines a rpc handler method for MsgUpdateParams. */
+  updateChannelParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+  /** PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. */
+  pruneAcknowledgements(request: MsgPruneAcknowledgements): Promise<MsgPruneAcknowledgementsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. */
+  channelOpenInit = async (request: MsgChannelOpenInit): Promise<MsgChannelOpenInitResponse> => {
+    const data = MsgChannelOpenInit.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenInit", data);
+    return promise.then(data => MsgChannelOpenInitResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry. */
+  channelOpenTry = async (request: MsgChannelOpenTry): Promise<MsgChannelOpenTryResponse> => {
+    const data = MsgChannelOpenTry.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenTry", data);
+    return promise.then(data => MsgChannelOpenTryResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck. */
+  channelOpenAck = async (request: MsgChannelOpenAck): Promise<MsgChannelOpenAckResponse> => {
+    const data = MsgChannelOpenAck.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenAck", data);
+    return promise.then(data => MsgChannelOpenAckResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm. */
+  channelOpenConfirm = async (request: MsgChannelOpenConfirm): Promise<MsgChannelOpenConfirmResponse> => {
+    const data = MsgChannelOpenConfirm.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelOpenConfirm", data);
+    return promise.then(data => MsgChannelOpenConfirmResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit. */
+  channelCloseInit = async (request: MsgChannelCloseInit): Promise<MsgChannelCloseInitResponse> => {
+    const data = MsgChannelCloseInit.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelCloseInit", data);
+    return promise.then(data => MsgChannelCloseInitResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelCloseConfirm defines a rpc handler method for
+   MsgChannelCloseConfirm. */
+  channelCloseConfirm = async (request: MsgChannelCloseConfirm): Promise<MsgChannelCloseConfirmResponse> => {
+    const data = MsgChannelCloseConfirm.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelCloseConfirm", data);
+    return promise.then(data => MsgChannelCloseConfirmResponse.decode(new BinaryReader(data)));
+  };
+  /* RecvPacket defines a rpc handler method for MsgRecvPacket. */
+  recvPacket = async (request: MsgRecvPacket): Promise<MsgRecvPacketResponse> => {
+    const data = MsgRecvPacket.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "RecvPacket", data);
+    return promise.then(data => MsgRecvPacketResponse.decode(new BinaryReader(data)));
+  };
+  /* Timeout defines a rpc handler method for MsgTimeout. */
+  timeout = async (request: MsgTimeout): Promise<MsgTimeoutResponse> => {
+    const data = MsgTimeout.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "Timeout", data);
+    return promise.then(data => MsgTimeoutResponse.decode(new BinaryReader(data)));
+  };
+  /* TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. */
+  timeoutOnClose = async (request: MsgTimeoutOnClose): Promise<MsgTimeoutOnCloseResponse> => {
+    const data = MsgTimeoutOnClose.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "TimeoutOnClose", data);
+    return promise.then(data => MsgTimeoutOnCloseResponse.decode(new BinaryReader(data)));
+  };
+  /* Acknowledgement defines a rpc handler method for MsgAcknowledgement. */
+  acknowledgement = async (request: MsgAcknowledgement): Promise<MsgAcknowledgementResponse> => {
+    const data = MsgAcknowledgement.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "Acknowledgement", data);
+    return promise.then(data => MsgAcknowledgementResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeInit defines a rpc handler method for MsgChannelUpgradeInit. */
+  channelUpgradeInit = async (request: MsgChannelUpgradeInit): Promise<MsgChannelUpgradeInitResponse> => {
+    const data = MsgChannelUpgradeInit.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeInit", data);
+    return promise.then(data => MsgChannelUpgradeInitResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeTry defines a rpc handler method for MsgChannelUpgradeTry. */
+  channelUpgradeTry = async (request: MsgChannelUpgradeTry): Promise<MsgChannelUpgradeTryResponse> => {
+    const data = MsgChannelUpgradeTry.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeTry", data);
+    return promise.then(data => MsgChannelUpgradeTryResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeAck defines a rpc handler method for MsgChannelUpgradeAck. */
+  channelUpgradeAck = async (request: MsgChannelUpgradeAck): Promise<MsgChannelUpgradeAckResponse> => {
+    const data = MsgChannelUpgradeAck.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeAck", data);
+    return promise.then(data => MsgChannelUpgradeAckResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm. */
+  channelUpgradeConfirm = async (request: MsgChannelUpgradeConfirm): Promise<MsgChannelUpgradeConfirmResponse> => {
+    const data = MsgChannelUpgradeConfirm.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeConfirm", data);
+    return promise.then(data => MsgChannelUpgradeConfirmResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. */
+  channelUpgradeOpen = async (request: MsgChannelUpgradeOpen): Promise<MsgChannelUpgradeOpenResponse> => {
+    const data = MsgChannelUpgradeOpen.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeOpen", data);
+    return promise.then(data => MsgChannelUpgradeOpenResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. */
+  channelUpgradeTimeout = async (request: MsgChannelUpgradeTimeout): Promise<MsgChannelUpgradeTimeoutResponse> => {
+    const data = MsgChannelUpgradeTimeout.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeTimeout", data);
+    return promise.then(data => MsgChannelUpgradeTimeoutResponse.decode(new BinaryReader(data)));
+  };
+  /* ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. */
+  channelUpgradeCancel = async (request: MsgChannelUpgradeCancel): Promise<MsgChannelUpgradeCancelResponse> => {
+    const data = MsgChannelUpgradeCancel.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "ChannelUpgradeCancel", data);
+    return promise.then(data => MsgChannelUpgradeCancelResponse.decode(new BinaryReader(data)));
+  };
+  /* UpdateChannelParams defines a rpc handler method for MsgUpdateParams. */
+  updateChannelParams = async (request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> => {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "UpdateChannelParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+  };
+  /* PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. */
+  pruneAcknowledgements = async (request: MsgPruneAcknowledgements): Promise<MsgPruneAcknowledgementsResponse> => {
+    const data = MsgPruneAcknowledgements.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.channel.v1.Msg", "PruneAcknowledgements", data);
+    return promise.then(data => MsgPruneAcknowledgementsResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createClientImpl = (rpc: TxRpc) => {
+  return new MsgClientImpl(rpc);
+};