@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.10

package/ibc/core/connection/v1/tx.registry.d.ts

@@ -0,0 +1,71 @@
+import { TelescopeGeneratedType } from "../../../../types";
+import { MsgConnectionOpenInit, MsgConnectionOpenTry, MsgConnectionOpenAck, MsgConnectionOpenConfirm, MsgUpdateParams } from "./tx";
+export declare const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]>;
+export declare const MessageComposer: {
+    encoded: {
+        connectionOpenInit(value: MsgConnectionOpenInit): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+        connectionOpenTry(value: MsgConnectionOpenTry): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+        connectionOpenAck(value: MsgConnectionOpenAck): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+        connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+        updateConnectionParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    };
+    withTypeUrl: {
+        connectionOpenInit(value: MsgConnectionOpenInit): {
+            typeUrl: string;
+            value: MsgConnectionOpenInit;
+        };
+        connectionOpenTry(value: MsgConnectionOpenTry): {
+            typeUrl: string;
+            value: MsgConnectionOpenTry;
+        };
+        connectionOpenAck(value: MsgConnectionOpenAck): {
+            typeUrl: string;
+            value: MsgConnectionOpenAck;
+        };
+        connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
+            typeUrl: string;
+            value: MsgConnectionOpenConfirm;
+        };
+        updateConnectionParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: MsgUpdateParams;
+        };
+    };
+    fromPartial: {
+        connectionOpenInit(value: MsgConnectionOpenInit): {
+            typeUrl: string;
+            value: MsgConnectionOpenInit;
+        };
+        connectionOpenTry(value: MsgConnectionOpenTry): {
+            typeUrl: string;
+            value: MsgConnectionOpenTry;
+        };
+        connectionOpenAck(value: MsgConnectionOpenAck): {
+            typeUrl: string;
+            value: MsgConnectionOpenAck;
+        };
+        connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
+            typeUrl: string;
+            value: MsgConnectionOpenConfirm;
+        };
+        updateConnectionParams(value: MsgUpdateParams): {
+            typeUrl: string;
+            value: MsgUpdateParams;
+        };
+    };
+};

package/ibc/core/connection/v1/tx.registry.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposer = exports.registry = void 0;
+const tx_1 = require("./tx");
+exports.registry = [["/ibc.core.connection.v1.MsgConnectionOpenInit", tx_1.MsgConnectionOpenInit], ["/ibc.core.connection.v1.MsgConnectionOpenTry", tx_1.MsgConnectionOpenTry], ["/ibc.core.connection.v1.MsgConnectionOpenAck", tx_1.MsgConnectionOpenAck], ["/ibc.core.connection.v1.MsgConnectionOpenConfirm", tx_1.MsgConnectionOpenConfirm], ["/ibc.core.connection.v1.MsgUpdateParams", tx_1.MsgUpdateParams]];
+exports.MessageComposer = {
+    encoded: {
+        connectionOpenInit(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInit",
+                value: tx_1.MsgConnectionOpenInit.encode(value).finish()
+            };
+        },
+        connectionOpenTry(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTry",
+                value: tx_1.MsgConnectionOpenTry.encode(value).finish()
+            };
+        },
+        connectionOpenAck(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAck",
+                value: tx_1.MsgConnectionOpenAck.encode(value).finish()
+            };
+        },
+        connectionOpenConfirm(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirm",
+                value: tx_1.MsgConnectionOpenConfirm.encode(value).finish()
+            };
+        },
+        updateConnectionParams(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgUpdateParams",
+                value: tx_1.MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        connectionOpenInit(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInit",
+                value
+            };
+        },
+        connectionOpenTry(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTry",
+                value
+            };
+        },
+        connectionOpenAck(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAck",
+                value
+            };
+        },
+        connectionOpenConfirm(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirm",
+                value
+            };
+        },
+        updateConnectionParams(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        connectionOpenInit(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInit",
+                value: tx_1.MsgConnectionOpenInit.fromPartial(value)
+            };
+        },
+        connectionOpenTry(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTry",
+                value: tx_1.MsgConnectionOpenTry.fromPartial(value)
+            };
+        },
+        connectionOpenAck(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAck",
+                value: tx_1.MsgConnectionOpenAck.fromPartial(value)
+            };
+        },
+        connectionOpenConfirm(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirm",
+                value: tx_1.MsgConnectionOpenConfirm.fromPartial(value)
+            };
+        },
+        updateConnectionParams(value) {
+            return {
+                typeUrl: "/ibc.core.connection.v1.MsgUpdateParams",
+                value: tx_1.MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

package/ibc/core/connection/v1/tx.rpc.func.d.ts

@@ -0,0 +1,12 @@
+import { SigningClientResolver } from "../../../../helper-func-types";
+import { MsgConnectionOpenInit, MsgConnectionOpenTry, MsgConnectionOpenAck, MsgConnectionOpenConfirm, MsgUpdateParams } from "./tx";
+export declare const createConnectionOpenInit: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgConnectionOpenInit, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const useConnectionOpenInit: ({ options, clientResolver }: import("../../../../react-query").ReactMutationParams<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenInit>, unknown>) => import("@tanstack/react-query").UseMutationResult<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenInit>, unknown>;
+export declare const createConnectionOpenTry: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgConnectionOpenTry, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const useConnectionOpenTry: ({ options, clientResolver }: import("../../../../react-query").ReactMutationParams<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenTry>, unknown>) => import("@tanstack/react-query").UseMutationResult<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenTry>, unknown>;
+export declare const createConnectionOpenAck: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgConnectionOpenAck, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const useConnectionOpenAck: ({ options, clientResolver }: import("../../../../react-query").ReactMutationParams<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenAck>, unknown>) => import("@tanstack/react-query").UseMutationResult<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenAck>, unknown>;
+export declare const createConnectionOpenConfirm: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgConnectionOpenConfirm, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const useConnectionOpenConfirm: ({ options, clientResolver }: import("../../../../react-query").ReactMutationParams<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenConfirm>, unknown>) => import("@tanstack/react-query").UseMutationResult<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgConnectionOpenConfirm>, unknown>;
+export declare const createUpdateConnectionParams: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgUpdateParams, fee: import("../../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../../helper-func-types").DeliverTxResponse>;
+export declare const useUpdateConnectionParams: ({ options, clientResolver }: import("../../../../react-query").ReactMutationParams<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgUpdateParams>, unknown>) => import("@tanstack/react-query").UseMutationResult<import("../../../../helper-func-types").DeliverTxResponse, Error, import("../../../../helper-func-types").ITxArgs<MsgUpdateParams>, unknown>;

package/ibc/core/connection/v1/tx.rpc.func.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUpdateConnectionParams = exports.createUpdateConnectionParams = exports.useConnectionOpenConfirm = exports.createConnectionOpenConfirm = exports.useConnectionOpenAck = exports.createConnectionOpenAck = exports.useConnectionOpenTry = exports.createConnectionOpenTry = exports.useConnectionOpenInit = exports.createConnectionOpenInit = void 0;
+const helper_func_types_1 = require("../../../../helper-func-types");
+const react_query_1 = require("../../../../react-query");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createConnectionOpenInit = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgConnectionOpenInit.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgConnectionOpenInit),
+    converters: (0, utils_1.toConverters)(tx_1.MsgConnectionOpenInit)
+});
+exports.createConnectionOpenInit = createConnectionOpenInit;
+exports.useConnectionOpenInit = (0, react_query_1.buildUseMutation)({
+    builderMutationFn: exports.createConnectionOpenInit
+});
+const createConnectionOpenTry = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgConnectionOpenTry.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgConnectionOpenTry),
+    converters: (0, utils_1.toConverters)(tx_1.MsgConnectionOpenTry)
+});
+exports.createConnectionOpenTry = createConnectionOpenTry;
+exports.useConnectionOpenTry = (0, react_query_1.buildUseMutation)({
+    builderMutationFn: exports.createConnectionOpenTry
+});
+const createConnectionOpenAck = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgConnectionOpenAck.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgConnectionOpenAck),
+    converters: (0, utils_1.toConverters)(tx_1.MsgConnectionOpenAck)
+});
+exports.createConnectionOpenAck = createConnectionOpenAck;
+exports.useConnectionOpenAck = (0, react_query_1.buildUseMutation)({
+    builderMutationFn: exports.createConnectionOpenAck
+});
+const createConnectionOpenConfirm = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgConnectionOpenConfirm.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgConnectionOpenConfirm),
+    converters: (0, utils_1.toConverters)(tx_1.MsgConnectionOpenConfirm)
+});
+exports.createConnectionOpenConfirm = createConnectionOpenConfirm;
+exports.useConnectionOpenConfirm = (0, react_query_1.buildUseMutation)({
+    builderMutationFn: exports.createConnectionOpenConfirm
+});
+const createUpdateConnectionParams = (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.createUpdateConnectionParams = createUpdateConnectionParams;
+exports.useUpdateConnectionParams = (0, react_query_1.buildUseMutation)({
+    builderMutationFn: exports.createUpdateConnectionParams
+});

package/ibc/core/types/v1/genesis.d.ts

@@ -0,0 +1,50 @@
+import { GenesisState as GenesisState1 } from "../../client/v1/genesis";
+import { GenesisStateAmino as GenesisState1Amino } from "../../client/v1/genesis";
+import { GenesisState as GenesisState2 } from "../../connection/v1/genesis";
+import { GenesisStateAmino as GenesisState2Amino } from "../../connection/v1/genesis";
+import { GenesisState as GenesisState3 } from "../../channel/v1/genesis";
+import { GenesisStateAmino as GenesisState3Amino } from "../../channel/v1/genesis";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** GenesisState defines the ibc module's genesis state. */
+export interface GenesisState {
+    /** ICS002 - Clients genesis state */
+    clientGenesis: GenesisState1;
+    /** ICS003 - Connections genesis state */
+    connectionGenesis: GenesisState2;
+    /** ICS004 - Channel genesis state */
+    channelGenesis: GenesisState3;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/ibc.core.types.v1.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the ibc module's genesis state. */
+export interface GenesisStateAmino {
+    /** ICS002 - Clients genesis state */
+    client_genesis: GenesisState1Amino;
+    /** ICS003 - Connections genesis state */
+    connection_genesis: GenesisState2Amino;
+    /** ICS004 - Channel genesis state */
+    channel_genesis: GenesisState3Amino;
+}
+export interface GenesisStateAminoMsg {
+    type: "cosmos-sdk/GenesisState";
+    value: GenesisStateAmino;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/ibc/core/types/v1/genesis.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+const genesis_1 = require("../../client/v1/genesis");
+const genesis_2 = require("../../connection/v1/genesis");
+const genesis_3 = require("../../channel/v1/genesis");
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+function createBaseGenesisState() {
+    return {
+        clientGenesis: genesis_1.GenesisState.fromPartial({}),
+        connectionGenesis: genesis_2.GenesisState.fromPartial({}),
+        channelGenesis: genesis_3.GenesisState.fromPartial({})
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/ibc.core.types.v1.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || genesis_1.GenesisState.is(o.clientGenesis) && genesis_2.GenesisState.is(o.connectionGenesis) && genesis_3.GenesisState.is(o.channelGenesis));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || genesis_1.GenesisState.isAmino(o.client_genesis) && genesis_2.GenesisState.isAmino(o.connection_genesis) && genesis_3.GenesisState.isAmino(o.channel_genesis));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.clientGenesis !== undefined) {
+            genesis_1.GenesisState.encode(message.clientGenesis, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.connectionGenesis !== undefined) {
+            genesis_2.GenesisState.encode(message.connectionGenesis, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.channelGenesis !== undefined) {
+            genesis_3.GenesisState.encode(message.channelGenesis, writer.uint32(26).fork()).ldelim();
+        }
+        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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.clientGenesis = genesis_1.GenesisState.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.connectionGenesis = genesis_2.GenesisState.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.channelGenesis = genesis_3.GenesisState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.clientGenesis = object.clientGenesis !== undefined && object.clientGenesis !== null ? genesis_1.GenesisState.fromPartial(object.clientGenesis) : undefined;
+        message.connectionGenesis = object.connectionGenesis !== undefined && object.connectionGenesis !== null ? genesis_2.GenesisState.fromPartial(object.connectionGenesis) : undefined;
+        message.channelGenesis = object.channelGenesis !== undefined && object.channelGenesis !== null ? genesis_3.GenesisState.fromPartial(object.channelGenesis) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.client_genesis !== undefined && object.client_genesis !== null) {
+            message.clientGenesis = genesis_1.GenesisState.fromAmino(object.client_genesis);
+        }
+        if (object.connection_genesis !== undefined && object.connection_genesis !== null) {
+            message.connectionGenesis = genesis_2.GenesisState.fromAmino(object.connection_genesis);
+        }
+        if (object.channel_genesis !== undefined && object.channel_genesis !== null) {
+            message.channelGenesis = genesis_3.GenesisState.fromAmino(object.channel_genesis);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.client_genesis = message.clientGenesis ? genesis_1.GenesisState.toAmino(message.clientGenesis) : undefined;
+        obj.connection_genesis = message.connectionGenesis ? genesis_2.GenesisState.toAmino(message.connectionGenesis) : undefined;
+        obj.channel_genesis = message.channelGenesis ? genesis_3.GenesisState.toAmino(message.channelGenesis) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: exports.GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.types.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.GenesisState.aminoType, exports.GenesisState.typeUrl);

package/ibc/lightclients/localhost/v2/localhost.d.ts

@@ -0,0 +1,37 @@
+import { Height, HeightAmino } from "../../../core/client/v1/client";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** ClientState defines the 09-localhost client state */
+export interface ClientState {
+    /** the latest block height */
+    latestHeight: Height;
+}
+export interface ClientStateProtoMsg {
+    typeUrl: "/ibc.lightclients.localhost.v2.ClientState";
+    value: Uint8Array;
+}
+/** ClientState defines the 09-localhost client state */
+export interface ClientStateAmino {
+    /** the latest block height */
+    latest_height: HeightAmino;
+}
+export interface ClientStateAminoMsg {
+    type: "cosmos-sdk/ClientState";
+    value: ClientStateAmino;
+}
+export declare const ClientState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is ClientState;
+    isAmino(o: any): o is ClientStateAmino;
+    encode(message: ClientState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ClientState;
+    fromPartial(object: DeepPartial<ClientState>): ClientState;
+    fromAmino(object: ClientStateAmino): ClientState;
+    toAmino(message: ClientState): ClientStateAmino;
+    fromAminoMsg(object: ClientStateAminoMsg): ClientState;
+    toAminoMsg(message: ClientState): ClientStateAminoMsg;
+    fromProtoMsg(message: ClientStateProtoMsg): ClientState;
+    toProto(message: ClientState): Uint8Array;
+    toProtoMsg(message: ClientState): ClientStateProtoMsg;
+};

package/ibc/lightclients/localhost/v2/localhost.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientState = void 0;
+const client_1 = require("../../../core/client/v1/client");
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+function createBaseClientState() {
+    return {
+        latestHeight: client_1.Height.fromPartial({})
+    };
+}
+exports.ClientState = {
+    typeUrl: "/ibc.lightclients.localhost.v2.ClientState",
+    aminoType: "cosmos-sdk/ClientState",
+    is(o) {
+        return o && (o.$typeUrl === exports.ClientState.typeUrl || client_1.Height.is(o.latestHeight));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.ClientState.typeUrl || client_1.Height.isAmino(o.latest_height));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.latestHeight !== undefined) {
+            client_1.Height.encode(message.latestHeight, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseClientState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.latestHeight = client_1.Height.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseClientState();
+        message.latestHeight = object.latestHeight !== undefined && object.latestHeight !== null ? client_1.Height.fromPartial(object.latestHeight) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseClientState();
+        if (object.latest_height !== undefined && object.latest_height !== null) {
+            message.latestHeight = client_1.Height.fromAmino(object.latest_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.latest_height = message.latestHeight ? client_1.Height.toAmino(message.latestHeight) : {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ClientState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ClientState",
+            value: exports.ClientState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.ClientState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ClientState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.lightclients.localhost.v2.ClientState",
+            value: exports.ClientState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.ClientState.typeUrl, exports.ClientState);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.ClientState.aminoType, exports.ClientState.typeUrl);