@xpla/xplajs 1.8.2 → 1.9.0

package/dist/cosmos/ics23/v1/proofs.js

@@ -0,0 +1,1520 @@
+import { BinaryReader, BinaryWriter } from "../../../binary.js";
+import { base64FromBytes, bytesFromBase64, isSet } from "../../../helpers.js";
+import { GlobalDecoderRegistry } from "../../../registry.js";
+
+//#region src/cosmos/ics23/v1/proofs.ts
+let HashOp = /* @__PURE__ */ function(HashOp) {
+	/** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
+	HashOp[HashOp["NO_HASH"] = 0] = "NO_HASH";
+	HashOp[HashOp["SHA256"] = 1] = "SHA256";
+	HashOp[HashOp["SHA512"] = 2] = "SHA512";
+	HashOp[HashOp["KECCAK256"] = 3] = "KECCAK256";
+	HashOp[HashOp["RIPEMD160"] = 4] = "RIPEMD160";
+	/** BITCOIN - ripemd160(sha256(x)) */
+	HashOp[HashOp["BITCOIN"] = 5] = "BITCOIN";
+	HashOp[HashOp["SHA512_256"] = 6] = "SHA512_256";
+	HashOp[HashOp["BLAKE2B_512"] = 7] = "BLAKE2B_512";
+	HashOp[HashOp["BLAKE2S_256"] = 8] = "BLAKE2S_256";
+	HashOp[HashOp["BLAKE3"] = 9] = "BLAKE3";
+	HashOp[HashOp["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return HashOp;
+}({});
+const HashOpAmino = HashOp;
+function hashOpFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NO_HASH": return HashOp.NO_HASH;
+		case 1:
+		case "SHA256": return HashOp.SHA256;
+		case 2:
+		case "SHA512": return HashOp.SHA512;
+		case 3:
+		case "KECCAK256": return HashOp.KECCAK256;
+		case 4:
+		case "RIPEMD160": return HashOp.RIPEMD160;
+		case 5:
+		case "BITCOIN": return HashOp.BITCOIN;
+		case 6:
+		case "SHA512_256": return HashOp.SHA512_256;
+		case 7:
+		case "BLAKE2B_512": return HashOp.BLAKE2B_512;
+		case 8:
+		case "BLAKE2S_256": return HashOp.BLAKE2S_256;
+		case 9:
+		case "BLAKE3": return HashOp.BLAKE3;
+		default: return HashOp.UNRECOGNIZED;
+	}
+}
+function hashOpToJSON(object) {
+	switch (object) {
+		case HashOp.NO_HASH: return "NO_HASH";
+		case HashOp.SHA256: return "SHA256";
+		case HashOp.SHA512: return "SHA512";
+		case HashOp.KECCAK256: return "KECCAK256";
+		case HashOp.RIPEMD160: return "RIPEMD160";
+		case HashOp.BITCOIN: return "BITCOIN";
+		case HashOp.SHA512_256: return "SHA512_256";
+		case HashOp.BLAKE2B_512: return "BLAKE2B_512";
+		case HashOp.BLAKE2S_256: return "BLAKE2S_256";
+		case HashOp.BLAKE3: return "BLAKE3";
+		case HashOp.UNRECOGNIZED:
+		default: return "UNRECOGNIZED";
+	}
+}
+/**
+* LengthOp defines how to process the key and value of the LeafOp
+* to include length information. After encoding the length with the given
+* algorithm, the length will be prepended to the key and value bytes.
+* (Each one with it's own encoded length)
+*/
+let LengthOp = /* @__PURE__ */ function(LengthOp) {
+	/** NO_PREFIX - NO_PREFIX don't include any length info */
+	LengthOp[LengthOp["NO_PREFIX"] = 0] = "NO_PREFIX";
+	/** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length */
+	LengthOp[LengthOp["VAR_PROTO"] = 1] = "VAR_PROTO";
+	/** VAR_RLP - VAR_RLP uses rlp int encoding of the length */
+	LengthOp[LengthOp["VAR_RLP"] = 2] = "VAR_RLP";
+	/** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer */
+	LengthOp[LengthOp["FIXED32_BIG"] = 3] = "FIXED32_BIG";
+	/** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer */
+	LengthOp[LengthOp["FIXED32_LITTLE"] = 4] = "FIXED32_LITTLE";
+	/** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer */
+	LengthOp[LengthOp["FIXED64_BIG"] = 5] = "FIXED64_BIG";
+	/** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer */
+	LengthOp[LengthOp["FIXED64_LITTLE"] = 6] = "FIXED64_LITTLE";
+	/** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) */
+	LengthOp[LengthOp["REQUIRE_32_BYTES"] = 7] = "REQUIRE_32_BYTES";
+	/** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) */
+	LengthOp[LengthOp["REQUIRE_64_BYTES"] = 8] = "REQUIRE_64_BYTES";
+	LengthOp[LengthOp["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return LengthOp;
+}({});
+const LengthOpAmino = LengthOp;
+function lengthOpFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "NO_PREFIX": return LengthOp.NO_PREFIX;
+		case 1:
+		case "VAR_PROTO": return LengthOp.VAR_PROTO;
+		case 2:
+		case "VAR_RLP": return LengthOp.VAR_RLP;
+		case 3:
+		case "FIXED32_BIG": return LengthOp.FIXED32_BIG;
+		case 4:
+		case "FIXED32_LITTLE": return LengthOp.FIXED32_LITTLE;
+		case 5:
+		case "FIXED64_BIG": return LengthOp.FIXED64_BIG;
+		case 6:
+		case "FIXED64_LITTLE": return LengthOp.FIXED64_LITTLE;
+		case 7:
+		case "REQUIRE_32_BYTES": return LengthOp.REQUIRE_32_BYTES;
+		case 8:
+		case "REQUIRE_64_BYTES": return LengthOp.REQUIRE_64_BYTES;
+		default: return LengthOp.UNRECOGNIZED;
+	}
+}
+function lengthOpToJSON(object) {
+	switch (object) {
+		case LengthOp.NO_PREFIX: return "NO_PREFIX";
+		case LengthOp.VAR_PROTO: return "VAR_PROTO";
+		case LengthOp.VAR_RLP: return "VAR_RLP";
+		case LengthOp.FIXED32_BIG: return "FIXED32_BIG";
+		case LengthOp.FIXED32_LITTLE: return "FIXED32_LITTLE";
+		case LengthOp.FIXED64_BIG: return "FIXED64_BIG";
+		case LengthOp.FIXED64_LITTLE: return "FIXED64_LITTLE";
+		case LengthOp.REQUIRE_32_BYTES: return "REQUIRE_32_BYTES";
+		case LengthOp.REQUIRE_64_BYTES: return "REQUIRE_64_BYTES";
+		case LengthOp.UNRECOGNIZED:
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseExistenceProof() {
+	return {
+		key: new Uint8Array(),
+		value: new Uint8Array(),
+		leaf: void 0,
+		path: []
+	};
+}
+/**
+* ExistenceProof takes a key and a value and a set of steps to perform on it.
+* The result of peforming all these steps will provide a "root hash", which can
+* be compared to the value in a header.
+* 
+* Since it is computationally infeasible to produce a hash collission for any of the used
+* cryptographic hash functions, if someone can provide a series of operations to transform
+* a given key and value into a root hash that matches some trusted root, these key and values
+* must be in the referenced merkle tree.
+* 
+* The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
+* which should be controlled by a spec. Eg. with lengthOp as NONE,
+* prefix = FOO, key = BAR, value = CHOICE
+* and
+* prefix = F, key = OOBAR, value = CHOICE
+* would produce the same value.
+* 
+* With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
+* in the ProofSpec is valuable to prevent this mutability. And why all trees should
+* length-prefix the data before hashing it.
+* @name ExistenceProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.ExistenceProof
+*/
+const ExistenceProof = {
+	typeUrl: "/cosmos.ics23.v1.ExistenceProof",
+	aminoType: "cosmos-sdk/ExistenceProof",
+	is(o) {
+		return o && (o.$typeUrl === ExistenceProof.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string") && Array.isArray(o.path) && (!o.path.length || InnerOp.is(o.path[0])));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === ExistenceProof.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string") && Array.isArray(o.path) && (!o.path.length || InnerOp.isAmino(o.path[0])));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.key.length !== 0) writer.uint32(10).bytes(message.key);
+		if (message.value.length !== 0) writer.uint32(18).bytes(message.value);
+		if (message.leaf !== void 0) LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
+		for (const v of message.path) InnerOp.encode(v, writer.uint32(34).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseExistenceProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.key = reader.bytes();
+					break;
+				case 2:
+					message.value = reader.bytes();
+					break;
+				case 3:
+					message.leaf = LeafOp.decode(reader, reader.uint32());
+					break;
+				case 4:
+					message.path.push(InnerOp.decode(reader, reader.uint32()));
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseExistenceProof();
+		message.key = object.key ?? new Uint8Array();
+		message.value = object.value ?? new Uint8Array();
+		message.leaf = object.leaf !== void 0 && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : void 0;
+		message.path = object.path?.map((e) => InnerOp.fromPartial(e)) || [];
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseExistenceProof();
+		if (object.key !== void 0 && object.key !== null) message.key = bytesFromBase64(object.key);
+		if (object.value !== void 0 && object.value !== null) message.value = bytesFromBase64(object.value);
+		if (object.leaf !== void 0 && object.leaf !== null) message.leaf = LeafOp.fromAmino(object.leaf);
+		message.path = object.path?.map((e) => InnerOp.fromAmino(e)) || [];
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.key = message.key ? base64FromBytes(message.key) : void 0;
+		obj.value = message.value ? base64FromBytes(message.value) : void 0;
+		obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : void 0;
+		if (message.path) obj.path = message.path.map((e) => e ? InnerOp.toAmino(e) : void 0);
+		else obj.path = message.path;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return ExistenceProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/ExistenceProof",
+			value: ExistenceProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return ExistenceProof.decode(message.value);
+	},
+	toProto(message) {
+		return ExistenceProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.ExistenceProof",
+			value: ExistenceProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(ExistenceProof.typeUrl)) return;
+		LeafOp.registerTypeUrl();
+		InnerOp.registerTypeUrl();
+	}
+};
+function createBaseNonExistenceProof() {
+	return {
+		key: new Uint8Array(),
+		left: void 0,
+		right: void 0
+	};
+}
+/**
+* NonExistenceProof takes a proof of two neighbors, one left of the desired key,
+* one right of the desired key. If both proofs are valid AND they are neighbors,
+* then there is no valid proof for the given key.
+* @name NonExistenceProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.NonExistenceProof
+*/
+const NonExistenceProof = {
+	typeUrl: "/cosmos.ics23.v1.NonExistenceProof",
+	aminoType: "cosmos-sdk/NonExistenceProof",
+	is(o) {
+		return o && (o.$typeUrl === NonExistenceProof.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === NonExistenceProof.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.key.length !== 0) writer.uint32(10).bytes(message.key);
+		if (message.left !== void 0) ExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
+		if (message.right !== void 0) ExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseNonExistenceProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.key = reader.bytes();
+					break;
+				case 2:
+					message.left = ExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 3:
+					message.right = ExistenceProof.decode(reader, reader.uint32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseNonExistenceProof();
+		message.key = object.key ?? new Uint8Array();
+		message.left = object.left !== void 0 && object.left !== null ? ExistenceProof.fromPartial(object.left) : void 0;
+		message.right = object.right !== void 0 && object.right !== null ? ExistenceProof.fromPartial(object.right) : void 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseNonExistenceProof();
+		if (object.key !== void 0 && object.key !== null) message.key = bytesFromBase64(object.key);
+		if (object.left !== void 0 && object.left !== null) message.left = ExistenceProof.fromAmino(object.left);
+		if (object.right !== void 0 && object.right !== null) message.right = ExistenceProof.fromAmino(object.right);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.key = message.key ? base64FromBytes(message.key) : void 0;
+		obj.left = message.left ? ExistenceProof.toAmino(message.left) : void 0;
+		obj.right = message.right ? ExistenceProof.toAmino(message.right) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return NonExistenceProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/NonExistenceProof",
+			value: NonExistenceProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return NonExistenceProof.decode(message.value);
+	},
+	toProto(message) {
+		return NonExistenceProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.NonExistenceProof",
+			value: NonExistenceProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(NonExistenceProof.typeUrl)) return;
+		ExistenceProof.registerTypeUrl();
+	}
+};
+function createBaseCommitmentProof() {
+	return {
+		exist: void 0,
+		nonexist: void 0,
+		batch: void 0,
+		compressed: void 0
+	};
+}
+/**
+* CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+* @name CommitmentProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.CommitmentProof
+*/
+const CommitmentProof = {
+	typeUrl: "/cosmos.ics23.v1.CommitmentProof",
+	aminoType: "cosmos-sdk/CommitmentProof",
+	is(o) {
+		return o && o.$typeUrl === CommitmentProof.typeUrl;
+	},
+	isAmino(o) {
+		return o && o.$typeUrl === CommitmentProof.typeUrl;
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.exist !== void 0) ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+		if (message.nonexist !== void 0) NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+		if (message.batch !== void 0) BatchProof.encode(message.batch, writer.uint32(26).fork()).ldelim();
+		if (message.compressed !== void 0) CompressedBatchProof.encode(message.compressed, writer.uint32(34).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseCommitmentProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.exist = ExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.nonexist = NonExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 3:
+					message.batch = BatchProof.decode(reader, reader.uint32());
+					break;
+				case 4:
+					message.compressed = CompressedBatchProof.decode(reader, reader.uint32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseCommitmentProof();
+		message.exist = object.exist !== void 0 && object.exist !== null ? ExistenceProof.fromPartial(object.exist) : void 0;
+		message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? NonExistenceProof.fromPartial(object.nonexist) : void 0;
+		message.batch = object.batch !== void 0 && object.batch !== null ? BatchProof.fromPartial(object.batch) : void 0;
+		message.compressed = object.compressed !== void 0 && object.compressed !== null ? CompressedBatchProof.fromPartial(object.compressed) : void 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseCommitmentProof();
+		if (object.exist !== void 0 && object.exist !== null) message.exist = ExistenceProof.fromAmino(object.exist);
+		if (object.nonexist !== void 0 && object.nonexist !== null) message.nonexist = NonExistenceProof.fromAmino(object.nonexist);
+		if (object.batch !== void 0 && object.batch !== null) message.batch = BatchProof.fromAmino(object.batch);
+		if (object.compressed !== void 0 && object.compressed !== null) message.compressed = CompressedBatchProof.fromAmino(object.compressed);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.exist = message.exist ? ExistenceProof.toAmino(message.exist) : void 0;
+		obj.nonexist = message.nonexist ? NonExistenceProof.toAmino(message.nonexist) : void 0;
+		obj.batch = message.batch ? BatchProof.toAmino(message.batch) : void 0;
+		obj.compressed = message.compressed ? CompressedBatchProof.toAmino(message.compressed) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return CommitmentProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/CommitmentProof",
+			value: CommitmentProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return CommitmentProof.decode(message.value);
+	},
+	toProto(message) {
+		return CommitmentProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.CommitmentProof",
+			value: CommitmentProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(CommitmentProof.typeUrl)) return;
+		ExistenceProof.registerTypeUrl();
+		NonExistenceProof.registerTypeUrl();
+		BatchProof.registerTypeUrl();
+		CompressedBatchProof.registerTypeUrl();
+	}
+};
+function createBaseLeafOp() {
+	return {
+		hash: 0,
+		prehashKey: 0,
+		prehashValue: 0,
+		length: 0,
+		prefix: new Uint8Array()
+	};
+}
+/**
+* LeafOp represents the raw key-value data we wish to prove, and
+* must be flexible to represent the internal transformation from
+* the original key-value pairs into the basis hash, for many existing
+* merkle trees.
+* 
+* key and value are passed in. So that the signature of this operation is:
+* leafOp(key, value) -> output
+* 
+* To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+* hkey = prehashKey(key)
+* hvalue = prehashValue(value)
+* 
+* Then combine the bytes, and hash it
+* output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+* @name LeafOp
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.LeafOp
+*/
+const LeafOp = {
+	typeUrl: "/cosmos.ics23.v1.LeafOp",
+	aminoType: "cosmos-sdk/LeafOp",
+	is(o) {
+		return o && (o.$typeUrl === LeafOp.typeUrl || isSet(o.hash) && isSet(o.prehashKey) && isSet(o.prehashValue) && isSet(o.length) && (o.prefix instanceof Uint8Array || typeof o.prefix === "string"));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === LeafOp.typeUrl || isSet(o.hash) && isSet(o.prehash_key) && isSet(o.prehash_value) && isSet(o.length) && (o.prefix instanceof Uint8Array || typeof o.prefix === "string"));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.hash !== 0) writer.uint32(8).int32(message.hash);
+		if (message.prehashKey !== 0) writer.uint32(16).int32(message.prehashKey);
+		if (message.prehashValue !== 0) writer.uint32(24).int32(message.prehashValue);
+		if (message.length !== 0) writer.uint32(32).int32(message.length);
+		if (message.prefix.length !== 0) writer.uint32(42).bytes(message.prefix);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseLeafOp();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.hash = reader.int32();
+					break;
+				case 2:
+					message.prehashKey = reader.int32();
+					break;
+				case 3:
+					message.prehashValue = reader.int32();
+					break;
+				case 4:
+					message.length = reader.int32();
+					break;
+				case 5:
+					message.prefix = reader.bytes();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseLeafOp();
+		message.hash = object.hash ?? 0;
+		message.prehashKey = object.prehashKey ?? 0;
+		message.prehashValue = object.prehashValue ?? 0;
+		message.length = object.length ?? 0;
+		message.prefix = object.prefix ?? new Uint8Array();
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseLeafOp();
+		if (object.hash !== void 0 && object.hash !== null) message.hash = object.hash;
+		if (object.prehash_key !== void 0 && object.prehash_key !== null) message.prehashKey = object.prehash_key;
+		if (object.prehash_value !== void 0 && object.prehash_value !== null) message.prehashValue = object.prehash_value;
+		if (object.length !== void 0 && object.length !== null) message.length = object.length;
+		if (object.prefix !== void 0 && object.prefix !== null) message.prefix = bytesFromBase64(object.prefix);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.hash = message.hash === 0 ? void 0 : message.hash;
+		obj.prehash_key = message.prehashKey === 0 ? void 0 : message.prehashKey;
+		obj.prehash_value = message.prehashValue === 0 ? void 0 : message.prehashValue;
+		obj.length = message.length === 0 ? void 0 : message.length;
+		obj.prefix = message.prefix ? base64FromBytes(message.prefix) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return LeafOp.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/LeafOp",
+			value: LeafOp.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return LeafOp.decode(message.value);
+	},
+	toProto(message) {
+		return LeafOp.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.LeafOp",
+			value: LeafOp.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {}
+};
+function createBaseInnerOp() {
+	return {
+		hash: 0,
+		prefix: new Uint8Array(),
+		suffix: new Uint8Array()
+	};
+}
+/**
+* InnerOp represents a merkle-proof step that is not a leaf.
+* It represents concatenating two children and hashing them to provide the next result.
+* 
+* The result of the previous step is passed in, so the signature of this op is:
+* innerOp(child) -> output
+* 
+* The result of applying InnerOp should be:
+* output = op.hash(op.prefix || child || op.suffix)
+* 
+* where the || operator is concatenation of binary data,
+* and child is the result of hashing all the tree below this step.
+* 
+* Any special data, like prepending child with the length, or prepending the entire operation with
+* some value to differentiate from leaf nodes, should be included in prefix and suffix.
+* If either of prefix or suffix is empty, we just treat it as an empty string
+* @name InnerOp
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.InnerOp
+*/
+const InnerOp = {
+	typeUrl: "/cosmos.ics23.v1.InnerOp",
+	aminoType: "cosmos-sdk/InnerOp",
+	is(o) {
+		return o && (o.$typeUrl === InnerOp.typeUrl || isSet(o.hash) && (o.prefix instanceof Uint8Array || typeof o.prefix === "string") && (o.suffix instanceof Uint8Array || typeof o.suffix === "string"));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === InnerOp.typeUrl || isSet(o.hash) && (o.prefix instanceof Uint8Array || typeof o.prefix === "string") && (o.suffix instanceof Uint8Array || typeof o.suffix === "string"));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.hash !== 0) writer.uint32(8).int32(message.hash);
+		if (message.prefix.length !== 0) writer.uint32(18).bytes(message.prefix);
+		if (message.suffix.length !== 0) writer.uint32(26).bytes(message.suffix);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseInnerOp();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.hash = reader.int32();
+					break;
+				case 2:
+					message.prefix = reader.bytes();
+					break;
+				case 3:
+					message.suffix = reader.bytes();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseInnerOp();
+		message.hash = object.hash ?? 0;
+		message.prefix = object.prefix ?? new Uint8Array();
+		message.suffix = object.suffix ?? new Uint8Array();
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseInnerOp();
+		if (object.hash !== void 0 && object.hash !== null) message.hash = object.hash;
+		if (object.prefix !== void 0 && object.prefix !== null) message.prefix = bytesFromBase64(object.prefix);
+		if (object.suffix !== void 0 && object.suffix !== null) message.suffix = bytesFromBase64(object.suffix);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.hash = message.hash === 0 ? void 0 : message.hash;
+		obj.prefix = message.prefix ? base64FromBytes(message.prefix) : void 0;
+		obj.suffix = message.suffix ? base64FromBytes(message.suffix) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return InnerOp.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/InnerOp",
+			value: InnerOp.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return InnerOp.decode(message.value);
+	},
+	toProto(message) {
+		return InnerOp.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.InnerOp",
+			value: InnerOp.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {}
+};
+function createBaseProofSpec() {
+	return {
+		leafSpec: void 0,
+		innerSpec: void 0,
+		maxDepth: 0,
+		minDepth: 0,
+		prehashKeyBeforeComparison: false
+	};
+}
+/**
+* ProofSpec defines what the expected parameters are for a given proof type.
+* This can be stored in the client and used to validate any incoming proofs.
+* 
+* verify(ProofSpec, Proof) -> Proof | Error
+* 
+* As demonstrated in tests, if we don't fix the algorithm used to calculate the
+* LeafHash for a given tree, there are many possible key-value pairs that can
+* generate a given hash (by interpretting the preimage differently).
+* We need this for proper security, requires client knows a priori what
+* tree format server uses. But not in code, rather a configuration object.
+* @name ProofSpec
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.ProofSpec
+*/
+const ProofSpec = {
+	typeUrl: "/cosmos.ics23.v1.ProofSpec",
+	aminoType: "cosmos-sdk/ProofSpec",
+	is(o) {
+		return o && (o.$typeUrl === ProofSpec.typeUrl || typeof o.maxDepth === "number" && typeof o.minDepth === "number" && typeof o.prehashKeyBeforeComparison === "boolean");
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === ProofSpec.typeUrl || typeof o.max_depth === "number" && typeof o.min_depth === "number" && typeof o.prehash_key_before_comparison === "boolean");
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.leafSpec !== void 0) LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
+		if (message.innerSpec !== void 0) InnerSpec.encode(message.innerSpec, writer.uint32(18).fork()).ldelim();
+		if (message.maxDepth !== 0) writer.uint32(24).int32(message.maxDepth);
+		if (message.minDepth !== 0) writer.uint32(32).int32(message.minDepth);
+		if (message.prehashKeyBeforeComparison === true) writer.uint32(40).bool(message.prehashKeyBeforeComparison);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseProofSpec();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.leafSpec = LeafOp.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.innerSpec = InnerSpec.decode(reader, reader.uint32());
+					break;
+				case 3:
+					message.maxDepth = reader.int32();
+					break;
+				case 4:
+					message.minDepth = reader.int32();
+					break;
+				case 5:
+					message.prehashKeyBeforeComparison = reader.bool();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseProofSpec();
+		message.leafSpec = object.leafSpec !== void 0 && object.leafSpec !== null ? LeafOp.fromPartial(object.leafSpec) : void 0;
+		message.innerSpec = object.innerSpec !== void 0 && object.innerSpec !== null ? InnerSpec.fromPartial(object.innerSpec) : void 0;
+		message.maxDepth = object.maxDepth ?? 0;
+		message.minDepth = object.minDepth ?? 0;
+		message.prehashKeyBeforeComparison = object.prehashKeyBeforeComparison ?? false;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseProofSpec();
+		if (object.leaf_spec !== void 0 && object.leaf_spec !== null) message.leafSpec = LeafOp.fromAmino(object.leaf_spec);
+		if (object.inner_spec !== void 0 && object.inner_spec !== null) message.innerSpec = InnerSpec.fromAmino(object.inner_spec);
+		if (object.max_depth !== void 0 && object.max_depth !== null) message.maxDepth = object.max_depth;
+		if (object.min_depth !== void 0 && object.min_depth !== null) message.minDepth = object.min_depth;
+		if (object.prehash_key_before_comparison !== void 0 && object.prehash_key_before_comparison !== null) message.prehashKeyBeforeComparison = object.prehash_key_before_comparison;
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.leaf_spec = message.leafSpec ? LeafOp.toAmino(message.leafSpec) : void 0;
+		obj.inner_spec = message.innerSpec ? InnerSpec.toAmino(message.innerSpec) : void 0;
+		obj.max_depth = message.maxDepth === 0 ? void 0 : message.maxDepth;
+		obj.min_depth = message.minDepth === 0 ? void 0 : message.minDepth;
+		obj.prehash_key_before_comparison = message.prehashKeyBeforeComparison === false ? void 0 : message.prehashKeyBeforeComparison;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return ProofSpec.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/ProofSpec",
+			value: ProofSpec.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return ProofSpec.decode(message.value);
+	},
+	toProto(message) {
+		return ProofSpec.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.ProofSpec",
+			value: ProofSpec.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(ProofSpec.typeUrl)) return;
+		LeafOp.registerTypeUrl();
+		InnerSpec.registerTypeUrl();
+	}
+};
+function createBaseInnerSpec() {
+	return {
+		childOrder: [],
+		childSize: 0,
+		minPrefixLength: 0,
+		maxPrefixLength: 0,
+		emptyChild: new Uint8Array(),
+		hash: 0
+	};
+}
+/**
+* InnerSpec contains all store-specific structure info to determine if two proofs from a
+* given store are neighbors.
+* 
+* This enables:
+* 
+* isLeftMost(spec: InnerSpec, op: InnerOp)
+* isRightMost(spec: InnerSpec, op: InnerOp)
+* isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+* @name InnerSpec
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.InnerSpec
+*/
+const InnerSpec = {
+	typeUrl: "/cosmos.ics23.v1.InnerSpec",
+	aminoType: "cosmos-sdk/InnerSpec",
+	is(o) {
+		return o && (o.$typeUrl === InnerSpec.typeUrl || Array.isArray(o.childOrder) && (!o.childOrder.length || typeof o.childOrder[0] === "number") && typeof o.childSize === "number" && typeof o.minPrefixLength === "number" && typeof o.maxPrefixLength === "number" && (o.emptyChild instanceof Uint8Array || typeof o.emptyChild === "string") && isSet(o.hash));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === InnerSpec.typeUrl || Array.isArray(o.child_order) && (!o.child_order.length || typeof o.child_order[0] === "number") && typeof o.child_size === "number" && typeof o.min_prefix_length === "number" && typeof o.max_prefix_length === "number" && (o.empty_child instanceof Uint8Array || typeof o.empty_child === "string") && isSet(o.hash));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		writer.uint32(10).fork();
+		for (const v of message.childOrder) writer.int32(v);
+		writer.ldelim();
+		if (message.childSize !== 0) writer.uint32(16).int32(message.childSize);
+		if (message.minPrefixLength !== 0) writer.uint32(24).int32(message.minPrefixLength);
+		if (message.maxPrefixLength !== 0) writer.uint32(32).int32(message.maxPrefixLength);
+		if (message.emptyChild.length !== 0) writer.uint32(42).bytes(message.emptyChild);
+		if (message.hash !== 0) writer.uint32(48).int32(message.hash);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseInnerSpec();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if ((tag & 7) === 2) {
+						const end2 = reader.uint32() + reader.pos;
+						while (reader.pos < end2) message.childOrder.push(reader.int32());
+					} else message.childOrder.push(reader.int32());
+					break;
+				case 2:
+					message.childSize = reader.int32();
+					break;
+				case 3:
+					message.minPrefixLength = reader.int32();
+					break;
+				case 4:
+					message.maxPrefixLength = reader.int32();
+					break;
+				case 5:
+					message.emptyChild = reader.bytes();
+					break;
+				case 6:
+					message.hash = reader.int32();
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseInnerSpec();
+		message.childOrder = object.childOrder?.map((e) => e) || [];
+		message.childSize = object.childSize ?? 0;
+		message.minPrefixLength = object.minPrefixLength ?? 0;
+		message.maxPrefixLength = object.maxPrefixLength ?? 0;
+		message.emptyChild = object.emptyChild ?? new Uint8Array();
+		message.hash = object.hash ?? 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseInnerSpec();
+		message.childOrder = object.child_order?.map((e) => e) || [];
+		if (object.child_size !== void 0 && object.child_size !== null) message.childSize = object.child_size;
+		if (object.min_prefix_length !== void 0 && object.min_prefix_length !== null) message.minPrefixLength = object.min_prefix_length;
+		if (object.max_prefix_length !== void 0 && object.max_prefix_length !== null) message.maxPrefixLength = object.max_prefix_length;
+		if (object.empty_child !== void 0 && object.empty_child !== null) message.emptyChild = bytesFromBase64(object.empty_child);
+		if (object.hash !== void 0 && object.hash !== null) message.hash = object.hash;
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		if (message.childOrder) obj.child_order = message.childOrder.map((e) => e);
+		else obj.child_order = message.childOrder;
+		obj.child_size = message.childSize === 0 ? void 0 : message.childSize;
+		obj.min_prefix_length = message.minPrefixLength === 0 ? void 0 : message.minPrefixLength;
+		obj.max_prefix_length = message.maxPrefixLength === 0 ? void 0 : message.maxPrefixLength;
+		obj.empty_child = message.emptyChild ? base64FromBytes(message.emptyChild) : void 0;
+		obj.hash = message.hash === 0 ? void 0 : message.hash;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return InnerSpec.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/InnerSpec",
+			value: InnerSpec.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return InnerSpec.decode(message.value);
+	},
+	toProto(message) {
+		return InnerSpec.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.InnerSpec",
+			value: InnerSpec.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {}
+};
+function createBaseBatchProof() {
+	return { entries: [] };
+}
+/**
+* BatchProof is a group of multiple proof types than can be compressed
+* @name BatchProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.BatchProof
+*/
+const BatchProof = {
+	typeUrl: "/cosmos.ics23.v1.BatchProof",
+	aminoType: "cosmos-sdk/BatchProof",
+	is(o) {
+		return o && (o.$typeUrl === BatchProof.typeUrl || Array.isArray(o.entries) && (!o.entries.length || BatchEntry.is(o.entries[0])));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === BatchProof.typeUrl || Array.isArray(o.entries) && (!o.entries.length || BatchEntry.isAmino(o.entries[0])));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		for (const v of message.entries) BatchEntry.encode(v, writer.uint32(10).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseBatchProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.entries.push(BatchEntry.decode(reader, reader.uint32()));
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseBatchProof();
+		message.entries = object.entries?.map((e) => BatchEntry.fromPartial(e)) || [];
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseBatchProof();
+		message.entries = object.entries?.map((e) => BatchEntry.fromAmino(e)) || [];
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		if (message.entries) obj.entries = message.entries.map((e) => e ? BatchEntry.toAmino(e) : void 0);
+		else obj.entries = message.entries;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return BatchProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/BatchProof",
+			value: BatchProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return BatchProof.decode(message.value);
+	},
+	toProto(message) {
+		return BatchProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.BatchProof",
+			value: BatchProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(BatchProof.typeUrl)) return;
+		BatchEntry.registerTypeUrl();
+	}
+};
+function createBaseBatchEntry() {
+	return {
+		exist: void 0,
+		nonexist: void 0
+	};
+}
+/**
+* Use BatchEntry not CommitmentProof, to avoid recursion
+* @name BatchEntry
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.BatchEntry
+*/
+const BatchEntry = {
+	typeUrl: "/cosmos.ics23.v1.BatchEntry",
+	aminoType: "cosmos-sdk/BatchEntry",
+	is(o) {
+		return o && o.$typeUrl === BatchEntry.typeUrl;
+	},
+	isAmino(o) {
+		return o && o.$typeUrl === BatchEntry.typeUrl;
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.exist !== void 0) ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+		if (message.nonexist !== void 0) NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseBatchEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.exist = ExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.nonexist = NonExistenceProof.decode(reader, reader.uint32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseBatchEntry();
+		message.exist = object.exist !== void 0 && object.exist !== null ? ExistenceProof.fromPartial(object.exist) : void 0;
+		message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? NonExistenceProof.fromPartial(object.nonexist) : void 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseBatchEntry();
+		if (object.exist !== void 0 && object.exist !== null) message.exist = ExistenceProof.fromAmino(object.exist);
+		if (object.nonexist !== void 0 && object.nonexist !== null) message.nonexist = NonExistenceProof.fromAmino(object.nonexist);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.exist = message.exist ? ExistenceProof.toAmino(message.exist) : void 0;
+		obj.nonexist = message.nonexist ? NonExistenceProof.toAmino(message.nonexist) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return BatchEntry.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/BatchEntry",
+			value: BatchEntry.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return BatchEntry.decode(message.value);
+	},
+	toProto(message) {
+		return BatchEntry.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.BatchEntry",
+			value: BatchEntry.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(BatchEntry.typeUrl)) return;
+		ExistenceProof.registerTypeUrl();
+		NonExistenceProof.registerTypeUrl();
+	}
+};
+function createBaseCompressedBatchProof() {
+	return {
+		entries: [],
+		lookupInners: []
+	};
+}
+/**
+* @name CompressedBatchProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.CompressedBatchProof
+*/
+const CompressedBatchProof = {
+	typeUrl: "/cosmos.ics23.v1.CompressedBatchProof",
+	aminoType: "cosmos-sdk/CompressedBatchProof",
+	is(o) {
+		return o && (o.$typeUrl === CompressedBatchProof.typeUrl || Array.isArray(o.entries) && (!o.entries.length || CompressedBatchEntry.is(o.entries[0])) && Array.isArray(o.lookupInners) && (!o.lookupInners.length || InnerOp.is(o.lookupInners[0])));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === CompressedBatchProof.typeUrl || Array.isArray(o.entries) && (!o.entries.length || CompressedBatchEntry.isAmino(o.entries[0])) && Array.isArray(o.lookup_inners) && (!o.lookup_inners.length || InnerOp.isAmino(o.lookup_inners[0])));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		for (const v of message.entries) CompressedBatchEntry.encode(v, writer.uint32(10).fork()).ldelim();
+		for (const v of message.lookupInners) InnerOp.encode(v, writer.uint32(18).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseCompressedBatchProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.entries.push(CompressedBatchEntry.decode(reader, reader.uint32()));
+					break;
+				case 2:
+					message.lookupInners.push(InnerOp.decode(reader, reader.uint32()));
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseCompressedBatchProof();
+		message.entries = object.entries?.map((e) => CompressedBatchEntry.fromPartial(e)) || [];
+		message.lookupInners = object.lookupInners?.map((e) => InnerOp.fromPartial(e)) || [];
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseCompressedBatchProof();
+		message.entries = object.entries?.map((e) => CompressedBatchEntry.fromAmino(e)) || [];
+		message.lookupInners = object.lookup_inners?.map((e) => InnerOp.fromAmino(e)) || [];
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		if (message.entries) obj.entries = message.entries.map((e) => e ? CompressedBatchEntry.toAmino(e) : void 0);
+		else obj.entries = message.entries;
+		if (message.lookupInners) obj.lookup_inners = message.lookupInners.map((e) => e ? InnerOp.toAmino(e) : void 0);
+		else obj.lookup_inners = message.lookupInners;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return CompressedBatchProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/CompressedBatchProof",
+			value: CompressedBatchProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return CompressedBatchProof.decode(message.value);
+	},
+	toProto(message) {
+		return CompressedBatchProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.CompressedBatchProof",
+			value: CompressedBatchProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedBatchProof.typeUrl)) return;
+		CompressedBatchEntry.registerTypeUrl();
+		InnerOp.registerTypeUrl();
+	}
+};
+function createBaseCompressedBatchEntry() {
+	return {
+		exist: void 0,
+		nonexist: void 0
+	};
+}
+/**
+* Use BatchEntry not CommitmentProof, to avoid recursion
+* @name CompressedBatchEntry
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.CompressedBatchEntry
+*/
+const CompressedBatchEntry = {
+	typeUrl: "/cosmos.ics23.v1.CompressedBatchEntry",
+	aminoType: "cosmos-sdk/CompressedBatchEntry",
+	is(o) {
+		return o && o.$typeUrl === CompressedBatchEntry.typeUrl;
+	},
+	isAmino(o) {
+		return o && o.$typeUrl === CompressedBatchEntry.typeUrl;
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.exist !== void 0) CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+		if (message.nonexist !== void 0) CompressedNonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseCompressedBatchEntry();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.exist = CompressedExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 2:
+					message.nonexist = CompressedNonExistenceProof.decode(reader, reader.uint32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseCompressedBatchEntry();
+		message.exist = object.exist !== void 0 && object.exist !== null ? CompressedExistenceProof.fromPartial(object.exist) : void 0;
+		message.nonexist = object.nonexist !== void 0 && object.nonexist !== null ? CompressedNonExistenceProof.fromPartial(object.nonexist) : void 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseCompressedBatchEntry();
+		if (object.exist !== void 0 && object.exist !== null) message.exist = CompressedExistenceProof.fromAmino(object.exist);
+		if (object.nonexist !== void 0 && object.nonexist !== null) message.nonexist = CompressedNonExistenceProof.fromAmino(object.nonexist);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.exist = message.exist ? CompressedExistenceProof.toAmino(message.exist) : void 0;
+		obj.nonexist = message.nonexist ? CompressedNonExistenceProof.toAmino(message.nonexist) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return CompressedBatchEntry.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/CompressedBatchEntry",
+			value: CompressedBatchEntry.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return CompressedBatchEntry.decode(message.value);
+	},
+	toProto(message) {
+		return CompressedBatchEntry.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.CompressedBatchEntry",
+			value: CompressedBatchEntry.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedBatchEntry.typeUrl)) return;
+		CompressedExistenceProof.registerTypeUrl();
+		CompressedNonExistenceProof.registerTypeUrl();
+	}
+};
+function createBaseCompressedExistenceProof() {
+	return {
+		key: new Uint8Array(),
+		value: new Uint8Array(),
+		leaf: void 0,
+		path: []
+	};
+}
+/**
+* @name CompressedExistenceProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.CompressedExistenceProof
+*/
+const CompressedExistenceProof = {
+	typeUrl: "/cosmos.ics23.v1.CompressedExistenceProof",
+	aminoType: "cosmos-sdk/CompressedExistenceProof",
+	is(o) {
+		return o && (o.$typeUrl === CompressedExistenceProof.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string") && Array.isArray(o.path) && (!o.path.length || typeof o.path[0] === "number"));
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === CompressedExistenceProof.typeUrl || (o.key instanceof Uint8Array || typeof o.key === "string") && (o.value instanceof Uint8Array || typeof o.value === "string") && Array.isArray(o.path) && (!o.path.length || typeof o.path[0] === "number"));
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.key.length !== 0) writer.uint32(10).bytes(message.key);
+		if (message.value.length !== 0) writer.uint32(18).bytes(message.value);
+		if (message.leaf !== void 0) LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
+		writer.uint32(34).fork();
+		for (const v of message.path) writer.int32(v);
+		writer.ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseCompressedExistenceProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.key = reader.bytes();
+					break;
+				case 2:
+					message.value = reader.bytes();
+					break;
+				case 3:
+					message.leaf = LeafOp.decode(reader, reader.uint32());
+					break;
+				case 4:
+					if ((tag & 7) === 2) {
+						const end2 = reader.uint32() + reader.pos;
+						while (reader.pos < end2) message.path.push(reader.int32());
+					} else message.path.push(reader.int32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseCompressedExistenceProof();
+		message.key = object.key ?? new Uint8Array();
+		message.value = object.value ?? new Uint8Array();
+		message.leaf = object.leaf !== void 0 && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : void 0;
+		message.path = object.path?.map((e) => e) || [];
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseCompressedExistenceProof();
+		if (object.key !== void 0 && object.key !== null) message.key = bytesFromBase64(object.key);
+		if (object.value !== void 0 && object.value !== null) message.value = bytesFromBase64(object.value);
+		if (object.leaf !== void 0 && object.leaf !== null) message.leaf = LeafOp.fromAmino(object.leaf);
+		message.path = object.path?.map((e) => e) || [];
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.key = message.key ? base64FromBytes(message.key) : void 0;
+		obj.value = message.value ? base64FromBytes(message.value) : void 0;
+		obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : void 0;
+		if (message.path) obj.path = message.path.map((e) => e);
+		else obj.path = message.path;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return CompressedExistenceProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/CompressedExistenceProof",
+			value: CompressedExistenceProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return CompressedExistenceProof.decode(message.value);
+	},
+	toProto(message) {
+		return CompressedExistenceProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.CompressedExistenceProof",
+			value: CompressedExistenceProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedExistenceProof.typeUrl)) return;
+		LeafOp.registerTypeUrl();
+	}
+};
+function createBaseCompressedNonExistenceProof() {
+	return {
+		key: new Uint8Array(),
+		left: void 0,
+		right: void 0
+	};
+}
+/**
+* @name CompressedNonExistenceProof
+* @package cosmos.ics23.v1
+* @see proto type: cosmos.ics23.v1.CompressedNonExistenceProof
+*/
+const CompressedNonExistenceProof = {
+	typeUrl: "/cosmos.ics23.v1.CompressedNonExistenceProof",
+	aminoType: "cosmos-sdk/CompressedNonExistenceProof",
+	is(o) {
+		return o && (o.$typeUrl === CompressedNonExistenceProof.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+	},
+	isAmino(o) {
+		return o && (o.$typeUrl === CompressedNonExistenceProof.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
+	},
+	encode(message, writer = BinaryWriter.create()) {
+		if (message.key.length !== 0) writer.uint32(10).bytes(message.key);
+		if (message.left !== void 0) CompressedExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
+		if (message.right !== void 0) CompressedExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		let end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseCompressedNonExistenceProof();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					message.key = reader.bytes();
+					break;
+				case 2:
+					message.left = CompressedExistenceProof.decode(reader, reader.uint32());
+					break;
+				case 3:
+					message.right = CompressedExistenceProof.decode(reader, reader.uint32());
+					break;
+				default:
+					reader.skipType(tag & 7);
+					break;
+			}
+		}
+		return message;
+	},
+	fromPartial(object) {
+		const message = createBaseCompressedNonExistenceProof();
+		message.key = object.key ?? new Uint8Array();
+		message.left = object.left !== void 0 && object.left !== null ? CompressedExistenceProof.fromPartial(object.left) : void 0;
+		message.right = object.right !== void 0 && object.right !== null ? CompressedExistenceProof.fromPartial(object.right) : void 0;
+		return message;
+	},
+	fromAmino(object) {
+		const message = createBaseCompressedNonExistenceProof();
+		if (object.key !== void 0 && object.key !== null) message.key = bytesFromBase64(object.key);
+		if (object.left !== void 0 && object.left !== null) message.left = CompressedExistenceProof.fromAmino(object.left);
+		if (object.right !== void 0 && object.right !== null) message.right = CompressedExistenceProof.fromAmino(object.right);
+		return message;
+	},
+	toAmino(message) {
+		const obj = {};
+		obj.key = message.key ? base64FromBytes(message.key) : void 0;
+		obj.left = message.left ? CompressedExistenceProof.toAmino(message.left) : void 0;
+		obj.right = message.right ? CompressedExistenceProof.toAmino(message.right) : void 0;
+		return obj;
+	},
+	fromAminoMsg(object) {
+		return CompressedNonExistenceProof.fromAmino(object.value);
+	},
+	toAminoMsg(message) {
+		return {
+			type: "cosmos-sdk/CompressedNonExistenceProof",
+			value: CompressedNonExistenceProof.toAmino(message)
+		};
+	},
+	fromProtoMsg(message) {
+		return CompressedNonExistenceProof.decode(message.value);
+	},
+	toProto(message) {
+		return CompressedNonExistenceProof.encode(message).finish();
+	},
+	toProtoMsg(message) {
+		return {
+			typeUrl: "/cosmos.ics23.v1.CompressedNonExistenceProof",
+			value: CompressedNonExistenceProof.encode(message).finish()
+		};
+	},
+	registerTypeUrl() {
+		if (!GlobalDecoderRegistry.registerExistingTypeUrl(CompressedNonExistenceProof.typeUrl)) return;
+		CompressedExistenceProof.registerTypeUrl();
+	}
+};
+
+//#endregion
+export { BatchEntry, BatchProof, CommitmentProof, CompressedBatchEntry, CompressedBatchProof, CompressedExistenceProof, CompressedNonExistenceProof, ExistenceProof, HashOp, HashOpAmino, InnerOp, InnerSpec, LeafOp, LengthOp, LengthOpAmino, NonExistenceProof, ProofSpec, hashOpFromJSON, hashOpToJSON, lengthOpFromJSON, lengthOpToJSON };