@xpla/xplajs 1.7.0 → 1.8.0-rc.0

package/ibc/core/client/v2/tx.registry.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposer = exports.registry = void 0;
+const tx_1 = require("./tx");
+exports.registry = [["/ibc.core.client.v2.MsgRegisterCounterparty", tx_1.MsgRegisterCounterparty], ["/ibc.core.client.v2.MsgUpdateClientConfig", tx_1.MsgUpdateClientConfig]];
+exports.MessageComposer = {
+    encoded: {
+        registerCounterparty(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgRegisterCounterparty",
+                value: tx_1.MsgRegisterCounterparty.encode(value).finish()
+            };
+        },
+        updateClientConfig(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgUpdateClientConfig",
+                value: tx_1.MsgUpdateClientConfig.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        registerCounterparty(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgRegisterCounterparty",
+                value
+            };
+        },
+        updateClientConfig(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgUpdateClientConfig",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        registerCounterparty(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgRegisterCounterparty",
+                value: tx_1.MsgRegisterCounterparty.fromPartial(value)
+            };
+        },
+        updateClientConfig(value) {
+            return {
+                typeUrl: "/ibc.core.client.v2.MsgUpdateClientConfig",
+                value: tx_1.MsgUpdateClientConfig.fromPartial(value)
+            };
+        }
+    }
+};

package/ibc/core/client/v2/tx.rpc.func.d.ts

@@ -0,0 +1,15 @@
+import { MsgRegisterCounterparty, MsgUpdateClientConfig } from "./tx";
+/**
+ * RegisterCounterparty defines a rpc handler method for MsgRegisterCounterparty.
+ * @name registerCounterparty
+ * @package ibc.core.client.v2
+ * @see proto service: ibc.core.client.v2.RegisterCounterparty
+ */
+export declare const registerCounterparty: (client: import("@interchainjs/cosmos/types/signing-client").ISigningClient, signerAddress: string, message: MsgRegisterCounterparty | MsgRegisterCounterparty[], fee: import("../../../..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+/**
+ * UpdateClientConfig defines a rpc handler method for MsgUpdateClientConfig.
+ * @name updateClientConfig
+ * @package ibc.core.client.v2
+ * @see proto service: ibc.core.client.v2.UpdateClientConfig
+ */
+export declare const updateClientConfig: (client: import("@interchainjs/cosmos/types/signing-client").ISigningClient, signerAddress: string, message: MsgUpdateClientConfig | MsgUpdateClientConfig[], fee: import("../../../..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;

package/ibc/core/client/v2/tx.rpc.func.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateClientConfig = exports.registerCounterparty = void 0;
+const helper_func_types_1 = require("../../../../helper-func-types");
+const tx_1 = require("./tx");
+/**
+ * RegisterCounterparty defines a rpc handler method for MsgRegisterCounterparty.
+ * @name registerCounterparty
+ * @package ibc.core.client.v2
+ * @see proto service: ibc.core.client.v2.RegisterCounterparty
+ */
+exports.registerCounterparty = (0, helper_func_types_1.buildTx)({
+    msg: tx_1.MsgRegisterCounterparty
+});
+/**
+ * UpdateClientConfig defines a rpc handler method for MsgUpdateClientConfig.
+ * @name updateClientConfig
+ * @package ibc.core.client.v2
+ * @see proto service: ibc.core.client.v2.UpdateClientConfig
+ */
+exports.updateClientConfig = (0, helper_func_types_1.buildTx)({
+    msg: tx_1.MsgUpdateClientConfig
+});

package/ibc/core/client/v2/tx.rpc.msg.d.ts

@@ -0,0 +1,16 @@
+import { TxRpc } from "../../../../types";
+import { MsgRegisterCounterparty, MsgRegisterCounterpartyResponse, MsgUpdateClientConfig, MsgUpdateClientConfigResponse } from "./tx";
+/** Msg defines the ibc/client/v2 Msg service. */
+export interface Msg {
+    /** RegisterCounterparty defines a rpc handler method for MsgRegisterCounterparty. */
+    registerCounterparty(request: MsgRegisterCounterparty): Promise<MsgRegisterCounterpartyResponse>;
+    /** UpdateClientConfig defines a rpc handler method for MsgUpdateClientConfig. */
+    updateClientConfig(request: MsgUpdateClientConfig): Promise<MsgUpdateClientConfigResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    registerCounterparty: (request: MsgRegisterCounterparty) => Promise<MsgRegisterCounterpartyResponse>;
+    updateClientConfig: (request: MsgUpdateClientConfig) => Promise<MsgUpdateClientConfigResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/ibc/core/client/v2/tx.rpc.msg.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../../binary");
+const tx_1 = require("./tx");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* RegisterCounterparty defines a rpc handler method for MsgRegisterCounterparty. */
+    registerCounterparty = async (request) => {
+        const data = tx_1.MsgRegisterCounterparty.encode(request).finish();
+        const promise = this.rpc.request("ibc.core.client.v2.Msg", "RegisterCounterparty", data);
+        return promise.then(data => tx_1.MsgRegisterCounterpartyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* UpdateClientConfig defines a rpc handler method for MsgUpdateClientConfig. */
+    updateClientConfig = async (request) => {
+        const data = tx_1.MsgUpdateClientConfig.encode(request).finish();
+        const promise = this.rpc.request("ibc.core.client.v2.Msg", "UpdateClientConfig", data);
+        return promise.then(data => tx_1.MsgUpdateClientConfigResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/ibc/core/commitment/v1/commitment.d.ts

@@ -4,6 +4,9 @@ import { DeepPartial } from "../../../../helpers";
 /**
  * MerkleRoot defines a merkle root hash.
  * In the Cosmos SDK, the AppHash of a block header becomes the root.
+ * @name MerkleRoot
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleRoot
  */
 export interface MerkleRoot {
     hash: Uint8Array;
@@ -15,6 +18,9 @@ export interface MerkleRootProtoMsg {
 /**
  * MerkleRoot defines a merkle root hash.
  * In the Cosmos SDK, the AppHash of a block header becomes the root.
+ * @name MerkleRootAmino
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleRoot
  */
 export interface MerkleRootAmino {
     hash: string;
@@ -27,6 +33,9 @@ export interface MerkleRootAminoMsg {
  * MerklePrefix is merkle path prefixed to the key.
  * The constructed key from the Path and the key will be append(Path.KeyPath,
  * append(Path.KeyPrefix, key...))
+ * @name MerklePrefix
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerklePrefix
  */
 export interface MerklePrefix {
     keyPrefix: Uint8Array;
@@ -39,6 +48,9 @@ export interface MerklePrefixProtoMsg {
  * MerklePrefix is merkle path prefixed to the key.
  * The constructed key from the Path and the key will be append(Path.KeyPath,
  * append(Path.KeyPrefix, key...))
+ * @name MerklePrefixAmino
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerklePrefix
  */
 export interface MerklePrefixAmino {
     key_prefix: string;
@@ -47,36 +59,15 @@ export interface MerklePrefixAminoMsg {
     type: "cosmos-sdk/MerklePrefix";
     value: MerklePrefixAmino;
 }
-/**
- * MerklePath is the path used to verify commitment proofs, which can be an
- * arbitrary structured object (defined by a commitment type).
- * MerklePath is represented from root-to-leaf
- */
-export interface MerklePath {
-    keyPath: string[];
-}
-export interface MerklePathProtoMsg {
-    typeUrl: "/ibc.core.commitment.v1.MerklePath";
-    value: Uint8Array;
-}
-/**
- * MerklePath is the path used to verify commitment proofs, which can be an
- * arbitrary structured object (defined by a commitment type).
- * MerklePath is represented from root-to-leaf
- */
-export interface MerklePathAmino {
-    key_path: string[];
-}
-export interface MerklePathAminoMsg {
-    type: "cosmos-sdk/MerklePath";
-    value: MerklePathAmino;
-}
 /**
  * MerkleProof is a wrapper type over a chain of CommitmentProofs.
  * It demonstrates membership or non-membership for an element or set of
  * elements, verifiable in conjunction with a known commitment root. Proofs
  * should be succinct.
  * MerkleProofs are ordered from leaf-to-root
+ * @name MerkleProof
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleProof
  */
 export interface MerkleProof {
     proofs: CommitmentProof[];
@@ -91,6 +82,9 @@ export interface MerkleProofProtoMsg {
  * elements, verifiable in conjunction with a known commitment root. Proofs
  * should be succinct.
  * MerkleProofs are ordered from leaf-to-root
+ * @name MerkleProofAmino
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleProof
  */
 export interface MerkleProofAmino {
     proofs: CommitmentProofAmino[];
@@ -99,6 +93,13 @@ export interface MerkleProofAminoMsg {
     type: "cosmos-sdk/MerkleProof";
     value: MerkleProofAmino;
 }
+/**
+ * MerkleRoot defines a merkle root hash.
+ * In the Cosmos SDK, the AppHash of a block header becomes the root.
+ * @name MerkleRoot
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleRoot
+ */
 export declare const MerkleRoot: {
     typeUrl: string;
     aminoType: string;
@@ -116,6 +117,14 @@ export declare const MerkleRoot: {
     toProtoMsg(message: MerkleRoot): MerkleRootProtoMsg;
     registerTypeUrl(): void;
 };
+/**
+ * MerklePrefix is merkle path prefixed to the key.
+ * The constructed key from the Path and the key will be append(Path.KeyPath,
+ * append(Path.KeyPrefix, key...))
+ * @name MerklePrefix
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerklePrefix
+ */
 export declare const MerklePrefix: {
     typeUrl: string;
     aminoType: string;
@@ -133,23 +142,16 @@ export declare const MerklePrefix: {
     toProtoMsg(message: MerklePrefix): MerklePrefixProtoMsg;
     registerTypeUrl(): void;
 };
-export declare const MerklePath: {
-    typeUrl: string;
-    aminoType: string;
-    is(o: any): o is MerklePath;
-    isAmino(o: any): o is MerklePathAmino;
-    encode(message: MerklePath, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): MerklePath;
-    fromPartial(object: DeepPartial<MerklePath>): MerklePath;
-    fromAmino(object: MerklePathAmino): MerklePath;
-    toAmino(message: MerklePath): MerklePathAmino;
-    fromAminoMsg(object: MerklePathAminoMsg): MerklePath;
-    toAminoMsg(message: MerklePath): MerklePathAminoMsg;
-    fromProtoMsg(message: MerklePathProtoMsg): MerklePath;
-    toProto(message: MerklePath): Uint8Array;
-    toProtoMsg(message: MerklePath): MerklePathProtoMsg;
-    registerTypeUrl(): void;
-};
+/**
+ * MerkleProof is a wrapper type over a chain of CommitmentProofs.
+ * It demonstrates membership or non-membership for an element or set of
+ * elements, verifiable in conjunction with a known commitment root. Proofs
+ * should be succinct.
+ * MerkleProofs are ordered from leaf-to-root
+ * @name MerkleProof
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleProof
+ */
 export declare const MerkleProof: {
     typeUrl: string;
     aminoType: string;

package/ibc/core/commitment/v1/commitment.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MerkleProof = exports.MerklePath = exports.MerklePrefix = exports.MerkleRoot = void 0;
+exports.MerkleProof = exports.MerklePrefix = exports.MerkleRoot = void 0;
 const proofs_1 = require("../../../../cosmos/ics23/v1/proofs");
 const binary_1 = require("../../../../binary");
 const helpers_1 = require("../../../../helpers");
+const registry_1 = require("../../../../registry");
 function createBaseMerkleRoot() {
     return {
         hash: new Uint8Array()
     };
 }
+/**
+ * MerkleRoot defines a merkle root hash.
+ * In the Cosmos SDK, the AppHash of a block header becomes the root.
+ * @name MerkleRoot
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleRoot
+ */
 exports.MerkleRoot = {
     typeUrl: "/ibc.core.commitment.v1.MerkleRoot",
     aminoType: "cosmos-sdk/MerkleRoot",
@@ -86,6 +94,14 @@ function createBaseMerklePrefix() {
         keyPrefix: new Uint8Array()
     };
 }
+/**
+ * MerklePrefix is merkle path prefixed to the key.
+ * The constructed key from the Path and the key will be append(Path.KeyPath,
+ * append(Path.KeyPrefix, key...))
+ * @name MerklePrefix
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerklePrefix
+ */
 exports.MerklePrefix = {
     typeUrl: "/ibc.core.commitment.v1.MerklePrefix",
     aminoType: "cosmos-sdk/MerklePrefix",
@@ -158,91 +174,21 @@ exports.MerklePrefix = {
     },
     registerTypeUrl() { }
 };
-function createBaseMerklePath() {
-    return {
-        keyPath: []
-    };
-}
-exports.MerklePath = {
-    typeUrl: "/ibc.core.commitment.v1.MerklePath",
-    aminoType: "cosmos-sdk/MerklePath",
-    is(o) {
-        return o && (o.$typeUrl === exports.MerklePath.typeUrl || Array.isArray(o.keyPath) && (!o.keyPath.length || typeof o.keyPath[0] === "string"));
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === exports.MerklePath.typeUrl || Array.isArray(o.key_path) && (!o.key_path.length || typeof o.key_path[0] === "string"));
-    },
-    encode(message, writer = binary_1.BinaryWriter.create()) {
-        for (const v of message.keyPath) {
-            writer.uint32(10).string(v);
-        }
-        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 = createBaseMerklePath();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.keyPath.push(reader.string());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMerklePath();
-        message.keyPath = object.keyPath?.map(e => e) || [];
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMerklePath();
-        message.keyPath = object.key_path?.map(e => e) || [];
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        if (message.keyPath) {
-            obj.key_path = message.keyPath.map(e => e);
-        }
-        else {
-            obj.key_path = message.keyPath;
-        }
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return exports.MerklePath.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MerklePath",
-            value: exports.MerklePath.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return exports.MerklePath.decode(message.value);
-    },
-    toProto(message) {
-        return exports.MerklePath.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/ibc.core.commitment.v1.MerklePath",
-            value: exports.MerklePath.encode(message).finish()
-        };
-    },
-    registerTypeUrl() { }
-};
 function createBaseMerkleProof() {
     return {
         proofs: []
     };
 }
+/**
+ * MerkleProof is a wrapper type over a chain of CommitmentProofs.
+ * It demonstrates membership or non-membership for an element or set of
+ * elements, verifiable in conjunction with a known commitment root. Proofs
+ * should be succinct.
+ * MerkleProofs are ordered from leaf-to-root
+ * @name MerkleProof
+ * @package ibc.core.commitment.v1
+ * @see proto type: ibc.core.commitment.v1.MerkleProof
+ */
 exports.MerkleProof = {
     typeUrl: "/ibc.core.commitment.v1.MerkleProof",
     aminoType: "cosmos-sdk/MerkleProof",
@@ -317,6 +263,9 @@ exports.MerkleProof = {
         };
     },
     registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.MerkleProof.typeUrl)) {
+            return;
+        }
         proofs_1.CommitmentProof.registerTypeUrl();
     }
 };

package/ibc/core/commitment/v2/commitment.d.ts

@@ -0,0 +1,141 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * MerklePath is the path used to verify commitment proofs, which can be an
+ * arbitrary structured object (defined by a commitment type).
+ * ICS-23 verification supports membership proofs for nested merkle trees.
+ * The ICS-24 standard provable keys MUST be stored in the lowest level tree with an optional prefix.
+ * The IC24 provable tree may then be stored in a higher level tree(s) that hash up to the root hash
+ * stored in the consensus state of the client.
+ * Each element of the path represents the key of a merkle tree from the root to the leaf.
+ * The elements of the path before the final element must be the path to the tree that contains
+ * the ICS24 provable store. Thus, it should remain constant for all ICS24 proofs.
+ * The final element of the path is the key of the leaf in the ICS24 provable store,
+ * Thus IBC core will append the ICS24 path to the final element of the MerklePath
+ * stored in the counterparty to create the full path to the leaf for proof verification.
+ * Examples:
+ * Cosmos SDK:
+ * The Cosmos SDK commits to a multi-tree where each store is an IAVL tree and all store hashes
+ * are hashed in a simple merkle tree to get the final root hash. Thus, the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["ibc", ""]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["ibc", "{packetCommitmentPath}"] which will then be used for final verification.
+ * Ethereum:
+ * The Ethereum client commits to a single Patricia merkle trie. The ICS24 provable store is managed
+ * by the smart contract state. Each smart contract has a specific prefix reserved within the global trie.
+ * Thus the MerklePath in the counterparty is the prefix to the smart contract state in the global trie.
+ * Since there is only one tree in the commitment structure of ethereum the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["IBCCoreContractAddressStoragePrefix"]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["IBCCoreContractAddressStoragePrefix{packetCommitmentPath}"] which will then be used for final
+ * verification. Thus the MerklePath in the counterparty MerklePrefix is the nested key path from the root hash of the
+ * consensus state down to the ICS24 provable store. The IBC handler retrieves the counterparty key path to the ICS24
+ * provable store from the MerklePath and appends the ICS24 path to get the final key path to the value being verified
+ * by the client against the root hash in the client's consensus state.
+ * @name MerklePath
+ * @package ibc.core.commitment.v2
+ * @see proto type: ibc.core.commitment.v2.MerklePath
+ */
+export interface MerklePath {
+    keyPath: Uint8Array[];
+}
+export interface MerklePathProtoMsg {
+    typeUrl: "/ibc.core.commitment.v2.MerklePath";
+    value: Uint8Array;
+}
+/**
+ * MerklePath is the path used to verify commitment proofs, which can be an
+ * arbitrary structured object (defined by a commitment type).
+ * ICS-23 verification supports membership proofs for nested merkle trees.
+ * The ICS-24 standard provable keys MUST be stored in the lowest level tree with an optional prefix.
+ * The IC24 provable tree may then be stored in a higher level tree(s) that hash up to the root hash
+ * stored in the consensus state of the client.
+ * Each element of the path represents the key of a merkle tree from the root to the leaf.
+ * The elements of the path before the final element must be the path to the tree that contains
+ * the ICS24 provable store. Thus, it should remain constant for all ICS24 proofs.
+ * The final element of the path is the key of the leaf in the ICS24 provable store,
+ * Thus IBC core will append the ICS24 path to the final element of the MerklePath
+ * stored in the counterparty to create the full path to the leaf for proof verification.
+ * Examples:
+ * Cosmos SDK:
+ * The Cosmos SDK commits to a multi-tree where each store is an IAVL tree and all store hashes
+ * are hashed in a simple merkle tree to get the final root hash. Thus, the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["ibc", ""]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["ibc", "{packetCommitmentPath}"] which will then be used for final verification.
+ * Ethereum:
+ * The Ethereum client commits to a single Patricia merkle trie. The ICS24 provable store is managed
+ * by the smart contract state. Each smart contract has a specific prefix reserved within the global trie.
+ * Thus the MerklePath in the counterparty is the prefix to the smart contract state in the global trie.
+ * Since there is only one tree in the commitment structure of ethereum the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["IBCCoreContractAddressStoragePrefix"]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["IBCCoreContractAddressStoragePrefix{packetCommitmentPath}"] which will then be used for final
+ * verification. Thus the MerklePath in the counterparty MerklePrefix is the nested key path from the root hash of the
+ * consensus state down to the ICS24 provable store. The IBC handler retrieves the counterparty key path to the ICS24
+ * provable store from the MerklePath and appends the ICS24 path to get the final key path to the value being verified
+ * by the client against the root hash in the client's consensus state.
+ * @name MerklePathAmino
+ * @package ibc.core.commitment.v2
+ * @see proto type: ibc.core.commitment.v2.MerklePath
+ */
+export interface MerklePathAmino {
+    key_path: string[];
+}
+export interface MerklePathAminoMsg {
+    type: "cosmos-sdk/MerklePath";
+    value: MerklePathAmino;
+}
+/**
+ * MerklePath is the path used to verify commitment proofs, which can be an
+ * arbitrary structured object (defined by a commitment type).
+ * ICS-23 verification supports membership proofs for nested merkle trees.
+ * The ICS-24 standard provable keys MUST be stored in the lowest level tree with an optional prefix.
+ * The IC24 provable tree may then be stored in a higher level tree(s) that hash up to the root hash
+ * stored in the consensus state of the client.
+ * Each element of the path represents the key of a merkle tree from the root to the leaf.
+ * The elements of the path before the final element must be the path to the tree that contains
+ * the ICS24 provable store. Thus, it should remain constant for all ICS24 proofs.
+ * The final element of the path is the key of the leaf in the ICS24 provable store,
+ * Thus IBC core will append the ICS24 path to the final element of the MerklePath
+ * stored in the counterparty to create the full path to the leaf for proof verification.
+ * Examples:
+ * Cosmos SDK:
+ * The Cosmos SDK commits to a multi-tree where each store is an IAVL tree and all store hashes
+ * are hashed in a simple merkle tree to get the final root hash. Thus, the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["ibc", ""]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["ibc", "{packetCommitmentPath}"] which will then be used for final verification.
+ * Ethereum:
+ * The Ethereum client commits to a single Patricia merkle trie. The ICS24 provable store is managed
+ * by the smart contract state. Each smart contract has a specific prefix reserved within the global trie.
+ * Thus the MerklePath in the counterparty is the prefix to the smart contract state in the global trie.
+ * Since there is only one tree in the commitment structure of ethereum the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["IBCCoreContractAddressStoragePrefix"]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["IBCCoreContractAddressStoragePrefix{packetCommitmentPath}"] which will then be used for final
+ * verification. Thus the MerklePath in the counterparty MerklePrefix is the nested key path from the root hash of the
+ * consensus state down to the ICS24 provable store. The IBC handler retrieves the counterparty key path to the ICS24
+ * provable store from the MerklePath and appends the ICS24 path to get the final key path to the value being verified
+ * by the client against the root hash in the client's consensus state.
+ * @name MerklePath
+ * @package ibc.core.commitment.v2
+ * @see proto type: ibc.core.commitment.v2.MerklePath
+ */
+export declare const MerklePath: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MerklePath;
+    isAmino(o: any): o is MerklePathAmino;
+    encode(message: MerklePath, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MerklePath;
+    fromPartial(object: DeepPartial<MerklePath>): MerklePath;
+    fromAmino(object: MerklePathAmino): MerklePath;
+    toAmino(message: MerklePath): MerklePathAmino;
+    fromAminoMsg(object: MerklePathAminoMsg): MerklePath;
+    toAminoMsg(message: MerklePath): MerklePathAminoMsg;
+    fromProtoMsg(message: MerklePathProtoMsg): MerklePath;
+    toProto(message: MerklePath): Uint8Array;
+    toProtoMsg(message: MerklePath): MerklePathProtoMsg;
+    registerTypeUrl(): void;
+};