@xpla/xpla-react 1.7.0 → 1.8.0-rc.0

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;
+};

package/ibc/core/commitment/v2/commitment.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerklePath = void 0;
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+function createBaseMerklePath() {
+    return {
+        keyPath: []
+    };
+}
+/**
+ * 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
+ */
+exports.MerklePath = {
+    typeUrl: "/ibc.core.commitment.v2.MerklePath",
+    aminoType: "cosmos-sdk/MerklePath",
+    is(o) {
+        return o && (o.$typeUrl === exports.MerklePath.typeUrl || Array.isArray(o.keyPath) && (!o.keyPath.length || o.keyPath[0] instanceof Uint8Array || typeof o.keyPath[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.MerklePath.typeUrl || Array.isArray(o.key_path) && (!o.key_path.length || o.key_path[0] instanceof Uint8Array || typeof o.key_path[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.keyPath) {
+            writer.uint32(10).bytes(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.bytes());
+                    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 => (0, helpers_1.bytesFromBase64)(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.keyPath) {
+            obj.key_path = message.keyPath.map(e => (0, helpers_1.base64FromBytes)(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.v2.MerklePath",
+            value: exports.MerklePath.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};