injectivejs 1.4.0 → 1.6.0

package/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/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/ibc/core/channel/v1/upgrade.d.ts

@@ -0,0 +1,139 @@
+import { Timeout, TimeoutAmino, Order } from "./channel";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * Upgrade is a verifiable type which contains the relevant information
+ * for an attempted upgrade. It provides the proposed changes to the channel
+ * end, the timeout for this upgrade attempt and the next packet sequence
+ * which allows the counterparty to efficiently know the highest sequence it has received.
+ * The next sequence send is used for pruning and upgrading from unordered to ordered channels.
+ */
+export interface Upgrade {
+    fields: UpgradeFields;
+    timeout: Timeout;
+    nextSequenceSend: bigint;
+}
+export interface UpgradeProtoMsg {
+    typeUrl: "/ibc.core.channel.v1.Upgrade";
+    value: Uint8Array;
+}
+/**
+ * Upgrade is a verifiable type which contains the relevant information
+ * for an attempted upgrade. It provides the proposed changes to the channel
+ * end, the timeout for this upgrade attempt and the next packet sequence
+ * which allows the counterparty to efficiently know the highest sequence it has received.
+ * The next sequence send is used for pruning and upgrading from unordered to ordered channels.
+ */
+export interface UpgradeAmino {
+    fields: UpgradeFieldsAmino;
+    timeout: TimeoutAmino;
+    next_sequence_send: string;
+}
+export interface UpgradeAminoMsg {
+    type: "cosmos-sdk/Upgrade";
+    value: UpgradeAmino;
+}
+/**
+ * UpgradeFields are the fields in a channel end which may be changed
+ * during a channel upgrade.
+ */
+export interface UpgradeFields {
+    ordering: Order;
+    connectionHops: string[];
+    version: string;
+}
+export interface UpgradeFieldsProtoMsg {
+    typeUrl: "/ibc.core.channel.v1.UpgradeFields";
+    value: Uint8Array;
+}
+/**
+ * UpgradeFields are the fields in a channel end which may be changed
+ * during a channel upgrade.
+ */
+export interface UpgradeFieldsAmino {
+    ordering: Order;
+    connection_hops: string[];
+    version: string;
+}
+export interface UpgradeFieldsAminoMsg {
+    type: "cosmos-sdk/UpgradeFields";
+    value: UpgradeFieldsAmino;
+}
+/**
+ * ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the
+ * upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the
+ * next sequence.
+ */
+export interface ErrorReceipt {
+    /** the channel upgrade sequence */
+    sequence: bigint;
+    /** the error message detailing the cause of failure */
+    message: string;
+}
+export interface ErrorReceiptProtoMsg {
+    typeUrl: "/ibc.core.channel.v1.ErrorReceipt";
+    value: Uint8Array;
+}
+/**
+ * ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the
+ * upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the
+ * next sequence.
+ */
+export interface ErrorReceiptAmino {
+    /** the channel upgrade sequence */
+    sequence: string;
+    /** the error message detailing the cause of failure */
+    message: string;
+}
+export interface ErrorReceiptAminoMsg {
+    type: "cosmos-sdk/ErrorReceipt";
+    value: ErrorReceiptAmino;
+}
+export declare const Upgrade: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Upgrade;
+    isAmino(o: any): o is UpgradeAmino;
+    encode(message: Upgrade, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Upgrade;
+    fromPartial(object: DeepPartial<Upgrade>): Upgrade;
+    fromAmino(object: UpgradeAmino): Upgrade;
+    toAmino(message: Upgrade): UpgradeAmino;
+    fromAminoMsg(object: UpgradeAminoMsg): Upgrade;
+    toAminoMsg(message: Upgrade): UpgradeAminoMsg;
+    fromProtoMsg(message: UpgradeProtoMsg): Upgrade;
+    toProto(message: Upgrade): Uint8Array;
+    toProtoMsg(message: Upgrade): UpgradeProtoMsg;
+};
+export declare const UpgradeFields: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is UpgradeFields;
+    isAmino(o: any): o is UpgradeFieldsAmino;
+    encode(message: UpgradeFields, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): UpgradeFields;
+    fromPartial(object: DeepPartial<UpgradeFields>): UpgradeFields;
+    fromAmino(object: UpgradeFieldsAmino): UpgradeFields;
+    toAmino(message: UpgradeFields): UpgradeFieldsAmino;
+    fromAminoMsg(object: UpgradeFieldsAminoMsg): UpgradeFields;
+    toAminoMsg(message: UpgradeFields): UpgradeFieldsAminoMsg;
+    fromProtoMsg(message: UpgradeFieldsProtoMsg): UpgradeFields;
+    toProto(message: UpgradeFields): Uint8Array;
+    toProtoMsg(message: UpgradeFields): UpgradeFieldsProtoMsg;
+};
+export declare const ErrorReceipt: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is ErrorReceipt;
+    isAmino(o: any): o is ErrorReceiptAmino;
+    encode(message: ErrorReceipt, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ErrorReceipt;
+    fromPartial(object: DeepPartial<ErrorReceipt>): ErrorReceipt;
+    fromAmino(object: ErrorReceiptAmino): ErrorReceipt;
+    toAmino(message: ErrorReceipt): ErrorReceiptAmino;
+    fromAminoMsg(object: ErrorReceiptAminoMsg): ErrorReceipt;
+    toAminoMsg(message: ErrorReceipt): ErrorReceiptAminoMsg;
+    fromProtoMsg(message: ErrorReceiptProtoMsg): ErrorReceipt;
+    toProto(message: ErrorReceipt): Uint8Array;
+    toProtoMsg(message: ErrorReceipt): ErrorReceiptProtoMsg;
+};

package/ibc/core/channel/v1/upgrade.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorReceipt = exports.UpgradeFields = exports.Upgrade = void 0;
+const channel_1 = require("./channel");
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+const registry_1 = require("../../../../registry");
+function createBaseUpgrade() {
+    return {
+        fields: exports.UpgradeFields.fromPartial({}),
+        timeout: channel_1.Timeout.fromPartial({}),
+        nextSequenceSend: BigInt(0)
+    };
+}
+exports.Upgrade = {
+    typeUrl: "/ibc.core.channel.v1.Upgrade",
+    aminoType: "cosmos-sdk/Upgrade",
+    is(o) {
+        return o && (o.$typeUrl === exports.Upgrade.typeUrl || exports.UpgradeFields.is(o.fields) && channel_1.Timeout.is(o.timeout) && typeof o.nextSequenceSend === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Upgrade.typeUrl || exports.UpgradeFields.isAmino(o.fields) && channel_1.Timeout.isAmino(o.timeout) && typeof o.next_sequence_send === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.fields !== undefined) {
+            exports.UpgradeFields.encode(message.fields, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.timeout !== undefined) {
+            channel_1.Timeout.encode(message.timeout, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.nextSequenceSend !== BigInt(0)) {
+            writer.uint32(24).uint64(message.nextSequenceSend);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUpgrade();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fields = exports.UpgradeFields.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.timeout = channel_1.Timeout.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.nextSequenceSend = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseUpgrade();
+        message.fields = object.fields !== undefined && object.fields !== null ? exports.UpgradeFields.fromPartial(object.fields) : undefined;
+        message.timeout = object.timeout !== undefined && object.timeout !== null ? channel_1.Timeout.fromPartial(object.timeout) : undefined;
+        message.nextSequenceSend = object.nextSequenceSend !== undefined && object.nextSequenceSend !== null ? BigInt(object.nextSequenceSend.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseUpgrade();
+        if (object.fields !== undefined && object.fields !== null) {
+            message.fields = exports.UpgradeFields.fromAmino(object.fields);
+        }
+        if (object.timeout !== undefined && object.timeout !== null) {
+            message.timeout = channel_1.Timeout.fromAmino(object.timeout);
+        }
+        if (object.next_sequence_send !== undefined && object.next_sequence_send !== null) {
+            message.nextSequenceSend = BigInt(object.next_sequence_send);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.fields = message.fields ? exports.UpgradeFields.toAmino(message.fields) : undefined;
+        obj.timeout = message.timeout ? channel_1.Timeout.toAmino(message.timeout) : undefined;
+        obj.next_sequence_send = message.nextSequenceSend !== BigInt(0) ? message.nextSequenceSend?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Upgrade.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Upgrade",
+            value: exports.Upgrade.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Upgrade.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Upgrade.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v1.Upgrade",
+            value: exports.Upgrade.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Upgrade.typeUrl, exports.Upgrade);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Upgrade.aminoType, exports.Upgrade.typeUrl);
+function createBaseUpgradeFields() {
+    return {
+        ordering: 0,
+        connectionHops: [],
+        version: ""
+    };
+}
+exports.UpgradeFields = {
+    typeUrl: "/ibc.core.channel.v1.UpgradeFields",
+    aminoType: "cosmos-sdk/UpgradeFields",
+    is(o) {
+        return o && (o.$typeUrl === exports.UpgradeFields.typeUrl || (0, helpers_1.isSet)(o.ordering) && Array.isArray(o.connectionHops) && (!o.connectionHops.length || typeof o.connectionHops[0] === "string") && typeof o.version === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.UpgradeFields.typeUrl || (0, helpers_1.isSet)(o.ordering) && Array.isArray(o.connection_hops) && (!o.connection_hops.length || typeof o.connection_hops[0] === "string") && typeof o.version === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.ordering !== 0) {
+            writer.uint32(8).int32(message.ordering);
+        }
+        for (const v of message.connectionHops) {
+            writer.uint32(18).string(v);
+        }
+        if (message.version !== "") {
+            writer.uint32(26).string(message.version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUpgradeFields();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.ordering = reader.int32();
+                    break;
+                case 2:
+                    message.connectionHops.push(reader.string());
+                    break;
+                case 3:
+                    message.version = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseUpgradeFields();
+        message.ordering = object.ordering ?? 0;
+        message.connectionHops = object.connectionHops?.map(e => e) || [];
+        message.version = object.version ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseUpgradeFields();
+        if (object.ordering !== undefined && object.ordering !== null) {
+            message.ordering = object.ordering;
+        }
+        message.connectionHops = object.connection_hops?.map(e => e) || [];
+        if (object.version !== undefined && object.version !== null) {
+            message.version = object.version;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.ordering = message.ordering === 0 ? undefined : message.ordering;
+        if (message.connectionHops) {
+            obj.connection_hops = message.connectionHops.map(e => e);
+        }
+        else {
+            obj.connection_hops = message.connectionHops;
+        }
+        obj.version = message.version === "" ? undefined : message.version;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.UpgradeFields.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/UpgradeFields",
+            value: exports.UpgradeFields.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.UpgradeFields.decode(message.value);
+    },
+    toProto(message) {
+        return exports.UpgradeFields.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v1.UpgradeFields",
+            value: exports.UpgradeFields.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.UpgradeFields.typeUrl, exports.UpgradeFields);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.UpgradeFields.aminoType, exports.UpgradeFields.typeUrl);
+function createBaseErrorReceipt() {
+    return {
+        sequence: BigInt(0),
+        message: ""
+    };
+}
+exports.ErrorReceipt = {
+    typeUrl: "/ibc.core.channel.v1.ErrorReceipt",
+    aminoType: "cosmos-sdk/ErrorReceipt",
+    is(o) {
+        return o && (o.$typeUrl === exports.ErrorReceipt.typeUrl || typeof o.sequence === "bigint" && typeof o.message === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.ErrorReceipt.typeUrl || typeof o.sequence === "bigint" && typeof o.message === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(8).uint64(message.sequence);
+        }
+        if (message.message !== "") {
+            writer.uint32(18).string(message.message);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseErrorReceipt();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sequence = reader.uint64();
+                    break;
+                case 2:
+                    message.message = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseErrorReceipt();
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        message.message = object.message ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseErrorReceipt();
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        if (object.message !== undefined && object.message !== null) {
+            message.message = object.message;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+        obj.message = message.message === "" ? undefined : message.message;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ErrorReceipt.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ErrorReceipt",
+            value: exports.ErrorReceipt.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.ErrorReceipt.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ErrorReceipt.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v1.ErrorReceipt",
+            value: exports.ErrorReceipt.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.ErrorReceipt.typeUrl, exports.ErrorReceipt);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.ErrorReceipt.aminoType, exports.ErrorReceipt.typeUrl);