juno-network 0.5.3 → 0.6.0

package/src/codegen/confio/proofs.ts

@@ -0,0 +1,1521 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+export enum HashOp {
+  /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
+  NO_HASH = 0,
+  SHA256 = 1,
+  SHA512 = 2,
+  KECCAK = 3,
+  RIPEMD160 = 4,
+
+  /** BITCOIN - ripemd160(sha256(x)) */
+  BITCOIN = 5,
+  UNRECOGNIZED = -1,
+}
+export enum HashOpSDKType {
+  /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
+  NO_HASH = 0,
+  SHA256 = 1,
+  SHA512 = 2,
+  KECCAK = 3,
+  RIPEMD160 = 4,
+
+  /** BITCOIN - ripemd160(sha256(x)) */
+  BITCOIN = 5,
+  UNRECOGNIZED = -1,
+}
+export function hashOpFromJSON(object: any): HashOp {
+  switch (object) {
+    case 0:
+    case "NO_HASH":
+      return HashOp.NO_HASH;
+
+    case 1:
+    case "SHA256":
+      return HashOp.SHA256;
+
+    case 2:
+    case "SHA512":
+      return HashOp.SHA512;
+
+    case 3:
+    case "KECCAK":
+      return HashOp.KECCAK;
+
+    case 4:
+    case "RIPEMD160":
+      return HashOp.RIPEMD160;
+
+    case 5:
+    case "BITCOIN":
+      return HashOp.BITCOIN;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return HashOp.UNRECOGNIZED;
+  }
+}
+export function hashOpToJSON(object: HashOp): string {
+  switch (object) {
+    case HashOp.NO_HASH:
+      return "NO_HASH";
+
+    case HashOp.SHA256:
+      return "SHA256";
+
+    case HashOp.SHA512:
+      return "SHA512";
+
+    case HashOp.KECCAK:
+      return "KECCAK";
+
+    case HashOp.RIPEMD160:
+      return "RIPEMD160";
+
+    case HashOp.BITCOIN:
+      return "BITCOIN";
+
+    default:
+      return "UNKNOWN";
+  }
+}
+/**
+ * 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)
+ */
+
+export enum LengthOp {
+  /** NO_PREFIX - NO_PREFIX don't include any length info */
+  NO_PREFIX = 0,
+
+  /** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length */
+  VAR_PROTO = 1,
+
+  /** VAR_RLP - VAR_RLP uses rlp int encoding of the length */
+  VAR_RLP = 2,
+
+  /** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer */
+  FIXED32_BIG = 3,
+
+  /** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer */
+  FIXED32_LITTLE = 4,
+
+  /** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer */
+  FIXED64_BIG = 5,
+
+  /** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer */
+  FIXED64_LITTLE = 6,
+
+  /** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) */
+  REQUIRE_32_BYTES = 7,
+
+  /** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) */
+  REQUIRE_64_BYTES = 8,
+  UNRECOGNIZED = -1,
+}
+/**
+ * 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)
+ */
+
+export enum LengthOpSDKType {
+  /** NO_PREFIX - NO_PREFIX don't include any length info */
+  NO_PREFIX = 0,
+
+  /** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length */
+  VAR_PROTO = 1,
+
+  /** VAR_RLP - VAR_RLP uses rlp int encoding of the length */
+  VAR_RLP = 2,
+
+  /** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer */
+  FIXED32_BIG = 3,
+
+  /** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer */
+  FIXED32_LITTLE = 4,
+
+  /** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer */
+  FIXED64_BIG = 5,
+
+  /** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer */
+  FIXED64_LITTLE = 6,
+
+  /** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) */
+  REQUIRE_32_BYTES = 7,
+
+  /** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) */
+  REQUIRE_64_BYTES = 8,
+  UNRECOGNIZED = -1,
+}
+export function lengthOpFromJSON(object: any): LengthOp {
+  switch (object) {
+    case 0:
+    case "NO_PREFIX":
+      return LengthOp.NO_PREFIX;
+
+    case 1:
+    case "VAR_PROTO":
+      return LengthOp.VAR_PROTO;
+
+    case 2:
+    case "VAR_RLP":
+      return LengthOp.VAR_RLP;
+
+    case 3:
+    case "FIXED32_BIG":
+      return LengthOp.FIXED32_BIG;
+
+    case 4:
+    case "FIXED32_LITTLE":
+      return LengthOp.FIXED32_LITTLE;
+
+    case 5:
+    case "FIXED64_BIG":
+      return LengthOp.FIXED64_BIG;
+
+    case 6:
+    case "FIXED64_LITTLE":
+      return LengthOp.FIXED64_LITTLE;
+
+    case 7:
+    case "REQUIRE_32_BYTES":
+      return LengthOp.REQUIRE_32_BYTES;
+
+    case 8:
+    case "REQUIRE_64_BYTES":
+      return LengthOp.REQUIRE_64_BYTES;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return LengthOp.UNRECOGNIZED;
+  }
+}
+export function lengthOpToJSON(object: LengthOp): string {
+  switch (object) {
+    case LengthOp.NO_PREFIX:
+      return "NO_PREFIX";
+
+    case LengthOp.VAR_PROTO:
+      return "VAR_PROTO";
+
+    case LengthOp.VAR_RLP:
+      return "VAR_RLP";
+
+    case LengthOp.FIXED32_BIG:
+      return "FIXED32_BIG";
+
+    case LengthOp.FIXED32_LITTLE:
+      return "FIXED32_LITTLE";
+
+    case LengthOp.FIXED64_BIG:
+      return "FIXED64_BIG";
+
+    case LengthOp.FIXED64_LITTLE:
+      return "FIXED64_LITTLE";
+
+    case LengthOp.REQUIRE_32_BYTES:
+      return "REQUIRE_32_BYTES";
+
+    case LengthOp.REQUIRE_64_BYTES:
+      return "REQUIRE_64_BYTES";
+
+    default:
+      return "UNKNOWN";
+  }
+}
+/**
+ * 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.
+ */
+
+export interface ExistenceProof {
+  key: Uint8Array;
+  value: Uint8Array;
+  leaf: LeafOp;
+  path: InnerOp[];
+}
+/**
+ * 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.
+ */
+
+export interface ExistenceProofSDKType {
+  key: Uint8Array;
+  value: Uint8Array;
+  leaf: LeafOpSDKType;
+  path: InnerOpSDKType[];
+}
+/**
+ * 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.
+ */
+
+export interface NonExistenceProof {
+  /** TODO: remove this as unnecessary??? we prove a range */
+  key: Uint8Array;
+  left: ExistenceProof;
+  right: ExistenceProof;
+}
+/**
+ * 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.
+ */
+
+export interface NonExistenceProofSDKType {
+  /** TODO: remove this as unnecessary??? we prove a range */
+  key: Uint8Array;
+  left: ExistenceProofSDKType;
+  right: ExistenceProofSDKType;
+}
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+
+export interface CommitmentProof {
+  exist?: ExistenceProof;
+  nonexist?: NonExistenceProof;
+  batch?: BatchProof;
+  compressed?: CompressedBatchProof;
+}
+/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+
+export interface CommitmentProofSDKType {
+  exist?: ExistenceProofSDKType;
+  nonexist?: NonExistenceProofSDKType;
+  batch?: BatchProofSDKType;
+  compressed?: CompressedBatchProofSDKType;
+}
+/**
+ * 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)
+ */
+
+export interface LeafOp {
+  hash: HashOp;
+  prehashKey: HashOp;
+  prehashValue: HashOp;
+  length: LengthOp;
+  /**
+   * prefix is a fixed bytes that may optionally be included at the beginning to differentiate
+   * a leaf node from an inner node.
+   */
+
+  prefix: Uint8Array;
+}
+/**
+ * LeafOp represents the raw key-value data we wish to prove, and
+ * must be flexible to represent the internal transformation from
+ * the original key-value pairs into the basis hash, for many existing
+ * merkle trees.
+ * 
+ * key and value are passed in. So that the signature of this operation is:
+ * leafOp(key, value) -> output
+ * 
+ * To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+ * hkey = prehashKey(key)
+ * hvalue = prehashValue(value)
+ * 
+ * Then combine the bytes, and hash it
+ * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ */
+
+export interface LeafOpSDKType {
+  hash: HashOpSDKType;
+  prehash_key: HashOpSDKType;
+  prehash_value: HashOpSDKType;
+  length: LengthOpSDKType;
+  /**
+   * prefix is a fixed bytes that may optionally be included at the beginning to differentiate
+   * a leaf node from an inner node.
+   */
+
+  prefix: Uint8Array;
+}
+/**
+ * InnerOp represents a merkle-proof step that is not a leaf.
+ * It represents concatenating two children and hashing them to provide the next result.
+ * 
+ * The result of the previous step is passed in, so the signature of this op is:
+ * innerOp(child) -> output
+ * 
+ * The result of applying InnerOp should be:
+ * output = op.hash(op.prefix || child || op.suffix)
+ * 
+ * where the || operator is concatenation of binary data,
+ * and child is the result of hashing all the tree below this step.
+ * 
+ * Any special data, like prepending child with the length, or prepending the entire operation with
+ * some value to differentiate from leaf nodes, should be included in prefix and suffix.
+ * If either of prefix or suffix is empty, we just treat it as an empty string
+ */
+
+export interface InnerOp {
+  hash: HashOp;
+  prefix: Uint8Array;
+  suffix: Uint8Array;
+}
+/**
+ * InnerOp represents a merkle-proof step that is not a leaf.
+ * It represents concatenating two children and hashing them to provide the next result.
+ * 
+ * The result of the previous step is passed in, so the signature of this op is:
+ * innerOp(child) -> output
+ * 
+ * The result of applying InnerOp should be:
+ * output = op.hash(op.prefix || child || op.suffix)
+ * 
+ * where the || operator is concatenation of binary data,
+ * and child is the result of hashing all the tree below this step.
+ * 
+ * Any special data, like prepending child with the length, or prepending the entire operation with
+ * some value to differentiate from leaf nodes, should be included in prefix and suffix.
+ * If either of prefix or suffix is empty, we just treat it as an empty string
+ */
+
+export interface InnerOpSDKType {
+  hash: HashOpSDKType;
+  prefix: Uint8Array;
+  suffix: Uint8Array;
+}
+/**
+ * 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.
+ */
+
+export interface ProofSpec {
+  /**
+   * any field in the ExistenceProof must be the same as in this spec.
+   * except Prefix, which is just the first bytes of prefix (spec can be longer)
+   */
+  leafSpec: LeafOp;
+  innerSpec: InnerSpec;
+  /** max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) */
+
+  maxDepth: number;
+  /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
+
+  minDepth: number;
+}
+/**
+ * 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.
+ */
+
+export interface ProofSpecSDKType {
+  /**
+   * any field in the ExistenceProof must be the same as in this spec.
+   * except Prefix, which is just the first bytes of prefix (spec can be longer)
+   */
+  leaf_spec: LeafOpSDKType;
+  inner_spec: InnerSpecSDKType;
+  /** max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) */
+
+  max_depth: number;
+  /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
+
+  min_depth: number;
+}
+/**
+ * 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)
+ */
+
+export interface InnerSpec {
+  /**
+   * Child order is the ordering of the children node, must count from 0
+   * iavl tree is [0, 1] (left then right)
+   * merk is [0, 2, 1] (left, right, here)
+   */
+  childOrder: number[];
+  childSize: number;
+  minPrefixLength: number;
+  maxPrefixLength: number;
+  /** empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) */
+
+  emptyChild: Uint8Array;
+  /** hash is the algorithm that must be used for each InnerOp */
+
+  hash: HashOp;
+}
+/**
+ * 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)
+ */
+
+export interface InnerSpecSDKType {
+  /**
+   * Child order is the ordering of the children node, must count from 0
+   * iavl tree is [0, 1] (left then right)
+   * merk is [0, 2, 1] (left, right, here)
+   */
+  child_order: number[];
+  child_size: number;
+  min_prefix_length: number;
+  max_prefix_length: number;
+  /** empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) */
+
+  empty_child: Uint8Array;
+  /** hash is the algorithm that must be used for each InnerOp */
+
+  hash: HashOpSDKType;
+}
+/** BatchProof is a group of multiple proof types than can be compressed */
+
+export interface BatchProof {
+  entries: BatchEntry[];
+}
+/** BatchProof is a group of multiple proof types than can be compressed */
+
+export interface BatchProofSDKType {
+  entries: BatchEntrySDKType[];
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+export interface BatchEntry {
+  exist?: ExistenceProof;
+  nonexist?: NonExistenceProof;
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+export interface BatchEntrySDKType {
+  exist?: ExistenceProofSDKType;
+  nonexist?: NonExistenceProofSDKType;
+}
+export interface CompressedBatchProof {
+  entries: CompressedBatchEntry[];
+  lookupInners: InnerOp[];
+}
+export interface CompressedBatchProofSDKType {
+  entries: CompressedBatchEntrySDKType[];
+  lookup_inners: InnerOpSDKType[];
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+export interface CompressedBatchEntry {
+  exist?: CompressedExistenceProof;
+  nonexist?: CompressedNonExistenceProof;
+}
+/** Use BatchEntry not CommitmentProof, to avoid recursion */
+
+export interface CompressedBatchEntrySDKType {
+  exist?: CompressedExistenceProofSDKType;
+  nonexist?: CompressedNonExistenceProofSDKType;
+}
+export interface CompressedExistenceProof {
+  key: Uint8Array;
+  value: Uint8Array;
+  leaf: LeafOp;
+  /** these are indexes into the lookup_inners table in CompressedBatchProof */
+
+  path: number[];
+}
+export interface CompressedExistenceProofSDKType {
+  key: Uint8Array;
+  value: Uint8Array;
+  leaf: LeafOpSDKType;
+  /** these are indexes into the lookup_inners table in CompressedBatchProof */
+
+  path: number[];
+}
+export interface CompressedNonExistenceProof {
+  /** TODO: remove this as unnecessary??? we prove a range */
+  key: Uint8Array;
+  left: CompressedExistenceProof;
+  right: CompressedExistenceProof;
+}
+export interface CompressedNonExistenceProofSDKType {
+  /** TODO: remove this as unnecessary??? we prove a range */
+  key: Uint8Array;
+  left: CompressedExistenceProofSDKType;
+  right: CompressedExistenceProofSDKType;
+}
+
+function createBaseExistenceProof(): ExistenceProof {
+  return {
+    key: new Uint8Array(),
+    value: new Uint8Array(),
+    leaf: undefined,
+    path: []
+  };
+}
+
+export const ExistenceProof = {
+  encode(message: ExistenceProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+
+    if (message.leaf !== undefined) {
+      LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.path) {
+      InnerOp.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ExistenceProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExistenceProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.value = reader.bytes();
+          break;
+
+        case 3:
+          message.leaf = LeafOp.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.path.push(InnerOp.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ExistenceProof>): ExistenceProof {
+    const message = createBaseExistenceProof();
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    message.leaf = object.leaf !== undefined && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : undefined;
+    message.path = object.path?.map(e => InnerOp.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseNonExistenceProof(): NonExistenceProof {
+  return {
+    key: new Uint8Array(),
+    left: undefined,
+    right: undefined
+  };
+}
+
+export const NonExistenceProof = {
+  encode(message: NonExistenceProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (message.left !== undefined) {
+      ExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.right !== undefined) {
+      ExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): NonExistenceProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseNonExistenceProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.left = ExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.right = ExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<NonExistenceProof>): NonExistenceProof {
+    const message = createBaseNonExistenceProof();
+    message.key = object.key ?? new Uint8Array();
+    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;
+  }
+
+};
+
+function createBaseCommitmentProof(): CommitmentProof {
+  return {
+    exist: undefined,
+    nonexist: undefined,
+    batch: undefined,
+    compressed: undefined
+  };
+}
+
+export const CommitmentProof = {
+  encode(message: CommitmentProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.exist !== undefined) {
+      ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.nonexist !== undefined) {
+      NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.batch !== undefined) {
+      BatchProof.encode(message.batch, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.compressed !== undefined) {
+      CompressedBatchProof.encode(message.compressed, writer.uint32(34).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CommitmentProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommitmentProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.exist = ExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.nonexist = NonExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.batch = BatchProof.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.compressed = CompressedBatchProof.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CommitmentProof>): CommitmentProof {
+    const message = createBaseCommitmentProof();
+    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;
+    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;
+  }
+
+};
+
+function createBaseLeafOp(): LeafOp {
+  return {
+    hash: 0,
+    prehashKey: 0,
+    prehashValue: 0,
+    length: 0,
+    prefix: new Uint8Array()
+  };
+}
+
+export const LeafOp = {
+  encode(message: LeafOp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash !== 0) {
+      writer.uint32(8).int32(message.hash);
+    }
+
+    if (message.prehashKey !== 0) {
+      writer.uint32(16).int32(message.prehashKey);
+    }
+
+    if (message.prehashValue !== 0) {
+      writer.uint32(24).int32(message.prehashValue);
+    }
+
+    if (message.length !== 0) {
+      writer.uint32(32).int32(message.length);
+    }
+
+    if (message.prefix.length !== 0) {
+      writer.uint32(42).bytes(message.prefix);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LeafOp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLeafOp();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.hash = (reader.int32() as any);
+          break;
+
+        case 2:
+          message.prehashKey = (reader.int32() as any);
+          break;
+
+        case 3:
+          message.prehashValue = (reader.int32() as any);
+          break;
+
+        case 4:
+          message.length = (reader.int32() as any);
+          break;
+
+        case 5:
+          message.prefix = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<LeafOp>): LeafOp {
+    const message = createBaseLeafOp();
+    message.hash = object.hash ?? 0;
+    message.prehashKey = object.prehashKey ?? 0;
+    message.prehashValue = object.prehashValue ?? 0;
+    message.length = object.length ?? 0;
+    message.prefix = object.prefix ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseInnerOp(): InnerOp {
+  return {
+    hash: 0,
+    prefix: new Uint8Array(),
+    suffix: new Uint8Array()
+  };
+}
+
+export const InnerOp = {
+  encode(message: InnerOp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash !== 0) {
+      writer.uint32(8).int32(message.hash);
+    }
+
+    if (message.prefix.length !== 0) {
+      writer.uint32(18).bytes(message.prefix);
+    }
+
+    if (message.suffix.length !== 0) {
+      writer.uint32(26).bytes(message.suffix);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): InnerOp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInnerOp();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.hash = (reader.int32() as any);
+          break;
+
+        case 2:
+          message.prefix = reader.bytes();
+          break;
+
+        case 3:
+          message.suffix = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<InnerOp>): InnerOp {
+    const message = createBaseInnerOp();
+    message.hash = object.hash ?? 0;
+    message.prefix = object.prefix ?? new Uint8Array();
+    message.suffix = object.suffix ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseProofSpec(): ProofSpec {
+  return {
+    leafSpec: undefined,
+    innerSpec: undefined,
+    maxDepth: 0,
+    minDepth: 0
+  };
+}
+
+export const ProofSpec = {
+  encode(message: ProofSpec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.leafSpec !== undefined) {
+      LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.innerSpec !== undefined) {
+      InnerSpec.encode(message.innerSpec, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.maxDepth !== 0) {
+      writer.uint32(24).int32(message.maxDepth);
+    }
+
+    if (message.minDepth !== 0) {
+      writer.uint32(32).int32(message.minDepth);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ProofSpec {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProofSpec();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.leafSpec = LeafOp.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.innerSpec = InnerSpec.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.maxDepth = reader.int32();
+          break;
+
+        case 4:
+          message.minDepth = reader.int32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ProofSpec>): ProofSpec {
+    const message = createBaseProofSpec();
+    message.leafSpec = object.leafSpec !== undefined && object.leafSpec !== null ? LeafOp.fromPartial(object.leafSpec) : undefined;
+    message.innerSpec = object.innerSpec !== undefined && object.innerSpec !== null ? InnerSpec.fromPartial(object.innerSpec) : undefined;
+    message.maxDepth = object.maxDepth ?? 0;
+    message.minDepth = object.minDepth ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseInnerSpec(): InnerSpec {
+  return {
+    childOrder: [],
+    childSize: 0,
+    minPrefixLength: 0,
+    maxPrefixLength: 0,
+    emptyChild: new Uint8Array(),
+    hash: 0
+  };
+}
+
+export const InnerSpec = {
+  encode(message: InnerSpec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+
+    for (const v of message.childOrder) {
+      writer.int32(v);
+    }
+
+    writer.ldelim();
+
+    if (message.childSize !== 0) {
+      writer.uint32(16).int32(message.childSize);
+    }
+
+    if (message.minPrefixLength !== 0) {
+      writer.uint32(24).int32(message.minPrefixLength);
+    }
+
+    if (message.maxPrefixLength !== 0) {
+      writer.uint32(32).int32(message.maxPrefixLength);
+    }
+
+    if (message.emptyChild.length !== 0) {
+      writer.uint32(42).bytes(message.emptyChild);
+    }
+
+    if (message.hash !== 0) {
+      writer.uint32(48).int32(message.hash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): InnerSpec {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInnerSpec();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.childOrder.push(reader.int32());
+            }
+          } else {
+            message.childOrder.push(reader.int32());
+          }
+
+          break;
+
+        case 2:
+          message.childSize = reader.int32();
+          break;
+
+        case 3:
+          message.minPrefixLength = reader.int32();
+          break;
+
+        case 4:
+          message.maxPrefixLength = reader.int32();
+          break;
+
+        case 5:
+          message.emptyChild = reader.bytes();
+          break;
+
+        case 6:
+          message.hash = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<InnerSpec>): InnerSpec {
+    const message = createBaseInnerSpec();
+    message.childOrder = object.childOrder?.map(e => e) || [];
+    message.childSize = object.childSize ?? 0;
+    message.minPrefixLength = object.minPrefixLength ?? 0;
+    message.maxPrefixLength = object.maxPrefixLength ?? 0;
+    message.emptyChild = object.emptyChild ?? new Uint8Array();
+    message.hash = object.hash ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseBatchProof(): BatchProof {
+  return {
+    entries: []
+  };
+}
+
+export const BatchProof = {
+  encode(message: BatchProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.entries) {
+      BatchEntry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BatchProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBatchProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.entries.push(BatchEntry.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BatchProof>): BatchProof {
+    const message = createBaseBatchProof();
+    message.entries = object.entries?.map(e => BatchEntry.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseBatchEntry(): BatchEntry {
+  return {
+    exist: undefined,
+    nonexist: undefined
+  };
+}
+
+export const BatchEntry = {
+  encode(message: BatchEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.exist !== undefined) {
+      ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.nonexist !== undefined) {
+      NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BatchEntry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBatchEntry();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.exist = ExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.nonexist = NonExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BatchEntry>): BatchEntry {
+    const message = createBaseBatchEntry();
+    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;
+  }
+
+};
+
+function createBaseCompressedBatchProof(): CompressedBatchProof {
+  return {
+    entries: [],
+    lookupInners: []
+  };
+}
+
+export const CompressedBatchProof = {
+  encode(message: CompressedBatchProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.entries) {
+      CompressedBatchEntry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.lookupInners) {
+      InnerOp.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompressedBatchProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.entries.push(CompressedBatchEntry.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.lookupInners.push(InnerOp.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CompressedBatchProof>): CompressedBatchProof {
+    const message = createBaseCompressedBatchProof();
+    message.entries = object.entries?.map(e => CompressedBatchEntry.fromPartial(e)) || [];
+    message.lookupInners = object.lookupInners?.map(e => InnerOp.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseCompressedBatchEntry(): CompressedBatchEntry {
+  return {
+    exist: undefined,
+    nonexist: undefined
+  };
+}
+
+export const CompressedBatchEntry = {
+  encode(message: CompressedBatchEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.exist !== undefined) {
+      CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.nonexist !== undefined) {
+      CompressedNonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchEntry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompressedBatchEntry();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.exist = CompressedExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.nonexist = CompressedNonExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CompressedBatchEntry>): CompressedBatchEntry {
+    const message = createBaseCompressedBatchEntry();
+    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;
+  }
+
+};
+
+function createBaseCompressedExistenceProof(): CompressedExistenceProof {
+  return {
+    key: new Uint8Array(),
+    value: new Uint8Array(),
+    leaf: undefined,
+    path: []
+  };
+}
+
+export const CompressedExistenceProof = {
+  encode(message: CompressedExistenceProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+
+    if (message.leaf !== undefined) {
+      LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim();
+    }
+
+    writer.uint32(34).fork();
+
+    for (const v of message.path) {
+      writer.int32(v);
+    }
+
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CompressedExistenceProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompressedExistenceProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.value = reader.bytes();
+          break;
+
+        case 3:
+          message.leaf = LeafOp.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.path.push(reader.int32());
+            }
+          } else {
+            message.path.push(reader.int32());
+          }
+
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CompressedExistenceProof>): CompressedExistenceProof {
+    const message = createBaseCompressedExistenceProof();
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    message.leaf = object.leaf !== undefined && object.leaf !== null ? LeafOp.fromPartial(object.leaf) : undefined;
+    message.path = object.path?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseCompressedNonExistenceProof(): CompressedNonExistenceProof {
+  return {
+    key: new Uint8Array(),
+    left: undefined,
+    right: undefined
+  };
+}
+
+export const CompressedNonExistenceProof = {
+  encode(message: CompressedNonExistenceProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (message.left !== undefined) {
+      CompressedExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.right !== undefined) {
+      CompressedExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CompressedNonExistenceProof {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompressedNonExistenceProof();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.left = CompressedExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.right = CompressedExistenceProof.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CompressedNonExistenceProof>): CompressedNonExistenceProof {
+    const message = createBaseCompressedNonExistenceProof();
+    message.key = object.key ?? new Uint8Array();
+    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;
+  }
+
+};