@xpla/xplajs 1.7.0-beta.0

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.d.ts

@@ -0,0 +1,21 @@
+import { SigningClientResolver } from "../../../../helper-func-types";
+import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement, MsgChannelUpgradeInit, MsgChannelUpgradeTry, MsgChannelUpgradeAck, MsgChannelUpgradeConfirm, MsgChannelUpgradeOpen, MsgChannelUpgradeTimeout, MsgChannelUpgradeCancel, MsgUpdateParams, MsgPruneAcknowledgements } from "./tx";
+export declare const createChannelOpenInit: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelOpenInit, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelOpenTry: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelOpenTry, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelOpenAck: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelOpenAck, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelOpenConfirm: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelOpenConfirm, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelCloseInit: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelCloseInit, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelCloseConfirm: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelCloseConfirm, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createRecvPacket: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRecvPacket, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createTimeout: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgTimeout, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createTimeoutOnClose: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgTimeoutOnClose, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createAcknowledgement: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgAcknowledgement, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeInit: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeInit, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeTry: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeTry, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeAck: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeAck, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeConfirm: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeConfirm, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeOpen: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeOpen, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeTimeout: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeTimeout, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createChannelUpgradeCancel: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgChannelUpgradeCancel, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createUpdateChannelParams: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgUpdateParams, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const createPruneAcknowledgements: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgPruneAcknowledgements, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPruneAcknowledgements = exports.createUpdateChannelParams = exports.createChannelUpgradeCancel = exports.createChannelUpgradeTimeout = exports.createChannelUpgradeOpen = exports.createChannelUpgradeConfirm = exports.createChannelUpgradeAck = exports.createChannelUpgradeTry = exports.createChannelUpgradeInit = exports.createAcknowledgement = exports.createTimeoutOnClose = exports.createTimeout = exports.createRecvPacket = exports.createChannelCloseConfirm = exports.createChannelCloseInit = exports.createChannelOpenConfirm = exports.createChannelOpenAck = exports.createChannelOpenTry = exports.createChannelOpenInit = void 0;
+const helper_func_types_1 = require("../../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createChannelOpenInit = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelOpenInit.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelOpenInit),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelOpenInit)
+});
+exports.createChannelOpenInit = createChannelOpenInit;
+const createChannelOpenTry = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelOpenTry.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelOpenTry),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelOpenTry)
+});
+exports.createChannelOpenTry = createChannelOpenTry;
+const createChannelOpenAck = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelOpenAck.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelOpenAck),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelOpenAck)
+});
+exports.createChannelOpenAck = createChannelOpenAck;
+const createChannelOpenConfirm = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelOpenConfirm.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelOpenConfirm),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelOpenConfirm)
+});
+exports.createChannelOpenConfirm = createChannelOpenConfirm;
+const createChannelCloseInit = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelCloseInit.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelCloseInit),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelCloseInit)
+});
+exports.createChannelCloseInit = createChannelCloseInit;
+const createChannelCloseConfirm = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelCloseConfirm.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelCloseConfirm),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelCloseConfirm)
+});
+exports.createChannelCloseConfirm = createChannelCloseConfirm;
+const createRecvPacket = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRecvPacket.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRecvPacket),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRecvPacket)
+});
+exports.createRecvPacket = createRecvPacket;
+const createTimeout = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgTimeout.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgTimeout),
+    converters: (0, utils_1.toConverters)(tx_1.MsgTimeout)
+});
+exports.createTimeout = createTimeout;
+const createTimeoutOnClose = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgTimeoutOnClose.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgTimeoutOnClose),
+    converters: (0, utils_1.toConverters)(tx_1.MsgTimeoutOnClose)
+});
+exports.createTimeoutOnClose = createTimeoutOnClose;
+const createAcknowledgement = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgAcknowledgement.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgAcknowledgement),
+    converters: (0, utils_1.toConverters)(tx_1.MsgAcknowledgement)
+});
+exports.createAcknowledgement = createAcknowledgement;
+const createChannelUpgradeInit = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeInit.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeInit),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeInit)
+});
+exports.createChannelUpgradeInit = createChannelUpgradeInit;
+const createChannelUpgradeTry = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeTry.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeTry),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeTry)
+});
+exports.createChannelUpgradeTry = createChannelUpgradeTry;
+const createChannelUpgradeAck = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeAck.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeAck),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeAck)
+});
+exports.createChannelUpgradeAck = createChannelUpgradeAck;
+const createChannelUpgradeConfirm = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeConfirm.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeConfirm),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeConfirm)
+});
+exports.createChannelUpgradeConfirm = createChannelUpgradeConfirm;
+const createChannelUpgradeOpen = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeOpen.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeOpen),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeOpen)
+});
+exports.createChannelUpgradeOpen = createChannelUpgradeOpen;
+const createChannelUpgradeTimeout = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeTimeout.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeTimeout),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeTimeout)
+});
+exports.createChannelUpgradeTimeout = createChannelUpgradeTimeout;
+const createChannelUpgradeCancel = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgChannelUpgradeCancel.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgChannelUpgradeCancel),
+    converters: (0, utils_1.toConverters)(tx_1.MsgChannelUpgradeCancel)
+});
+exports.createChannelUpgradeCancel = createChannelUpgradeCancel;
+const createUpdateChannelParams = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgUpdateParams.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgUpdateParams),
+    converters: (0, utils_1.toConverters)(tx_1.MsgUpdateParams)
+});
+exports.createUpdateChannelParams = createUpdateChannelParams;
+const createPruneAcknowledgements = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgPruneAcknowledgements.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgPruneAcknowledgements),
+    converters: (0, utils_1.toConverters)(tx_1.MsgPruneAcknowledgements)
+});
+exports.createPruneAcknowledgements = createPruneAcknowledgements;

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);
+};