@xpla/xplajs 1.7.0-beta.3 → 1.7.0-beta.4

package/dist/esm/ibc/applications/interchain_accounts/host/v1/tx.js

@@ -0,0 +1,345 @@
+import { Params, QueryRequest } from "./host";
+import { BinaryReader, BinaryWriter } from "../../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../../registry";
+function createBaseMsgUpdateParams() {
+    return {
+        signer: "",
+        params: Params.fromPartial({})
+    };
+}
+export const MsgUpdateParams = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams",
+    aminoType: "cosmos-sdk/MsgUpdateParams",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.signer === "string" && Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.signer === "string" && Params.isAmino(o.params));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.signer = object.signer ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse",
+    aminoType: "cosmos-sdk/MsgUpdateParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);
+function createBaseMsgModuleQuerySafe() {
+    return {
+        signer: "",
+        requests: []
+    };
+}
+export const MsgModuleQuerySafe = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe",
+    aminoType: "cosmos-sdk/MsgModuleQuerySafe",
+    is(o) {
+        return o && (o.$typeUrl === MsgModuleQuerySafe.typeUrl || typeof o.signer === "string" && Array.isArray(o.requests) && (!o.requests.length || QueryRequest.is(o.requests[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgModuleQuerySafe.typeUrl || typeof o.signer === "string" && Array.isArray(o.requests) && (!o.requests.length || QueryRequest.isAmino(o.requests[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        for (const v of message.requests) {
+            QueryRequest.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgModuleQuerySafe();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.requests.push(QueryRequest.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgModuleQuerySafe();
+        message.signer = object.signer ?? "";
+        message.requests = object.requests?.map(e => QueryRequest.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgModuleQuerySafe();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        message.requests = object.requests?.map(e => QueryRequest.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        if (message.requests) {
+            obj.requests = message.requests.map(e => e ? QueryRequest.toAmino(e) : undefined);
+        }
+        else {
+            obj.requests = message.requests;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgModuleQuerySafe.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgModuleQuerySafe",
+            value: MsgModuleQuerySafe.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgModuleQuerySafe.decode(message.value);
+    },
+    toProto(message) {
+        return MsgModuleQuerySafe.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe",
+            value: MsgModuleQuerySafe.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgModuleQuerySafe.typeUrl, MsgModuleQuerySafe);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgModuleQuerySafe.aminoType, MsgModuleQuerySafe.typeUrl);
+function createBaseMsgModuleQuerySafeResponse() {
+    return {
+        height: BigInt(0),
+        responses: []
+    };
+}
+export const MsgModuleQuerySafeResponse = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse",
+    aminoType: "cosmos-sdk/MsgModuleQuerySafeResponse",
+    is(o) {
+        return o && (o.$typeUrl === MsgModuleQuerySafeResponse.typeUrl || typeof o.height === "bigint" && Array.isArray(o.responses) && (!o.responses.length || o.responses[0] instanceof Uint8Array || typeof o.responses[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgModuleQuerySafeResponse.typeUrl || typeof o.height === "bigint" && Array.isArray(o.responses) && (!o.responses.length || o.responses[0] instanceof Uint8Array || typeof o.responses[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.height !== BigInt(0)) {
+            writer.uint32(8).uint64(message.height);
+        }
+        for (const v of message.responses) {
+            writer.uint32(18).bytes(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgModuleQuerySafeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.height = reader.uint64();
+                    break;
+                case 2:
+                    message.responses.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgModuleQuerySafeResponse();
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.responses = object.responses?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgModuleQuerySafeResponse();
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        message.responses = object.responses?.map(e => bytesFromBase64(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        if (message.responses) {
+            obj.responses = message.responses.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.responses = message.responses;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgModuleQuerySafeResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgModuleQuerySafeResponse",
+            value: MsgModuleQuerySafeResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgModuleQuerySafeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgModuleQuerySafeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse",
+            value: MsgModuleQuerySafeResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgModuleQuerySafeResponse.typeUrl, MsgModuleQuerySafeResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgModuleQuerySafeResponse.aminoType, MsgModuleQuerySafeResponse.typeUrl);

package/dist/esm/ibc/applications/interchain_accounts/host/v1/tx.registry.js

@@ -0,0 +1,2 @@
+import { MsgUpdateParams, MsgModuleQuerySafe } from "./tx";
+export const registry = [["/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams", MsgUpdateParams], ["/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe", MsgModuleQuerySafe]];

package/dist/esm/ibc/applications/interchain_accounts/host/v1/tx.rpc.func.js

@@ -0,0 +1,15 @@
+import { buildTx } from "../../../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgUpdateParams, MsgModuleQuerySafe } from "./tx";
+export const createUpdateParams = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgUpdateParams.typeUrl,
+    encoders: toEncoders(MsgUpdateParams),
+    converters: toConverters(MsgUpdateParams)
+});
+export const createModuleQuerySafe = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgModuleQuerySafe.typeUrl,
+    encoders: toEncoders(MsgModuleQuerySafe),
+    converters: toConverters(MsgModuleQuerySafe)
+});

package/dist/esm/ibc/applications/interchain_accounts/host/v1/tx.rpc.msg.js

@@ -0,0 +1,23 @@
+import { BinaryReader } from "../../../../../binary";
+import { MsgUpdateParams, MsgUpdateParamsResponse, MsgModuleQuerySafe, MsgModuleQuerySafeResponse } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* UpdateParams defines a rpc handler for MsgUpdateParams. */
+    updateParams = async (request) => {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.host.v1.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+    };
+    /* ModuleQuerySafe defines a rpc handler for MsgModuleQuerySafe. */
+    moduleQuerySafe = async (request) => {
+        const data = MsgModuleQuerySafe.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.host.v1.Msg", "ModuleQuerySafe", data);
+        return promise.then(data => MsgModuleQuerySafeResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/dist/esm/ibc/applications/interchain_accounts/v1/account.js

@@ -0,0 +1,93 @@
+import { BaseAccount } from "../../../../cosmos/auth/v1beta1/auth";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBaseInterchainAccount() {
+    return {
+        baseAccount: undefined,
+        accountOwner: ""
+    };
+}
+export const InterchainAccount = {
+    typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccount",
+    aminoType: "cosmos-sdk/InterchainAccount",
+    is(o) {
+        return o && (o.$typeUrl === InterchainAccount.typeUrl || typeof o.accountOwner === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === InterchainAccount.typeUrl || typeof o.account_owner === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.baseAccount !== undefined) {
+            BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.accountOwner !== "") {
+            writer.uint32(18).string(message.accountOwner);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInterchainAccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.baseAccount = BaseAccount.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.accountOwner = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseInterchainAccount();
+        message.baseAccount = object.baseAccount !== undefined && object.baseAccount !== null ? BaseAccount.fromPartial(object.baseAccount) : undefined;
+        message.accountOwner = object.accountOwner ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseInterchainAccount();
+        if (object.base_account !== undefined && object.base_account !== null) {
+            message.baseAccount = BaseAccount.fromAmino(object.base_account);
+        }
+        if (object.account_owner !== undefined && object.account_owner !== null) {
+            message.accountOwner = object.account_owner;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.base_account = message.baseAccount ? BaseAccount.toAmino(message.baseAccount) : undefined;
+        obj.account_owner = message.accountOwner === "" ? undefined : message.accountOwner;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return InterchainAccount.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/InterchainAccount",
+            value: InterchainAccount.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return InterchainAccount.decode(message.value);
+    },
+    toProto(message) {
+        return InterchainAccount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccount",
+            value: InterchainAccount.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(InterchainAccount.typeUrl, InterchainAccount);
+GlobalDecoderRegistry.registerAminoProtoMapping(InterchainAccount.aminoType, InterchainAccount.typeUrl);

package/dist/esm/ibc/applications/interchain_accounts/v1/metadata.js

@@ -0,0 +1,140 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBaseMetadata() {
+    return {
+        version: "",
+        controllerConnectionId: "",
+        hostConnectionId: "",
+        address: "",
+        encoding: "",
+        txType: ""
+    };
+}
+export const Metadata = {
+    typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata",
+    aminoType: "cosmos-sdk/Metadata",
+    is(o) {
+        return o && (o.$typeUrl === Metadata.typeUrl || typeof o.version === "string" && typeof o.controllerConnectionId === "string" && typeof o.hostConnectionId === "string" && typeof o.address === "string" && typeof o.encoding === "string" && typeof o.txType === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Metadata.typeUrl || typeof o.version === "string" && typeof o.controller_connection_id === "string" && typeof o.host_connection_id === "string" && typeof o.address === "string" && typeof o.encoding === "string" && typeof o.tx_type === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        if (message.controllerConnectionId !== "") {
+            writer.uint32(18).string(message.controllerConnectionId);
+        }
+        if (message.hostConnectionId !== "") {
+            writer.uint32(26).string(message.hostConnectionId);
+        }
+        if (message.address !== "") {
+            writer.uint32(34).string(message.address);
+        }
+        if (message.encoding !== "") {
+            writer.uint32(42).string(message.encoding);
+        }
+        if (message.txType !== "") {
+            writer.uint32(50).string(message.txType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.version = reader.string();
+                    break;
+                case 2:
+                    message.controllerConnectionId = reader.string();
+                    break;
+                case 3:
+                    message.hostConnectionId = reader.string();
+                    break;
+                case 4:
+                    message.address = reader.string();
+                    break;
+                case 5:
+                    message.encoding = reader.string();
+                    break;
+                case 6:
+                    message.txType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMetadata();
+        message.version = object.version ?? "";
+        message.controllerConnectionId = object.controllerConnectionId ?? "";
+        message.hostConnectionId = object.hostConnectionId ?? "";
+        message.address = object.address ?? "";
+        message.encoding = object.encoding ?? "";
+        message.txType = object.txType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMetadata();
+        if (object.version !== undefined && object.version !== null) {
+            message.version = object.version;
+        }
+        if (object.controller_connection_id !== undefined && object.controller_connection_id !== null) {
+            message.controllerConnectionId = object.controller_connection_id;
+        }
+        if (object.host_connection_id !== undefined && object.host_connection_id !== null) {
+            message.hostConnectionId = object.host_connection_id;
+        }
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.encoding !== undefined && object.encoding !== null) {
+            message.encoding = object.encoding;
+        }
+        if (object.tx_type !== undefined && object.tx_type !== null) {
+            message.txType = object.tx_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.version = message.version === "" ? undefined : message.version;
+        obj.controller_connection_id = message.controllerConnectionId === "" ? undefined : message.controllerConnectionId;
+        obj.host_connection_id = message.hostConnectionId === "" ? undefined : message.hostConnectionId;
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.encoding = message.encoding === "" ? undefined : message.encoding;
+        obj.tx_type = message.txType === "" ? undefined : message.txType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Metadata.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Metadata",
+            value: Metadata.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Metadata.decode(message.value);
+    },
+    toProto(message) {
+        return Metadata.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata",
+            value: Metadata.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Metadata.typeUrl, Metadata);
+GlobalDecoderRegistry.registerAminoProtoMapping(Metadata.aminoType, Metadata.typeUrl);