juno-network 0.15.0 → 0.17.0

package/module/codegen/confio/proofs.js

@@ -1,6 +1,6 @@
-import * as _m0 from "protobufjs/minimal";
-export let HashOp;
-(function (HashOp) {
+import { BinaryReader, BinaryWriter } from "../binary";
+import { bytesFromBase64, base64FromBytes } from "../helpers";
+export let HashOp = /*#__PURE__*/function (HashOp) {
   HashOp[HashOp["NO_HASH"] = 0] = "NO_HASH";
   HashOp[HashOp["SHA256"] = 1] = "SHA256";
   HashOp[HashOp["SHA512"] = 2] = "SHA512";
@@ -8,17 +8,10 @@ export let HashOp;
   HashOp[HashOp["RIPEMD160"] = 4] = "RIPEMD160";
   HashOp[HashOp["BITCOIN"] = 5] = "BITCOIN";
   HashOp[HashOp["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(HashOp || (HashOp = {}));
-export let HashOpSDKType;
-(function (HashOpSDKType) {
-  HashOpSDKType[HashOpSDKType["NO_HASH"] = 0] = "NO_HASH";
-  HashOpSDKType[HashOpSDKType["SHA256"] = 1] = "SHA256";
-  HashOpSDKType[HashOpSDKType["SHA512"] = 2] = "SHA512";
-  HashOpSDKType[HashOpSDKType["KECCAK"] = 3] = "KECCAK";
-  HashOpSDKType[HashOpSDKType["RIPEMD160"] = 4] = "RIPEMD160";
-  HashOpSDKType[HashOpSDKType["BITCOIN"] = 5] = "BITCOIN";
-  HashOpSDKType[HashOpSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(HashOpSDKType || (HashOpSDKType = {}));
+  return HashOp;
+}({});
+export const HashOpSDKType = HashOp;
+export const HashOpAmino = HashOp;
 export function hashOpFromJSON(object) {
   switch (object) {
     case 0:
@@ -70,15 +63,7 @@ export function hashOpToJSON(object) {
  * algorithm, the length will be prepended to the key and value bytes.
  * (Each one with it's own encoded length)
  */
-
-export let LengthOp;
-/**
- * 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)
- */
-(function (LengthOp) {
+export let LengthOp = /*#__PURE__*/function (LengthOp) {
   LengthOp[LengthOp["NO_PREFIX"] = 0] = "NO_PREFIX";
   LengthOp[LengthOp["VAR_PROTO"] = 1] = "VAR_PROTO";
   LengthOp[LengthOp["VAR_RLP"] = 2] = "VAR_RLP";
@@ -89,20 +74,10 @@ export let LengthOp;
   LengthOp[LengthOp["REQUIRE_32_BYTES"] = 7] = "REQUIRE_32_BYTES";
   LengthOp[LengthOp["REQUIRE_64_BYTES"] = 8] = "REQUIRE_64_BYTES";
   LengthOp[LengthOp["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(LengthOp || (LengthOp = {}));
-export let LengthOpSDKType;
-(function (LengthOpSDKType) {
-  LengthOpSDKType[LengthOpSDKType["NO_PREFIX"] = 0] = "NO_PREFIX";
-  LengthOpSDKType[LengthOpSDKType["VAR_PROTO"] = 1] = "VAR_PROTO";
-  LengthOpSDKType[LengthOpSDKType["VAR_RLP"] = 2] = "VAR_RLP";
-  LengthOpSDKType[LengthOpSDKType["FIXED32_BIG"] = 3] = "FIXED32_BIG";
-  LengthOpSDKType[LengthOpSDKType["FIXED32_LITTLE"] = 4] = "FIXED32_LITTLE";
-  LengthOpSDKType[LengthOpSDKType["FIXED64_BIG"] = 5] = "FIXED64_BIG";
-  LengthOpSDKType[LengthOpSDKType["FIXED64_LITTLE"] = 6] = "FIXED64_LITTLE";
-  LengthOpSDKType[LengthOpSDKType["REQUIRE_32_BYTES"] = 7] = "REQUIRE_32_BYTES";
-  LengthOpSDKType[LengthOpSDKType["REQUIRE_64_BYTES"] = 8] = "REQUIRE_64_BYTES";
-  LengthOpSDKType[LengthOpSDKType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(LengthOpSDKType || (LengthOpSDKType = {}));
+  return LengthOp;
+}({});
+export const LengthOpSDKType = LengthOp;
+export const LengthOpAmino = LengthOp;
 export function lengthOpFromJSON(object) {
   switch (object) {
     case 0:
@@ -185,6 +160,269 @@ export function lengthOpToJSON(object) {
  * length-prefix the data before hashing it.
  */
 
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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
+ */
+
+/**
+ * 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
+ */
+
+/**
+ * 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
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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)
+ */
+
+/** BatchProof is a group of multiple proof types than can be compressed */
+
+/** BatchProof is a group of multiple proof types than can be compressed */
+
+/** BatchProof is a group of multiple proof types than can be compressed */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
 function createBaseExistenceProof() {
   return {
     key: new Uint8Array(),
@@ -194,7 +432,8 @@ function createBaseExistenceProof() {
   };
 }
 export const ExistenceProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.ExistenceProof",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -210,7 +449,7 @@ export const ExistenceProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseExistenceProof();
     while (reader.pos < end) {
@@ -243,6 +482,48 @@ export const ExistenceProof = {
     message.leaf = object.leaf !== undefined && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : undefined;
     message.path = ((_object$path = object.path) === null || _object$path === void 0 ? void 0 : _object$path.map(e => InnerOp.fromPartial(e))) || [];
     return message;
+  },
+  fromAmino(object) {
+    var _object$path2;
+    const message = createBaseExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = bytesFromBase64(object.value);
+    }
+    if (object.leaf !== undefined && object.leaf !== null) {
+      message.leaf = LeafOp.fromAmino(object.leaf);
+    }
+    message.path = ((_object$path2 = object.path) === null || _object$path2 === void 0 ? void 0 : _object$path2.map(e => InnerOp.fromAmino(e))) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.value = message.value ? base64FromBytes(message.value) : undefined;
+    obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : undefined;
+    if (message.path) {
+      obj.path = message.path.map(e => e ? InnerOp.toAmino(e) : undefined);
+    } else {
+      obj.path = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return ExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return ExistenceProof.decode(message.value);
+  },
+  toProto(message) {
+    return ExistenceProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.ExistenceProof",
+      value: ExistenceProof.encode(message).finish()
+    };
   }
 };
 function createBaseNonExistenceProof() {
@@ -253,7 +534,8 @@ function createBaseNonExistenceProof() {
   };
 }
 export const NonExistenceProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.NonExistenceProof",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -266,7 +548,7 @@ export const NonExistenceProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseNonExistenceProof();
     while (reader.pos < end) {
@@ -295,6 +577,41 @@ export const NonExistenceProof = {
     message.left = object.left !== undefined && object.left !== null ? ExistenceProof.fromPartial(object.left) : undefined;
     message.right = object.right !== undefined && object.right !== null ? ExistenceProof.fromPartial(object.right) : undefined;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseNonExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.left !== undefined && object.left !== null) {
+      message.left = ExistenceProof.fromAmino(object.left);
+    }
+    if (object.right !== undefined && object.right !== null) {
+      message.right = ExistenceProof.fromAmino(object.right);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.left = message.left ? ExistenceProof.toAmino(message.left) : undefined;
+    obj.right = message.right ? ExistenceProof.toAmino(message.right) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return NonExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return NonExistenceProof.decode(message.value);
+  },
+  toProto(message) {
+    return NonExistenceProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.NonExistenceProof",
+      value: NonExistenceProof.encode(message).finish()
+    };
   }
 };
 function createBaseCommitmentProof() {
@@ -306,7 +623,8 @@ function createBaseCommitmentProof() {
   };
 }
 export const CommitmentProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.CommitmentProof",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.exist !== undefined) {
       ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -322,7 +640,7 @@ export const CommitmentProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCommitmentProof();
     while (reader.pos < end) {
@@ -354,6 +672,45 @@ export const CommitmentProof = {
     message.batch = object.batch !== undefined && object.batch !== null ? BatchProof.fromPartial(object.batch) : undefined;
     message.compressed = object.compressed !== undefined && object.compressed !== null ? CompressedBatchProof.fromPartial(object.compressed) : undefined;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseCommitmentProof();
+    if (object.exist !== undefined && object.exist !== null) {
+      message.exist = ExistenceProof.fromAmino(object.exist);
+    }
+    if (object.nonexist !== undefined && object.nonexist !== null) {
+      message.nonexist = NonExistenceProof.fromAmino(object.nonexist);
+    }
+    if (object.batch !== undefined && object.batch !== null) {
+      message.batch = BatchProof.fromAmino(object.batch);
+    }
+    if (object.compressed !== undefined && object.compressed !== null) {
+      message.compressed = CompressedBatchProof.fromAmino(object.compressed);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.exist = message.exist ? ExistenceProof.toAmino(message.exist) : undefined;
+    obj.nonexist = message.nonexist ? NonExistenceProof.toAmino(message.nonexist) : undefined;
+    obj.batch = message.batch ? BatchProof.toAmino(message.batch) : undefined;
+    obj.compressed = message.compressed ? CompressedBatchProof.toAmino(message.compressed) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return CommitmentProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return CommitmentProof.decode(message.value);
+  },
+  toProto(message) {
+    return CommitmentProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CommitmentProof",
+      value: CommitmentProof.encode(message).finish()
+    };
   }
 };
 function createBaseLeafOp() {
@@ -366,7 +723,8 @@ function createBaseLeafOp() {
   };
 }
 export const LeafOp = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.LeafOp",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.hash !== 0) {
       writer.uint32(8).int32(message.hash);
     }
@@ -385,7 +743,7 @@ export const LeafOp = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseLeafOp();
     while (reader.pos < end) {
@@ -422,6 +780,49 @@ export const LeafOp = {
     message.length = (_object$length = object.length) !== null && _object$length !== void 0 ? _object$length : 0;
     message.prefix = (_object$prefix = object.prefix) !== null && _object$prefix !== void 0 ? _object$prefix : new Uint8Array();
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseLeafOp();
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = hashOpFromJSON(object.hash);
+    }
+    if (object.prehash_key !== undefined && object.prehash_key !== null) {
+      message.prehashKey = hashOpFromJSON(object.prehash_key);
+    }
+    if (object.prehash_value !== undefined && object.prehash_value !== null) {
+      message.prehashValue = hashOpFromJSON(object.prehash_value);
+    }
+    if (object.length !== undefined && object.length !== null) {
+      message.length = lengthOpFromJSON(object.length);
+    }
+    if (object.prefix !== undefined && object.prefix !== null) {
+      message.prefix = bytesFromBase64(object.prefix);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.hash = hashOpToJSON(message.hash);
+    obj.prehash_key = hashOpToJSON(message.prehashKey);
+    obj.prehash_value = hashOpToJSON(message.prehashValue);
+    obj.length = lengthOpToJSON(message.length);
+    obj.prefix = message.prefix ? base64FromBytes(message.prefix) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return LeafOp.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return LeafOp.decode(message.value);
+  },
+  toProto(message) {
+    return LeafOp.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.LeafOp",
+      value: LeafOp.encode(message).finish()
+    };
   }
 };
 function createBaseInnerOp() {
@@ -432,7 +833,8 @@ function createBaseInnerOp() {
   };
 }
 export const InnerOp = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.InnerOp",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.hash !== 0) {
       writer.uint32(8).int32(message.hash);
     }
@@ -445,7 +847,7 @@ export const InnerOp = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInnerOp();
     while (reader.pos < end) {
@@ -474,6 +876,41 @@ export const InnerOp = {
     message.prefix = (_object$prefix2 = object.prefix) !== null && _object$prefix2 !== void 0 ? _object$prefix2 : new Uint8Array();
     message.suffix = (_object$suffix = object.suffix) !== null && _object$suffix !== void 0 ? _object$suffix : new Uint8Array();
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseInnerOp();
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = hashOpFromJSON(object.hash);
+    }
+    if (object.prefix !== undefined && object.prefix !== null) {
+      message.prefix = bytesFromBase64(object.prefix);
+    }
+    if (object.suffix !== undefined && object.suffix !== null) {
+      message.suffix = bytesFromBase64(object.suffix);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.hash = hashOpToJSON(message.hash);
+    obj.prefix = message.prefix ? base64FromBytes(message.prefix) : undefined;
+    obj.suffix = message.suffix ? base64FromBytes(message.suffix) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return InnerOp.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return InnerOp.decode(message.value);
+  },
+  toProto(message) {
+    return InnerOp.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.InnerOp",
+      value: InnerOp.encode(message).finish()
+    };
   }
 };
 function createBaseProofSpec() {
@@ -485,7 +922,8 @@ function createBaseProofSpec() {
   };
 }
 export const ProofSpec = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.ProofSpec",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.leafSpec !== undefined) {
       LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
     }
@@ -501,7 +939,7 @@ export const ProofSpec = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseProofSpec();
     while (reader.pos < end) {
@@ -534,6 +972,45 @@ export const ProofSpec = {
     message.maxDepth = (_object$maxDepth = object.maxDepth) !== null && _object$maxDepth !== void 0 ? _object$maxDepth : 0;
     message.minDepth = (_object$minDepth = object.minDepth) !== null && _object$minDepth !== void 0 ? _object$minDepth : 0;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseProofSpec();
+    if (object.leaf_spec !== undefined && object.leaf_spec !== null) {
+      message.leafSpec = LeafOp.fromAmino(object.leaf_spec);
+    }
+    if (object.inner_spec !== undefined && object.inner_spec !== null) {
+      message.innerSpec = InnerSpec.fromAmino(object.inner_spec);
+    }
+    if (object.max_depth !== undefined && object.max_depth !== null) {
+      message.maxDepth = object.max_depth;
+    }
+    if (object.min_depth !== undefined && object.min_depth !== null) {
+      message.minDepth = object.min_depth;
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.leaf_spec = message.leafSpec ? LeafOp.toAmino(message.leafSpec) : undefined;
+    obj.inner_spec = message.innerSpec ? InnerSpec.toAmino(message.innerSpec) : undefined;
+    obj.max_depth = message.maxDepth;
+    obj.min_depth = message.minDepth;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return ProofSpec.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return ProofSpec.decode(message.value);
+  },
+  toProto(message) {
+    return ProofSpec.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.ProofSpec",
+      value: ProofSpec.encode(message).finish()
+    };
   }
 };
 function createBaseInnerSpec() {
@@ -547,7 +1024,8 @@ function createBaseInnerSpec() {
   };
 }
 export const InnerSpec = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.InnerSpec",
+  encode(message, writer = BinaryWriter.create()) {
     writer.uint32(10).fork();
     for (const v of message.childOrder) {
       writer.int32(v);
@@ -571,7 +1049,7 @@ export const InnerSpec = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInnerSpec();
     while (reader.pos < end) {
@@ -619,6 +1097,56 @@ export const InnerSpec = {
     message.emptyChild = (_object$emptyChild = object.emptyChild) !== null && _object$emptyChild !== void 0 ? _object$emptyChild : new Uint8Array();
     message.hash = (_object$hash3 = object.hash) !== null && _object$hash3 !== void 0 ? _object$hash3 : 0;
     return message;
+  },
+  fromAmino(object) {
+    var _object$child_order;
+    const message = createBaseInnerSpec();
+    message.childOrder = ((_object$child_order = object.child_order) === null || _object$child_order === void 0 ? void 0 : _object$child_order.map(e => e)) || [];
+    if (object.child_size !== undefined && object.child_size !== null) {
+      message.childSize = object.child_size;
+    }
+    if (object.min_prefix_length !== undefined && object.min_prefix_length !== null) {
+      message.minPrefixLength = object.min_prefix_length;
+    }
+    if (object.max_prefix_length !== undefined && object.max_prefix_length !== null) {
+      message.maxPrefixLength = object.max_prefix_length;
+    }
+    if (object.empty_child !== undefined && object.empty_child !== null) {
+      message.emptyChild = bytesFromBase64(object.empty_child);
+    }
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = hashOpFromJSON(object.hash);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    if (message.childOrder) {
+      obj.child_order = message.childOrder.map(e => e);
+    } else {
+      obj.child_order = [];
+    }
+    obj.child_size = message.childSize;
+    obj.min_prefix_length = message.minPrefixLength;
+    obj.max_prefix_length = message.maxPrefixLength;
+    obj.empty_child = message.emptyChild ? base64FromBytes(message.emptyChild) : undefined;
+    obj.hash = hashOpToJSON(message.hash);
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return InnerSpec.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return InnerSpec.decode(message.value);
+  },
+  toProto(message) {
+    return InnerSpec.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.InnerSpec",
+      value: InnerSpec.encode(message).finish()
+    };
   }
 };
 function createBaseBatchProof() {
@@ -627,14 +1155,15 @@ function createBaseBatchProof() {
   };
 }
 export const BatchProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.BatchProof",
+  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 _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseBatchProof();
     while (reader.pos < end) {
@@ -655,6 +1184,36 @@ export const BatchProof = {
     const message = createBaseBatchProof();
     message.entries = ((_object$entries = object.entries) === null || _object$entries === void 0 ? void 0 : _object$entries.map(e => BatchEntry.fromPartial(e))) || [];
     return message;
+  },
+  fromAmino(object) {
+    var _object$entries2;
+    const message = createBaseBatchProof();
+    message.entries = ((_object$entries2 = object.entries) === null || _object$entries2 === void 0 ? void 0 : _object$entries2.map(e => BatchEntry.fromAmino(e))) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    if (message.entries) {
+      obj.entries = message.entries.map(e => e ? BatchEntry.toAmino(e) : undefined);
+    } else {
+      obj.entries = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return BatchProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return BatchProof.decode(message.value);
+  },
+  toProto(message) {
+    return BatchProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.BatchProof",
+      value: BatchProof.encode(message).finish()
+    };
   }
 };
 function createBaseBatchEntry() {
@@ -664,7 +1223,8 @@ function createBaseBatchEntry() {
   };
 }
 export const BatchEntry = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.BatchEntry",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.exist !== undefined) {
       ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -674,7 +1234,7 @@ export const BatchEntry = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseBatchEntry();
     while (reader.pos < end) {
@@ -698,6 +1258,37 @@ export const BatchEntry = {
     message.exist = object.exist !== undefined && object.exist !== null ? ExistenceProof.fromPartial(object.exist) : undefined;
     message.nonexist = object.nonexist !== undefined && object.nonexist !== null ? NonExistenceProof.fromPartial(object.nonexist) : undefined;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseBatchEntry();
+    if (object.exist !== undefined && object.exist !== null) {
+      message.exist = ExistenceProof.fromAmino(object.exist);
+    }
+    if (object.nonexist !== undefined && object.nonexist !== null) {
+      message.nonexist = NonExistenceProof.fromAmino(object.nonexist);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.exist = message.exist ? ExistenceProof.toAmino(message.exist) : undefined;
+    obj.nonexist = message.nonexist ? NonExistenceProof.toAmino(message.nonexist) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return BatchEntry.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return BatchEntry.decode(message.value);
+  },
+  toProto(message) {
+    return BatchEntry.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.BatchEntry",
+      value: BatchEntry.encode(message).finish()
+    };
   }
 };
 function createBaseCompressedBatchProof() {
@@ -707,7 +1298,8 @@ function createBaseCompressedBatchProof() {
   };
 }
 export const CompressedBatchProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.CompressedBatchProof",
+  encode(message, writer = BinaryWriter.create()) {
     for (const v of message.entries) {
       CompressedBatchEntry.encode(v, writer.uint32(10).fork()).ldelim();
     }
@@ -717,7 +1309,7 @@ export const CompressedBatchProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCompressedBatchProof();
     while (reader.pos < end) {
@@ -737,11 +1329,47 @@ export const CompressedBatchProof = {
     return message;
   },
   fromPartial(object) {
-    var _object$entries2, _object$lookupInners;
+    var _object$entries3, _object$lookupInners;
     const message = createBaseCompressedBatchProof();
-    message.entries = ((_object$entries2 = object.entries) === null || _object$entries2 === void 0 ? void 0 : _object$entries2.map(e => CompressedBatchEntry.fromPartial(e))) || [];
+    message.entries = ((_object$entries3 = object.entries) === null || _object$entries3 === void 0 ? void 0 : _object$entries3.map(e => CompressedBatchEntry.fromPartial(e))) || [];
     message.lookupInners = ((_object$lookupInners = object.lookupInners) === null || _object$lookupInners === void 0 ? void 0 : _object$lookupInners.map(e => InnerOp.fromPartial(e))) || [];
     return message;
+  },
+  fromAmino(object) {
+    var _object$entries4, _object$lookup_inners;
+    const message = createBaseCompressedBatchProof();
+    message.entries = ((_object$entries4 = object.entries) === null || _object$entries4 === void 0 ? void 0 : _object$entries4.map(e => CompressedBatchEntry.fromAmino(e))) || [];
+    message.lookupInners = ((_object$lookup_inners = object.lookup_inners) === null || _object$lookup_inners === void 0 ? void 0 : _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) : undefined);
+    } else {
+      obj.entries = [];
+    }
+    if (message.lookupInners) {
+      obj.lookup_inners = message.lookupInners.map(e => e ? InnerOp.toAmino(e) : undefined);
+    } else {
+      obj.lookup_inners = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return CompressedBatchProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return CompressedBatchProof.decode(message.value);
+  },
+  toProto(message) {
+    return CompressedBatchProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedBatchProof",
+      value: CompressedBatchProof.encode(message).finish()
+    };
   }
 };
 function createBaseCompressedBatchEntry() {
@@ -751,7 +1379,8 @@ function createBaseCompressedBatchEntry() {
   };
 }
 export const CompressedBatchEntry = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.CompressedBatchEntry",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.exist !== undefined) {
       CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -761,7 +1390,7 @@ export const CompressedBatchEntry = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCompressedBatchEntry();
     while (reader.pos < end) {
@@ -785,6 +1414,37 @@ export const CompressedBatchEntry = {
     message.exist = object.exist !== undefined && object.exist !== null ? CompressedExistenceProof.fromPartial(object.exist) : undefined;
     message.nonexist = object.nonexist !== undefined && object.nonexist !== null ? CompressedNonExistenceProof.fromPartial(object.nonexist) : undefined;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseCompressedBatchEntry();
+    if (object.exist !== undefined && object.exist !== null) {
+      message.exist = CompressedExistenceProof.fromAmino(object.exist);
+    }
+    if (object.nonexist !== undefined && object.nonexist !== null) {
+      message.nonexist = CompressedNonExistenceProof.fromAmino(object.nonexist);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.exist = message.exist ? CompressedExistenceProof.toAmino(message.exist) : undefined;
+    obj.nonexist = message.nonexist ? CompressedNonExistenceProof.toAmino(message.nonexist) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return CompressedBatchEntry.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return CompressedBatchEntry.decode(message.value);
+  },
+  toProto(message) {
+    return CompressedBatchEntry.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedBatchEntry",
+      value: CompressedBatchEntry.encode(message).finish()
+    };
   }
 };
 function createBaseCompressedExistenceProof() {
@@ -796,7 +1456,8 @@ function createBaseCompressedExistenceProof() {
   };
 }
 export const CompressedExistenceProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.CompressedExistenceProof",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -814,7 +1475,7 @@ export const CompressedExistenceProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCompressedExistenceProof();
     while (reader.pos < end) {
@@ -847,13 +1508,55 @@ export const CompressedExistenceProof = {
     return message;
   },
   fromPartial(object) {
-    var _object$key3, _object$value2, _object$path2;
+    var _object$key3, _object$value2, _object$path3;
     const message = createBaseCompressedExistenceProof();
     message.key = (_object$key3 = object.key) !== null && _object$key3 !== void 0 ? _object$key3 : new Uint8Array();
     message.value = (_object$value2 = object.value) !== null && _object$value2 !== void 0 ? _object$value2 : new Uint8Array();
     message.leaf = object.leaf !== undefined && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : undefined;
-    message.path = ((_object$path2 = object.path) === null || _object$path2 === void 0 ? void 0 : _object$path2.map(e => e)) || [];
+    message.path = ((_object$path3 = object.path) === null || _object$path3 === void 0 ? void 0 : _object$path3.map(e => e)) || [];
+    return message;
+  },
+  fromAmino(object) {
+    var _object$path4;
+    const message = createBaseCompressedExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = bytesFromBase64(object.value);
+    }
+    if (object.leaf !== undefined && object.leaf !== null) {
+      message.leaf = LeafOp.fromAmino(object.leaf);
+    }
+    message.path = ((_object$path4 = object.path) === null || _object$path4 === void 0 ? void 0 : _object$path4.map(e => e)) || [];
     return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.value = message.value ? base64FromBytes(message.value) : undefined;
+    obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : undefined;
+    if (message.path) {
+      obj.path = message.path.map(e => e);
+    } else {
+      obj.path = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return CompressedExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return CompressedExistenceProof.decode(message.value);
+  },
+  toProto(message) {
+    return CompressedExistenceProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedExistenceProof",
+      value: CompressedExistenceProof.encode(message).finish()
+    };
   }
 };
 function createBaseCompressedNonExistenceProof() {
@@ -864,7 +1567,8 @@ function createBaseCompressedNonExistenceProof() {
   };
 }
 export const CompressedNonExistenceProof = {
-  encode(message, writer = _m0.Writer.create()) {
+  typeUrl: "/ics23.CompressedNonExistenceProof",
+  encode(message, writer = BinaryWriter.create()) {
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -877,7 +1581,7 @@ export const CompressedNonExistenceProof = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCompressedNonExistenceProof();
     while (reader.pos < end) {
@@ -906,5 +1610,40 @@ export const CompressedNonExistenceProof = {
     message.left = object.left !== undefined && object.left !== null ? CompressedExistenceProof.fromPartial(object.left) : undefined;
     message.right = object.right !== undefined && object.right !== null ? CompressedExistenceProof.fromPartial(object.right) : undefined;
     return message;
+  },
+  fromAmino(object) {
+    const message = createBaseCompressedNonExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.left !== undefined && object.left !== null) {
+      message.left = CompressedExistenceProof.fromAmino(object.left);
+    }
+    if (object.right !== undefined && object.right !== null) {
+      message.right = CompressedExistenceProof.fromAmino(object.right);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.left = message.left ? CompressedExistenceProof.toAmino(message.left) : undefined;
+    obj.right = message.right ? CompressedExistenceProof.toAmino(message.right) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return CompressedNonExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return CompressedNonExistenceProof.decode(message.value);
+  },
+  toProto(message) {
+    return CompressedNonExistenceProof.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedNonExistenceProof",
+      value: CompressedNonExistenceProof.encode(message).finish()
+    };
   }
 };