decentralcardgame-cardchain-client-ts 0.0.3 → 0.0.5

package/cosmos.staking.v1beta1/module.js

@@ -3,12 +3,12 @@ import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry } from "@cosmjs/proto-signing";
 import { msgTypes } from './registry';
 import { Api } from "./rest";
-import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgDelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgBeginRedelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
 import { StakeAuthorization as typeStakeAuthorization } from "./types";
 import { StakeAuthorization_Validators as typeStakeAuthorization_Validators } from "./types";
 import { LastValidatorPower as typeLastValidatorPower } from "./types";
@@ -32,7 +32,7 @@ import { DelegationResponse as typeDelegationResponse } from "./types";
 import { RedelegationEntryResponse as typeRedelegationEntryResponse } from "./types";
 import { RedelegationResponse as typeRedelegationResponse } from "./types";
 import { Pool as typePool } from "./types";
-export { MsgCreateValidator, MsgCancelUnbondingDelegation, MsgDelegate, MsgEditValidator, MsgBeginRedelegate, MsgUndelegate };
+export { MsgUndelegate, MsgDelegate, MsgBeginRedelegate, MsgEditValidator, MsgCreateValidator, MsgCancelUnbondingDelegation };
 export const registry = new Registry(msgTypes);
 function getStructure(template) {
     const structure = { fields: [] };
@@ -48,46 +48,46 @@ const defaultFee = {
 };
 export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
     return {
-        async sendMsgCreateValidator({ value, fee, memo }) {
+        async sendMsgUndelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateValidator: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgUndelegate: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgCreateValidator({ value: MsgCreateValidator.fromPartial(value) });
+                let msg = this.msgUndelegate({ value: MsgUndelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreateValidator: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgUndelegate: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgCancelUnbondingDelegation({ value, fee, memo }) {
+        async sendMsgDelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgDelegate: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgCancelUnbondingDelegation({ value: MsgCancelUnbondingDelegation.fromPartial(value) });
+                let msg = this.msgDelegate({ value: MsgDelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgDelegate: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgDelegate({ value, fee, memo }) {
+        async sendMsgBeginRedelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgDelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgBeginRedelegate: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgDelegate({ value: MsgDelegate.fromPartial(value) });
+                let msg = this.msgBeginRedelegate({ value: MsgBeginRedelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgDelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgBeginRedelegate: Could not broadcast Tx: ' + e.message);
             }
         },
         async sendMsgEditValidator({ value, fee, memo }) {
@@ -104,56 +104,56 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:sendMsgEditValidator: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgBeginRedelegate({ value, fee, memo }) {
+        async sendMsgCreateValidator({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBeginRedelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreateValidator: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgBeginRedelegate({ value: MsgBeginRedelegate.fromPartial(value) });
+                let msg = this.msgCreateValidator({ value: MsgCreateValidator.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgBeginRedelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreateValidator: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgUndelegate({ value, fee, memo }) {
+        async sendMsgCancelUnbondingDelegation({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgUndelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgUndelegate({ value: MsgUndelegate.fromPartial(value) });
+                let msg = this.msgCancelUnbondingDelegation({ value: MsgCancelUnbondingDelegation.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgUndelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Could not broadcast Tx: ' + e.message);
             }
         },
-        msgCreateValidator({ value }) {
+        msgUndelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator", value: MsgCreateValidator.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate", value: MsgUndelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreateValidator: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgUndelegate: Could not create message: ' + e.message);
             }
         },
-        msgCancelUnbondingDelegation({ value }) {
+        msgDelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", value: MsgCancelUnbondingDelegation.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgDelegate", value: MsgDelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCancelUnbondingDelegation: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgDelegate: Could not create message: ' + e.message);
             }
         },
-        msgDelegate({ value }) {
+        msgBeginRedelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgDelegate", value: MsgDelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate", value: MsgBeginRedelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgDelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgBeginRedelegate: Could not create message: ' + e.message);
             }
         },
         msgEditValidator({ value }) {
@@ -164,20 +164,20 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:MsgEditValidator: Could not create message: ' + e.message);
             }
         },
-        msgBeginRedelegate({ value }) {
+        msgCreateValidator({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate", value: MsgBeginRedelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator", value: MsgCreateValidator.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgBeginRedelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreateValidator: Could not create message: ' + e.message);
             }
         },
-        msgUndelegate({ value }) {
+        msgCancelUnbondingDelegation({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate", value: MsgUndelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", value: MsgCancelUnbondingDelegation.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgUndelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCancelUnbondingDelegation: Could not create message: ' + e.message);
             }
         },
     };

package/cosmos.staking.v1beta1/registry.js

@@ -1,15 +1,15 @@
-import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgDelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgBeginRedelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
 const msgTypes = [
-    ["/cosmos.staking.v1beta1.MsgCreateValidator", MsgCreateValidator],
-    ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", MsgCancelUnbondingDelegation],
+    ["/cosmos.staking.v1beta1.MsgUndelegate", MsgUndelegate],
     ["/cosmos.staking.v1beta1.MsgDelegate", MsgDelegate],
-    ["/cosmos.staking.v1beta1.MsgEditValidator", MsgEditValidator],
     ["/cosmos.staking.v1beta1.MsgBeginRedelegate", MsgBeginRedelegate],
-    ["/cosmos.staking.v1beta1.MsgUndelegate", MsgUndelegate],
+    ["/cosmos.staking.v1beta1.MsgEditValidator", MsgEditValidator],
+    ["/cosmos.staking.v1beta1.MsgCreateValidator", MsgCreateValidator],
+    ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", MsgCancelUnbondingDelegation],
 ];
 export { msgTypes };

package/cosmos.vesting.v1beta1/module.js

@@ -3,8 +3,8 @@ import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry } from "@cosmjs/proto-signing";
 import { msgTypes } from './registry';
 import { Api } from "./rest";
-import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePermanentLockedAccount } from "./types/cosmos/vesting/v1beta1/tx";
+import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePeriodicVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { BaseVestingAccount as typeBaseVestingAccount } from "./types";
 import { ContinuousVestingAccount as typeContinuousVestingAccount } from "./types";
@@ -12,7 +12,7 @@ import { DelayedVestingAccount as typeDelayedVestingAccount } from "./types";
 import { Period as typePeriod } from "./types";
 import { PeriodicVestingAccount as typePeriodicVestingAccount } from "./types";
 import { PermanentLockedAccount as typePermanentLockedAccount } from "./types";
-export { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount };
+export { MsgCreatePermanentLockedAccount, MsgCreateVestingAccount, MsgCreatePeriodicVestingAccount };
 export const registry = new Registry(msgTypes);
 function getStructure(template) {
     const structure = { fields: [] };
@@ -28,32 +28,32 @@ const defaultFee = {
 };
 export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
     return {
-        async sendMsgCreateVestingAccount({ value, fee, memo }) {
+        async sendMsgCreatePermanentLockedAccount({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateVestingAccount: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgCreateVestingAccount({ value: MsgCreateVestingAccount.fromPartial(value) });
+                let msg = this.msgCreatePermanentLockedAccount({ value: MsgCreatePermanentLockedAccount.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreateVestingAccount: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgCreatePermanentLockedAccount({ value, fee, memo }) {
+        async sendMsgCreateVestingAccount({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreateVestingAccount: Unable to sign Tx. Signer is not present.');
             }
             try {
                 const { address } = (await signer.getAccounts())[0];
                 const signingClient = await SigningStargateClient.connectWithSigner(addr, signer, { registry, prefix });
-                let msg = this.msgCreatePermanentLockedAccount({ value: MsgCreatePermanentLockedAccount.fromPartial(value) });
+                let msg = this.msgCreateVestingAccount({ value: MsgCreateVestingAccount.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreateVestingAccount: Could not broadcast Tx: ' + e.message);
             }
         },
         async sendMsgCreatePeriodicVestingAccount({ value, fee, memo }) {
@@ -70,20 +70,20 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:sendMsgCreatePeriodicVestingAccount: Could not broadcast Tx: ' + e.message);
             }
         },
-        msgCreateVestingAccount({ value }) {
+        msgCreatePermanentLockedAccount({ value }) {
             try {
-                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount", value: MsgCreateVestingAccount.fromPartial(value) };
+                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", value: MsgCreatePermanentLockedAccount.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreateVestingAccount: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreatePermanentLockedAccount: Could not create message: ' + e.message);
             }
         },
-        msgCreatePermanentLockedAccount({ value }) {
+        msgCreateVestingAccount({ value }) {
             try {
-                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", value: MsgCreatePermanentLockedAccount.fromPartial(value) };
+                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount", value: MsgCreateVestingAccount.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreatePermanentLockedAccount: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreateVestingAccount: Could not create message: ' + e.message);
             }
         },
         msgCreatePeriodicVestingAccount({ value }) {

package/cosmos.vesting.v1beta1/registry.js

@@ -1,9 +1,9 @@
-import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePermanentLockedAccount } from "./types/cosmos/vesting/v1beta1/tx";
+import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePeriodicVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 const msgTypes = [
-    ["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", MsgCreateVestingAccount],
     ["/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", MsgCreatePermanentLockedAccount],
+    ["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", MsgCreateVestingAccount],
     ["/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount", MsgCreatePeriodicVestingAccount],
 ];
 export { msgTypes };

package/ibc.applications.interchain_accounts.controller.v1/rest.js

@@ -8,6 +8,15 @@
  * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
  * ---------------------------------------------------------------
  */
+/**
+* - TYPE_UNSPECIFIED: Default zero value enumeration
+ - TYPE_EXECUTE_TX: Execute a transaction on an interchain accounts host chain
+*/
+export var InterchainAccountsv1Type;
+(function (InterchainAccountsv1Type) {
+    InterchainAccountsv1Type["TYPE_UNSPECIFIED"] = "TYPE_UNSPECIFIED";
+    InterchainAccountsv1Type["TYPE_EXECUTE_TX"] = "TYPE_EXECUTE_TX";
+})(InterchainAccountsv1Type || (InterchainAccountsv1Type = {}));
 import axios from "axios";
 export var ContentType;
 (function (ContentType) {

package/ibc.applications.interchain_accounts.controller.v1/types/ibc/applications/interchain_accounts/controller/v1/tx.js

@@ -0,0 +1,266 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { InterchainAccountPacketData } from "../../v1/packet";
+export const protobufPackage = "ibc.applications.interchain_accounts.controller.v1";
+function createBaseMsgRegisterInterchainAccount() {
+    return { owner: "", connectionId: "", version: "" };
+}
+export const MsgRegisterInterchainAccount = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.connectionId !== "") {
+            writer.uint32(18).string(message.connectionId);
+        }
+        if (message.version !== "") {
+            writer.uint32(26).string(message.version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRegisterInterchainAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.connectionId = reader.string();
+                    break;
+                case 3:
+                    message.version = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            owner: isSet(object.owner) ? String(object.owner) : "",
+            connectionId: isSet(object.connectionId) ? String(object.connectionId) : "",
+            version: isSet(object.version) ? String(object.version) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.owner !== undefined && (obj.owner = message.owner);
+        message.connectionId !== undefined && (obj.connectionId = message.connectionId);
+        message.version !== undefined && (obj.version = message.version);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterInterchainAccount();
+        message.owner = object.owner ?? "";
+        message.connectionId = object.connectionId ?? "";
+        message.version = object.version ?? "";
+        return message;
+    },
+};
+function createBaseMsgRegisterInterchainAccountResponse() {
+    return { channelId: "" };
+}
+export const MsgRegisterInterchainAccountResponse = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.channelId !== "") {
+            writer.uint32(10).string(message.channelId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRegisterInterchainAccountResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.channelId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { channelId: isSet(object.channelId) ? String(object.channelId) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.channelId !== undefined && (obj.channelId = message.channelId);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterInterchainAccountResponse();
+        message.channelId = object.channelId ?? "";
+        return message;
+    },
+};
+function createBaseMsgSendTx() {
+    return { owner: "", connectionId: "", packetData: undefined, relativeTimeout: 0 };
+}
+export const MsgSendTx = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.connectionId !== "") {
+            writer.uint32(18).string(message.connectionId);
+        }
+        if (message.packetData !== undefined) {
+            InterchainAccountPacketData.encode(message.packetData, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.relativeTimeout !== 0) {
+            writer.uint32(32).uint64(message.relativeTimeout);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgSendTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.connectionId = reader.string();
+                    break;
+                case 3:
+                    message.packetData = InterchainAccountPacketData.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.relativeTimeout = longToNumber(reader.uint64());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            owner: isSet(object.owner) ? String(object.owner) : "",
+            connectionId: isSet(object.connectionId) ? String(object.connectionId) : "",
+            packetData: isSet(object.packetData) ? InterchainAccountPacketData.fromJSON(object.packetData) : undefined,
+            relativeTimeout: isSet(object.relativeTimeout) ? Number(object.relativeTimeout) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.owner !== undefined && (obj.owner = message.owner);
+        message.connectionId !== undefined && (obj.connectionId = message.connectionId);
+        message.packetData !== undefined
+            && (obj.packetData = message.packetData ? InterchainAccountPacketData.toJSON(message.packetData) : undefined);
+        message.relativeTimeout !== undefined && (obj.relativeTimeout = Math.round(message.relativeTimeout));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSendTx();
+        message.owner = object.owner ?? "";
+        message.connectionId = object.connectionId ?? "";
+        message.packetData = (object.packetData !== undefined && object.packetData !== null)
+            ? InterchainAccountPacketData.fromPartial(object.packetData)
+            : undefined;
+        message.relativeTimeout = object.relativeTimeout ?? 0;
+        return message;
+    },
+};
+function createBaseMsgSendTxResponse() {
+    return { sequence: 0 };
+}
+export const MsgSendTxResponse = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.sequence !== 0) {
+            writer.uint32(8).uint64(message.sequence);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgSendTxResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sequence = longToNumber(reader.uint64());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { sequence: isSet(object.sequence) ? Number(object.sequence) : 0 };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.sequence !== undefined && (obj.sequence = Math.round(message.sequence));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSendTxResponse();
+        message.sequence = object.sequence ?? 0;
+        return message;
+    },
+};
+export class MsgClientImpl {
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.RegisterInterchainAccount = this.RegisterInterchainAccount.bind(this);
+        this.SendTx = this.SendTx.bind(this);
+    }
+    RegisterInterchainAccount(request) {
+        const data = MsgRegisterInterchainAccount.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.controller.v1.Msg", "RegisterInterchainAccount", data);
+        return promise.then((data) => MsgRegisterInterchainAccountResponse.decode(new _m0.Reader(data)));
+    }
+    SendTx(request) {
+        const data = MsgSendTx.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.controller.v1.Msg", "SendTx", data);
+        return promise.then((data) => MsgSendTxResponse.decode(new _m0.Reader(data)));
+    }
+}
+var globalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}