juno-network 0.15.0 → 0.17.0

package/main/codegen/confio/proofs.js

@@ -1,23 +1,19 @@
 "use strict";
 
-var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ProofSpec = exports.NonExistenceProof = exports.LengthOpSDKType = exports.LengthOp = exports.LeafOp = exports.InnerSpec = exports.InnerOp = exports.HashOpSDKType = exports.HashOp = exports.ExistenceProof = exports.CompressedNonExistenceProof = exports.CompressedExistenceProof = exports.CompressedBatchProof = exports.CompressedBatchEntry = exports.CommitmentProof = exports.BatchProof = exports.BatchEntry = void 0;
+exports.ProofSpec = exports.NonExistenceProof = exports.LengthOpSDKType = exports.LengthOpAmino = exports.LengthOp = exports.LeafOp = exports.InnerSpec = exports.InnerOp = exports.HashOpSDKType = exports.HashOpAmino = exports.HashOp = exports.ExistenceProof = exports.CompressedNonExistenceProof = exports.CompressedExistenceProof = exports.CompressedBatchProof = exports.CompressedBatchEntry = exports.CommitmentProof = exports.BatchProof = exports.BatchEntry = void 0;
 exports.hashOpFromJSON = hashOpFromJSON;
 exports.hashOpToJSON = hashOpToJSON;
 exports.lengthOpFromJSON = lengthOpFromJSON;
 exports.lengthOpToJSON = lengthOpToJSON;
-var _m0 = _interopRequireWildcard(require("protobufjs/minimal"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _binary = require("../binary");
+var _helpers = require("../helpers");
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-var HashOp;
-exports.HashOp = HashOp;
-(function (HashOp) {
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var HashOp = /*#__PURE__*/function (HashOp) {
   HashOp[HashOp["NO_HASH"] = 0] = "NO_HASH";
   HashOp[HashOp["SHA256"] = 1] = "SHA256";
   HashOp[HashOp["SHA512"] = 2] = "SHA512";
@@ -25,18 +21,13 @@ exports.HashOp = HashOp;
   HashOp[HashOp["RIPEMD160"] = 4] = "RIPEMD160";
   HashOp[HashOp["BITCOIN"] = 5] = "BITCOIN";
   HashOp[HashOp["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(HashOp || (exports.HashOp = HashOp = {}));
-var HashOpSDKType;
+  return HashOp;
+}({});
+exports.HashOp = HashOp;
+var HashOpSDKType = HashOp;
 exports.HashOpSDKType = 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 || (exports.HashOpSDKType = HashOpSDKType = {}));
+var HashOpAmino = HashOp;
+exports.HashOpAmino = HashOpAmino;
 function hashOpFromJSON(object) {
   switch (object) {
     case 0:
@@ -88,14 +79,7 @@ function hashOpToJSON(object) {
  * algorithm, the length will be prepended to the key and value bytes.
  * (Each one with it's own encoded length)
  */
-var 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)
-               */
-exports.LengthOp = LengthOp;
-(function (LengthOp) {
+var 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";
@@ -106,21 +90,13 @@ exports.LengthOp = 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 || (exports.LengthOp = LengthOp = {}));
-var LengthOpSDKType;
+  return LengthOp;
+}({});
+exports.LengthOp = LengthOp;
+var LengthOpSDKType = LengthOp;
 exports.LengthOpSDKType = 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 || (exports.LengthOpSDKType = LengthOpSDKType = {}));
+var LengthOpAmino = LengthOp;
+exports.LengthOpAmino = LengthOpAmino;
 function lengthOpFromJSON(object) {
   switch (object) {
     case 0:
@@ -203,6 +179,269 @@ 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(),
@@ -212,8 +451,9 @@ function createBaseExistenceProof() {
   };
 }
 var ExistenceProof = {
+  typeUrl: "/ics23.ExistenceProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -238,7 +478,7 @@ var ExistenceProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseExistenceProof();
     while (reader.pos < end) {
@@ -273,6 +513,52 @@ var ExistenceProof = {
       return InnerOp.fromPartial(e);
     })) || [];
     return message;
+  },
+  fromAmino: function fromAmino(object) {
+    var _object$path2;
+    var message = createBaseExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = (0, _helpers.bytesFromBase64)(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = (0, _helpers.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(function (e) {
+      return InnerOp.fromAmino(e);
+    })) || [];
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    obj.key = message.key ? (0, _helpers.base64FromBytes)(message.key) : undefined;
+    obj.value = message.value ? (0, _helpers.base64FromBytes)(message.value) : undefined;
+    obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : undefined;
+    if (message.path) {
+      obj.path = message.path.map(function (e) {
+        return e ? InnerOp.toAmino(e) : undefined;
+      });
+    } else {
+      obj.path = [];
+    }
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return ExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return ExistenceProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return ExistenceProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.ExistenceProof",
+      value: ExistenceProof.encode(message).finish()
+    };
   }
 };
 exports.ExistenceProof = ExistenceProof;
@@ -284,8 +570,9 @@ function createBaseNonExistenceProof() {
   };
 }
 var NonExistenceProof = {
+  typeUrl: "/ics23.NonExistenceProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -298,7 +585,7 @@ var NonExistenceProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseNonExistenceProof();
     while (reader.pos < end) {
@@ -327,6 +614,41 @@ var 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: function fromAmino(object) {
+    var message = createBaseNonExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = (0, _helpers.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: function toAmino(message) {
+    var obj = {};
+    obj.key = message.key ? (0, _helpers.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: function fromAminoMsg(object) {
+    return NonExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return NonExistenceProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return NonExistenceProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.NonExistenceProof",
+      value: NonExistenceProof.encode(message).finish()
+    };
   }
 };
 exports.NonExistenceProof = NonExistenceProof;
@@ -339,8 +661,9 @@ function createBaseCommitmentProof() {
   };
 }
 var CommitmentProof = {
+  typeUrl: "/ics23.CommitmentProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.exist !== undefined) {
       ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -356,7 +679,7 @@ var CommitmentProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseCommitmentProof();
     while (reader.pos < end) {
@@ -388,6 +711,45 @@ var 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: function fromAmino(object) {
+    var 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: function toAmino(message) {
+    var 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: function fromAminoMsg(object) {
+    return CommitmentProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return CommitmentProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return CommitmentProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CommitmentProof",
+      value: CommitmentProof.encode(message).finish()
+    };
   }
 };
 exports.CommitmentProof = CommitmentProof;
@@ -401,8 +763,9 @@ function createBaseLeafOp() {
   };
 }
 var LeafOp = {
+  typeUrl: "/ics23.LeafOp",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.hash !== 0) {
       writer.uint32(8).int32(message.hash);
     }
@@ -421,7 +784,7 @@ var LeafOp = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseLeafOp();
     while (reader.pos < end) {
@@ -458,6 +821,49 @@ var 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: function fromAmino(object) {
+    var 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 = (0, _helpers.bytesFromBase64)(object.prefix);
+    }
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var 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 ? (0, _helpers.base64FromBytes)(message.prefix) : undefined;
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return LeafOp.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return LeafOp.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return LeafOp.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.LeafOp",
+      value: LeafOp.encode(message).finish()
+    };
   }
 };
 exports.LeafOp = LeafOp;
@@ -469,8 +875,9 @@ function createBaseInnerOp() {
   };
 }
 var InnerOp = {
+  typeUrl: "/ics23.InnerOp",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.hash !== 0) {
       writer.uint32(8).int32(message.hash);
     }
@@ -483,7 +890,7 @@ var InnerOp = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseInnerOp();
     while (reader.pos < end) {
@@ -512,6 +919,41 @@ var 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: function fromAmino(object) {
+    var message = createBaseInnerOp();
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = hashOpFromJSON(object.hash);
+    }
+    if (object.prefix !== undefined && object.prefix !== null) {
+      message.prefix = (0, _helpers.bytesFromBase64)(object.prefix);
+    }
+    if (object.suffix !== undefined && object.suffix !== null) {
+      message.suffix = (0, _helpers.bytesFromBase64)(object.suffix);
+    }
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    obj.hash = hashOpToJSON(message.hash);
+    obj.prefix = message.prefix ? (0, _helpers.base64FromBytes)(message.prefix) : undefined;
+    obj.suffix = message.suffix ? (0, _helpers.base64FromBytes)(message.suffix) : undefined;
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return InnerOp.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return InnerOp.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return InnerOp.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.InnerOp",
+      value: InnerOp.encode(message).finish()
+    };
   }
 };
 exports.InnerOp = InnerOp;
@@ -524,8 +966,9 @@ function createBaseProofSpec() {
   };
 }
 var ProofSpec = {
+  typeUrl: "/ics23.ProofSpec",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.leafSpec !== undefined) {
       LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
     }
@@ -541,7 +984,7 @@ var ProofSpec = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseProofSpec();
     while (reader.pos < end) {
@@ -574,6 +1017,45 @@ var 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: function fromAmino(object) {
+    var 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: function toAmino(message) {
+    var 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: function fromAminoMsg(object) {
+    return ProofSpec.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return ProofSpec.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return ProofSpec.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.ProofSpec",
+      value: ProofSpec.encode(message).finish()
+    };
   }
 };
 exports.ProofSpec = ProofSpec;
@@ -588,8 +1070,9 @@ function createBaseInnerSpec() {
   };
 }
 var InnerSpec = {
+  typeUrl: "/ics23.InnerSpec",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     writer.uint32(10).fork();
     var _iterator2 = _createForOfIteratorHelper(message.childOrder),
       _step2;
@@ -622,7 +1105,7 @@ var InnerSpec = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseInnerSpec();
     while (reader.pos < end) {
@@ -672,6 +1155,60 @@ var 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: function fromAmino(object) {
+    var _object$child_order;
+    var message = createBaseInnerSpec();
+    message.childOrder = ((_object$child_order = object.child_order) === null || _object$child_order === void 0 ? void 0 : _object$child_order.map(function (e) {
+      return 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 = (0, _helpers.bytesFromBase64)(object.empty_child);
+    }
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = hashOpFromJSON(object.hash);
+    }
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    if (message.childOrder) {
+      obj.child_order = message.childOrder.map(function (e) {
+        return 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 ? (0, _helpers.base64FromBytes)(message.emptyChild) : undefined;
+    obj.hash = hashOpToJSON(message.hash);
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return InnerSpec.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return InnerSpec.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return InnerSpec.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.InnerSpec",
+      value: InnerSpec.encode(message).finish()
+    };
   }
 };
 exports.InnerSpec = InnerSpec;
@@ -681,8 +1218,9 @@ function createBaseBatchProof() {
   };
 }
 var BatchProof = {
+  typeUrl: "/ics23.BatchProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     var _iterator3 = _createForOfIteratorHelper(message.entries),
       _step3;
     try {
@@ -698,7 +1236,7 @@ var BatchProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseBatchProof();
     while (reader.pos < end) {
@@ -721,6 +1259,40 @@ var BatchProof = {
       return BatchEntry.fromPartial(e);
     })) || [];
     return message;
+  },
+  fromAmino: function fromAmino(object) {
+    var _object$entries2;
+    var message = createBaseBatchProof();
+    message.entries = ((_object$entries2 = object.entries) === null || _object$entries2 === void 0 ? void 0 : _object$entries2.map(function (e) {
+      return BatchEntry.fromAmino(e);
+    })) || [];
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    if (message.entries) {
+      obj.entries = message.entries.map(function (e) {
+        return e ? BatchEntry.toAmino(e) : undefined;
+      });
+    } else {
+      obj.entries = [];
+    }
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return BatchProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return BatchProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return BatchProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.BatchProof",
+      value: BatchProof.encode(message).finish()
+    };
   }
 };
 exports.BatchProof = BatchProof;
@@ -731,8 +1303,9 @@ function createBaseBatchEntry() {
   };
 }
 var BatchEntry = {
+  typeUrl: "/ics23.BatchEntry",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.exist !== undefined) {
       ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -742,7 +1315,7 @@ var BatchEntry = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseBatchEntry();
     while (reader.pos < end) {
@@ -766,6 +1339,37 @@ var 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: function fromAmino(object) {
+    var 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: function toAmino(message) {
+    var obj = {};
+    obj.exist = message.exist ? ExistenceProof.toAmino(message.exist) : undefined;
+    obj.nonexist = message.nonexist ? NonExistenceProof.toAmino(message.nonexist) : undefined;
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return BatchEntry.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return BatchEntry.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return BatchEntry.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.BatchEntry",
+      value: BatchEntry.encode(message).finish()
+    };
   }
 };
 exports.BatchEntry = BatchEntry;
@@ -776,8 +1380,9 @@ function createBaseCompressedBatchProof() {
   };
 }
 var CompressedBatchProof = {
+  typeUrl: "/ics23.CompressedBatchProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     var _iterator4 = _createForOfIteratorHelper(message.entries),
       _step4;
     try {
@@ -805,7 +1410,7 @@ var CompressedBatchProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseCompressedBatchProof();
     while (reader.pos < end) {
@@ -825,15 +1430,59 @@ var CompressedBatchProof = {
     return message;
   },
   fromPartial: function fromPartial(object) {
-    var _object$entries2, _object$lookupInners;
+    var _object$entries3, _object$lookupInners;
     var message = createBaseCompressedBatchProof();
-    message.entries = ((_object$entries2 = object.entries) === null || _object$entries2 === void 0 ? void 0 : _object$entries2.map(function (e) {
+    message.entries = ((_object$entries3 = object.entries) === null || _object$entries3 === void 0 ? void 0 : _object$entries3.map(function (e) {
       return CompressedBatchEntry.fromPartial(e);
     })) || [];
     message.lookupInners = ((_object$lookupInners = object.lookupInners) === null || _object$lookupInners === void 0 ? void 0 : _object$lookupInners.map(function (e) {
       return InnerOp.fromPartial(e);
     })) || [];
     return message;
+  },
+  fromAmino: function fromAmino(object) {
+    var _object$entries4, _object$lookup_inners;
+    var message = createBaseCompressedBatchProof();
+    message.entries = ((_object$entries4 = object.entries) === null || _object$entries4 === void 0 ? void 0 : _object$entries4.map(function (e) {
+      return CompressedBatchEntry.fromAmino(e);
+    })) || [];
+    message.lookupInners = ((_object$lookup_inners = object.lookup_inners) === null || _object$lookup_inners === void 0 ? void 0 : _object$lookup_inners.map(function (e) {
+      return InnerOp.fromAmino(e);
+    })) || [];
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    if (message.entries) {
+      obj.entries = message.entries.map(function (e) {
+        return e ? CompressedBatchEntry.toAmino(e) : undefined;
+      });
+    } else {
+      obj.entries = [];
+    }
+    if (message.lookupInners) {
+      obj.lookup_inners = message.lookupInners.map(function (e) {
+        return e ? InnerOp.toAmino(e) : undefined;
+      });
+    } else {
+      obj.lookup_inners = [];
+    }
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return CompressedBatchProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return CompressedBatchProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return CompressedBatchProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedBatchProof",
+      value: CompressedBatchProof.encode(message).finish()
+    };
   }
 };
 exports.CompressedBatchProof = CompressedBatchProof;
@@ -844,8 +1493,9 @@ function createBaseCompressedBatchEntry() {
   };
 }
 var CompressedBatchEntry = {
+  typeUrl: "/ics23.CompressedBatchEntry",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.exist !== undefined) {
       CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
     }
@@ -855,7 +1505,7 @@ var CompressedBatchEntry = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseCompressedBatchEntry();
     while (reader.pos < end) {
@@ -879,6 +1529,37 @@ var 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: function fromAmino(object) {
+    var 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: function toAmino(message) {
+    var obj = {};
+    obj.exist = message.exist ? CompressedExistenceProof.toAmino(message.exist) : undefined;
+    obj.nonexist = message.nonexist ? CompressedNonExistenceProof.toAmino(message.nonexist) : undefined;
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return CompressedBatchEntry.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return CompressedBatchEntry.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return CompressedBatchEntry.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedBatchEntry",
+      value: CompressedBatchEntry.encode(message).finish()
+    };
   }
 };
 exports.CompressedBatchEntry = CompressedBatchEntry;
@@ -891,8 +1572,9 @@ function createBaseCompressedExistenceProof() {
   };
 }
 var CompressedExistenceProof = {
+  typeUrl: "/ics23.CompressedExistenceProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -919,7 +1601,7 @@ var CompressedExistenceProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseCompressedExistenceProof();
     while (reader.pos < end) {
@@ -952,15 +1634,61 @@ var CompressedExistenceProof = {
     return message;
   },
   fromPartial: function fromPartial(object) {
-    var _object$key3, _object$value2, _object$path2;
+    var _object$key3, _object$value2, _object$path3;
     var 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(function (e) {
+    message.path = ((_object$path3 = object.path) === null || _object$path3 === void 0 ? void 0 : _object$path3.map(function (e) {
       return e;
     })) || [];
     return message;
+  },
+  fromAmino: function fromAmino(object) {
+    var _object$path4;
+    var message = createBaseCompressedExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = (0, _helpers.bytesFromBase64)(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = (0, _helpers.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(function (e) {
+      return e;
+    })) || [];
+    return message;
+  },
+  toAmino: function toAmino(message) {
+    var obj = {};
+    obj.key = message.key ? (0, _helpers.base64FromBytes)(message.key) : undefined;
+    obj.value = message.value ? (0, _helpers.base64FromBytes)(message.value) : undefined;
+    obj.leaf = message.leaf ? LeafOp.toAmino(message.leaf) : undefined;
+    if (message.path) {
+      obj.path = message.path.map(function (e) {
+        return e;
+      });
+    } else {
+      obj.path = [];
+    }
+    return obj;
+  },
+  fromAminoMsg: function fromAminoMsg(object) {
+    return CompressedExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return CompressedExistenceProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return CompressedExistenceProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedExistenceProof",
+      value: CompressedExistenceProof.encode(message).finish()
+    };
   }
 };
 exports.CompressedExistenceProof = CompressedExistenceProof;
@@ -972,8 +1700,9 @@ function createBaseCompressedNonExistenceProof() {
   };
 }
 var CompressedNonExistenceProof = {
+  typeUrl: "/ics23.CompressedNonExistenceProof",
   encode: function encode(message) {
-    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _m0.Writer.create();
+    var writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _binary.BinaryWriter.create();
     if (message.key.length !== 0) {
       writer.uint32(10).bytes(message.key);
     }
@@ -986,7 +1715,7 @@ var CompressedNonExistenceProof = {
     return writer;
   },
   decode: function decode(input, length) {
-    var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    var reader = input instanceof _binary.BinaryReader ? input : new _binary.BinaryReader(input);
     var end = length === undefined ? reader.len : reader.pos + length;
     var message = createBaseCompressedNonExistenceProof();
     while (reader.pos < end) {
@@ -1015,6 +1744,41 @@ var 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: function fromAmino(object) {
+    var message = createBaseCompressedNonExistenceProof();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = (0, _helpers.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: function toAmino(message) {
+    var obj = {};
+    obj.key = message.key ? (0, _helpers.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: function fromAminoMsg(object) {
+    return CompressedNonExistenceProof.fromAmino(object.value);
+  },
+  fromProtoMsg: function fromProtoMsg(message) {
+    return CompressedNonExistenceProof.decode(message.value);
+  },
+  toProto: function toProto(message) {
+    return CompressedNonExistenceProof.encode(message).finish();
+  },
+  toProtoMsg: function toProtoMsg(message) {
+    return {
+      typeUrl: "/ics23.CompressedNonExistenceProof",
+      value: CompressedNonExistenceProof.encode(message).finish()
+    };
   }
 };
 exports.CompressedNonExistenceProof = CompressedNonExistenceProof;