Variable ics23Const

Type declaration

• BatchEntry: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): BatchEntry;
      encode(message: BatchEntry, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: BatchEntryAmino): BatchEntry;
      fromAminoMsg(object: BatchEntryAminoMsg): BatchEntry;
      fromPartial(object: {
          exist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          };
          nonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
          };
      }): BatchEntry;
      fromProtoMsg(message: BatchEntryProtoMsg): BatchEntry;
      toAmino(message: BatchEntry): BatchEntryAmino;
      toProto(message: BatchEntry): Uint8Array;
      toProtoMsg(message: BatchEntry): BatchEntryProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): BatchEntry

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns BatchEntry

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: BatchEntry
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): BatchEntry

    • Parameters

      • object: BatchEntryAmino

      Returns BatchEntry

  • fromAminoMsg:function

    • fromAminoMsg(object): BatchEntry

    • Parameters

      • object: BatchEntryAminoMsg

      Returns BatchEntry

  • fromPartial:function

    • fromPartial(object): BatchEntry

    • Parameters

      • object: {
            exist?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: HashOp;
                    prefix?: Uint8Array;
                    suffix?: Uint8Array;
                }[];
                value?: Uint8Array;
            };
            nonexist?: {
                key?: Uint8Array;
                left?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: {
                        hash?: (...) | (...);
                        prefix?: (...) | (...);
                        suffix?: (...) | (...);
                    }[];
                    value?: Uint8Array;
                };
                right?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: {
                        hash?: (...) | (...);
                        prefix?: (...) | (...);
                        suffix?: (...) | (...);
                    }[];
                    value?: Uint8Array;
                };
            };
        }

        • Optionalexist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[]

          • Optionalvalue?: Uint8Array

        • Optionalnonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
          }

          • Optionalkey?: Uint8Array

            TODO: remove this as unnecessary??? we prove a range

          • Optionalleft?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: (...) | (...);
                    prefix?: (...) | (...);
                    suffix?: (...) | (...);
                }[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: {
                  hash?: (...) | (...);
                  prefix?: (...) | (...);
                  suffix?: (...) | (...);
              }[]

            • Optionalvalue?: Uint8Array

          • Optionalright?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: (...) | (...);
                    prefix?: (...) | (...);
                    suffix?: (...) | (...);
                }[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: {
                  hash?: (...) | (...);
                  prefix?: (...) | (...);
                  suffix?: (...) | (...);
              }[]

            • Optionalvalue?: Uint8Array

      Returns BatchEntry

  • fromProtoMsg:function

    • fromProtoMsg(message): BatchEntry

    • Parameters

      • message: BatchEntryProtoMsg

      Returns BatchEntry

  • toAmino:function

    • toAmino(message): BatchEntryAmino

    • Parameters

      • message: BatchEntry

      Returns BatchEntryAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: BatchEntry

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): BatchEntryProtoMsg

    • Parameters

      • message: BatchEntry

      Returns BatchEntryProtoMsg

• BatchProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): BatchProof;
      encode(message: BatchProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: BatchProofAmino): BatchProof;
      fromAminoMsg(object: BatchProofAminoMsg): BatchProof;
      fromPartial(object: {
          entries?: {
              exist?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: (...) | (...);
                      length?: (...) | (...);
                      prefix?: (...) | (...);
                      prehashKey?: (...) | (...);
                      prehashValue?: (...) | (...);
                  };
                  path?: {
                      hash?: ...;
                      prefix?: ...;
                      suffix?: ...;
                  }[];
                  value?: Uint8Array;
              };
              nonexist?: {
                  key?: Uint8Array;
                  left?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  right?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
              };
          }[];
      }): BatchProof;
      fromProtoMsg(message: BatchProofProtoMsg): BatchProof;
      toAmino(message: BatchProof): BatchProofAmino;
      toProto(message: BatchProof): Uint8Array;
      toProtoMsg(message: BatchProof): BatchProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): BatchProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns BatchProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: BatchProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): BatchProof

    • Parameters

      • object: BatchProofAmino

      Returns BatchProof

  • fromAminoMsg:function

    • fromAminoMsg(object): BatchProof

    • Parameters

      • object: BatchProofAminoMsg

      Returns BatchProof

  • fromPartial:function

    • fromPartial(object): BatchProof

    • Parameters

      • object: {
            entries?: {
                exist?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: (...) | (...);
                        length?: (...) | (...);
                        prefix?: (...) | (...);
                        prehashKey?: (...) | (...);
                        prehashValue?: (...) | (...);
                    };
                    path?: {
                        hash?: ...;
                        prefix?: ...;
                        suffix?: ...;
                    }[];
                    value?: Uint8Array;
                };
                nonexist?: {
                    key?: Uint8Array;
                    left?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                    right?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                };
            }[];
        }

        • Optionalentries?: {
              exist?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: (...) | (...);
                      length?: (...) | (...);
                      prefix?: (...) | (...);
                      prehashKey?: (...) | (...);
                      prehashValue?: (...) | (...);
                  };
                  path?: {
                      hash?: ...;
                      prefix?: ...;
                      suffix?: ...;
                  }[];
                  value?: Uint8Array;
              };
              nonexist?: {
                  key?: Uint8Array;
                  left?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  right?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
              };
          }[]

      Returns BatchProof

  • fromProtoMsg:function

    • fromProtoMsg(message): BatchProof

    • Parameters

      • message: BatchProofProtoMsg

      Returns BatchProof

  • toAmino:function

    • toAmino(message): BatchProofAmino

    • Parameters

      • message: BatchProof

      Returns BatchProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: BatchProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): BatchProofProtoMsg

    • Parameters

      • message: BatchProof

      Returns BatchProofProtoMsg

• CommitmentProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): CommitmentProof;
      encode(message: CommitmentProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: CommitmentProofAmino): CommitmentProof;
      fromAminoMsg(object: CommitmentProofAminoMsg): CommitmentProof;
      fromPartial(object: {
          batch?: {
              entries?: {
                  exist?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  nonexist?: {
                      key?: (...) | (...);
                      left?: (...) | (...);
                      right?: (...) | (...);
                  };
              }[];
          };
          compressed?: {
              entries?: {
                  exist?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  nonexist?: {
                      key?: (...) | (...);
                      left?: (...) | (...);
                      right?: (...) | (...);
                  };
              }[];
              lookupInners?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
          };
          exist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          };
          nonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
          };
      }): CommitmentProof;
      fromProtoMsg(message: CommitmentProofProtoMsg): CommitmentProof;
      toAmino(message: CommitmentProof): CommitmentProofAmino;
      toProto(message: CommitmentProof): Uint8Array;
      toProtoMsg(message: CommitmentProof): CommitmentProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): CommitmentProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns CommitmentProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: CommitmentProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): CommitmentProof

    • Parameters

      • object: CommitmentProofAmino

      Returns CommitmentProof

  • fromAminoMsg:function

    • fromAminoMsg(object): CommitmentProof

    • Parameters

      • object: CommitmentProofAminoMsg

      Returns CommitmentProof

  • fromPartial:function

    • fromPartial(object): CommitmentProof

    • Parameters

      • object: {
            batch?: {
                entries?: {
                    exist?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                    nonexist?: {
                        key?: (...) | (...);
                        left?: (...) | (...);
                        right?: (...) | (...);
                    };
                }[];
            };
            compressed?: {
                entries?: {
                    exist?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                    nonexist?: {
                        key?: (...) | (...);
                        left?: (...) | (...);
                        right?: (...) | (...);
                    };
                }[];
                lookupInners?: {
                    hash?: HashOp;
                    prefix?: Uint8Array;
                    suffix?: Uint8Array;
                }[];
            };
            exist?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: HashOp;
                    prefix?: Uint8Array;
                    suffix?: Uint8Array;
                }[];
                value?: Uint8Array;
            };
            nonexist?: {
                key?: Uint8Array;
                left?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: {
                        hash?: (...) | (...);
                        prefix?: (...) | (...);
                        suffix?: (...) | (...);
                    }[];
                    value?: Uint8Array;
                };
                right?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: {
                        hash?: (...) | (...);
                        prefix?: (...) | (...);
                        suffix?: (...) | (...);
                    }[];
                    value?: Uint8Array;
                };
            };
        }

        • Optionalbatch?: {
              entries?: {
                  exist?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  nonexist?: {
                      key?: (...) | (...);
                      left?: (...) | (...);
                      right?: (...) | (...);
                  };
              }[];
          }

          • Optionalentries?: {
                exist?: {
                    key?: (...) | (...);
                    leaf?: (...) | (...);
                    path?: (...) | (...);
                    value?: (...) | (...);
                };
                nonexist?: {
                    key?: (...) | (...);
                    left?: (...) | (...);
                    right?: (...) | (...);
                };
            }[]

        • Optionalcompressed?: {
              entries?: {
                  exist?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  nonexist?: {
                      key?: (...) | (...);
                      left?: (...) | (...);
                      right?: (...) | (...);
                  };
              }[];
              lookupInners?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
          }

          • Optionalentries?: {
                exist?: {
                    key?: (...) | (...);
                    leaf?: (...) | (...);
                    path?: (...) | (...);
                    value?: (...) | (...);
                };
                nonexist?: {
                    key?: (...) | (...);
                    left?: (...) | (...);
                    right?: (...) | (...);
                };
            }[]

          • OptionallookupInners?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[]

        • Optionalexist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[]

          • Optionalvalue?: Uint8Array

        • Optionalnonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: {
                      hash?: (...) | (...);
                      prefix?: (...) | (...);
                      suffix?: (...) | (...);
                  }[];
                  value?: Uint8Array;
              };
          }

          • Optionalkey?: Uint8Array

            TODO: remove this as unnecessary??? we prove a range

          • Optionalleft?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: (...) | (...);
                    prefix?: (...) | (...);
                    suffix?: (...) | (...);
                }[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: {
                  hash?: (...) | (...);
                  prefix?: (...) | (...);
                  suffix?: (...) | (...);
              }[]

            • Optionalvalue?: Uint8Array

          • Optionalright?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: (...) | (...);
                    prefix?: (...) | (...);
                    suffix?: (...) | (...);
                }[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: {
                  hash?: (...) | (...);
                  prefix?: (...) | (...);
                  suffix?: (...) | (...);
              }[]

            • Optionalvalue?: Uint8Array

      Returns CommitmentProof

  • fromProtoMsg:function

    • fromProtoMsg(message): CommitmentProof

    • Parameters

      • message: CommitmentProofProtoMsg

      Returns CommitmentProof

  • toAmino:function

    • toAmino(message): CommitmentProofAmino

    • Parameters

      • message: CommitmentProof

      Returns CommitmentProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: CommitmentProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): CommitmentProofProtoMsg

    • Parameters

      • message: CommitmentProof

      Returns CommitmentProofProtoMsg

• CompressedBatchEntry: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): CompressedBatchEntry;
      encode(message: CompressedBatchEntry, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: CompressedBatchEntryAmino): CompressedBatchEntry;
      fromAminoMsg(object: CompressedBatchEntryAminoMsg): CompressedBatchEntry;
      fromPartial(object: {
          exist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          };
          nonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
          };
      }): CompressedBatchEntry;
      fromProtoMsg(message: CompressedBatchEntryProtoMsg): CompressedBatchEntry;
      toAmino(message: CompressedBatchEntry): CompressedBatchEntryAmino;
      toProto(message: CompressedBatchEntry): Uint8Array;
      toProtoMsg(message: CompressedBatchEntry): CompressedBatchEntryProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): CompressedBatchEntry

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns CompressedBatchEntry

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: CompressedBatchEntry
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): CompressedBatchEntry

    • Parameters

      • object: CompressedBatchEntryAmino

      Returns CompressedBatchEntry

  • fromAminoMsg:function

    • fromAminoMsg(object): CompressedBatchEntry

    • Parameters

      • object: CompressedBatchEntryAminoMsg

      Returns CompressedBatchEntry

  • fromPartial:function

    • fromPartial(object): CompressedBatchEntry

    • Parameters

      • object: {
            exist?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: number[];
                value?: Uint8Array;
            };
            nonexist?: {
                key?: Uint8Array;
                left?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: number[];
                    value?: Uint8Array;
                };
                right?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: HashOp;
                        length?: LengthOp;
                        prefix?: Uint8Array;
                        prehashKey?: HashOp;
                        prehashValue?: HashOp;
                    };
                    path?: number[];
                    value?: Uint8Array;
                };
            };
        }

        • Optionalexist?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: number[]

            these are indexes into the lookup_inners table in CompressedBatchProof

          • Optionalvalue?: Uint8Array

        • Optionalnonexist?: {
              key?: Uint8Array;
              left?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
              right?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: HashOp;
                      length?: LengthOp;
                      prefix?: Uint8Array;
                      prehashKey?: HashOp;
                      prehashValue?: HashOp;
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
          }

          • Optionalkey?: Uint8Array

            TODO: remove this as unnecessary??? we prove a range

          • Optionalleft?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: number[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: number[]

              these are indexes into the lookup_inners table in CompressedBatchProof

            • Optionalvalue?: Uint8Array

          • Optionalright?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: number[];
                value?: Uint8Array;
            }

            • Optionalkey?: Uint8Array

            • Optionalleaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              }

              • Optionalhash?: HashOp

              • Optionallength?: LengthOp

              • Optionalprefix?: Uint8Array

                prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

              • OptionalprehashKey?: HashOp

              • OptionalprehashValue?: HashOp

            • Optionalpath?: number[]

              these are indexes into the lookup_inners table in CompressedBatchProof

            • Optionalvalue?: Uint8Array

      Returns CompressedBatchEntry

  • fromProtoMsg:function

    • fromProtoMsg(message): CompressedBatchEntry

    • Parameters

      • message: CompressedBatchEntryProtoMsg

      Returns CompressedBatchEntry

  • toAmino:function

    • toAmino(message): CompressedBatchEntryAmino

    • Parameters

      • message: CompressedBatchEntry

      Returns CompressedBatchEntryAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: CompressedBatchEntry

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): CompressedBatchEntryProtoMsg

    • Parameters

      • message: CompressedBatchEntry

      Returns CompressedBatchEntryProtoMsg

• CompressedBatchProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): CompressedBatchProof;
      encode(message: CompressedBatchProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: CompressedBatchProofAmino): CompressedBatchProof;
      fromAminoMsg(object: CompressedBatchProofAminoMsg): CompressedBatchProof;
      fromPartial(object: {
          entries?: {
              exist?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: (...) | (...);
                      length?: (...) | (...);
                      prefix?: (...) | (...);
                      prehashKey?: (...) | (...);
                      prehashValue?: (...) | (...);
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
              nonexist?: {
                  key?: Uint8Array;
                  left?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  right?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
              };
          }[];
          lookupInners?: {
              hash?: HashOp;
              prefix?: Uint8Array;
              suffix?: Uint8Array;
          }[];
      }): CompressedBatchProof;
      fromProtoMsg(message: CompressedBatchProofProtoMsg): CompressedBatchProof;
      toAmino(message: CompressedBatchProof): CompressedBatchProofAmino;
      toProto(message: CompressedBatchProof): Uint8Array;
      toProtoMsg(message: CompressedBatchProof): CompressedBatchProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): CompressedBatchProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns CompressedBatchProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: CompressedBatchProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): CompressedBatchProof

    • Parameters

      • object: CompressedBatchProofAmino

      Returns CompressedBatchProof

  • fromAminoMsg:function

    • fromAminoMsg(object): CompressedBatchProof

    • Parameters

      • object: CompressedBatchProofAminoMsg

      Returns CompressedBatchProof

  • fromPartial:function

    • fromPartial(object): CompressedBatchProof

    • Parameters

      • object: {
            entries?: {
                exist?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: (...) | (...);
                        length?: (...) | (...);
                        prefix?: (...) | (...);
                        prehashKey?: (...) | (...);
                        prehashValue?: (...) | (...);
                    };
                    path?: number[];
                    value?: Uint8Array;
                };
                nonexist?: {
                    key?: Uint8Array;
                    left?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                    right?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                };
            }[];
            lookupInners?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[];
        }

        • Optionalentries?: {
              exist?: {
                  key?: Uint8Array;
                  leaf?: {
                      hash?: (...) | (...);
                      length?: (...) | (...);
                      prefix?: (...) | (...);
                      prehashKey?: (...) | (...);
                      prehashValue?: (...) | (...);
                  };
                  path?: number[];
                  value?: Uint8Array;
              };
              nonexist?: {
                  key?: Uint8Array;
                  left?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
                  right?: {
                      key?: (...) | (...);
                      leaf?: (...) | (...);
                      path?: (...) | (...);
                      value?: (...) | (...);
                  };
              };
          }[]

        • OptionallookupInners?: {
              hash?: HashOp;
              prefix?: Uint8Array;
              suffix?: Uint8Array;
          }[]

      Returns CompressedBatchProof

  • fromProtoMsg:function

    • fromProtoMsg(message): CompressedBatchProof

    • Parameters

      • message: CompressedBatchProofProtoMsg

      Returns CompressedBatchProof

  • toAmino:function

    • toAmino(message): CompressedBatchProofAmino

    • Parameters

      • message: CompressedBatchProof

      Returns CompressedBatchProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: CompressedBatchProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): CompressedBatchProofProtoMsg

    • Parameters

      • message: CompressedBatchProof

      Returns CompressedBatchProofProtoMsg

• CompressedExistenceProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): CompressedExistenceProof;
      encode(message: CompressedExistenceProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: CompressedExistenceProofAmino): CompressedExistenceProof;
      fromAminoMsg(object: CompressedExistenceProofAminoMsg): CompressedExistenceProof;
      fromPartial(object: {
          key?: Uint8Array;
          leaf?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          };
          path?: number[];
          value?: Uint8Array;
      }): CompressedExistenceProof;
      fromProtoMsg(message: CompressedExistenceProofProtoMsg): CompressedExistenceProof;
      toAmino(message: CompressedExistenceProof): CompressedExistenceProofAmino;
      toProto(message: CompressedExistenceProof): Uint8Array;
      toProtoMsg(message: CompressedExistenceProof): CompressedExistenceProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): CompressedExistenceProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns CompressedExistenceProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: CompressedExistenceProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): CompressedExistenceProof

    • Parameters

      • object: CompressedExistenceProofAmino

      Returns CompressedExistenceProof

  • fromAminoMsg:function

    • fromAminoMsg(object): CompressedExistenceProof

    • Parameters

      • object: CompressedExistenceProofAminoMsg

      Returns CompressedExistenceProof

  • fromPartial:function

    • fromPartial(object): CompressedExistenceProof

    • Parameters

      • object: {
            key?: Uint8Array;
            leaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            };
            path?: number[];
            value?: Uint8Array;
        }

        • Optionalkey?: Uint8Array

        • Optionalleaf?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          }

          • Optionalhash?: HashOp

          • Optionallength?: LengthOp

          • Optionalprefix?: Uint8Array

            prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

          • OptionalprehashKey?: HashOp

          • OptionalprehashValue?: HashOp

        • Optionalpath?: number[]

          these are indexes into the lookup_inners table in CompressedBatchProof

        • Optionalvalue?: Uint8Array

      Returns CompressedExistenceProof

  • fromProtoMsg:function

    • fromProtoMsg(message): CompressedExistenceProof

    • Parameters

      • message: CompressedExistenceProofProtoMsg

      Returns CompressedExistenceProof

  • toAmino:function

    • toAmino(message): CompressedExistenceProofAmino

    • Parameters

      • message: CompressedExistenceProof

      Returns CompressedExistenceProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: CompressedExistenceProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): CompressedExistenceProofProtoMsg

    • Parameters

      • message: CompressedExistenceProof

      Returns CompressedExistenceProofProtoMsg

• CompressedNonExistenceProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): CompressedNonExistenceProof;
      encode(message: CompressedNonExistenceProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: CompressedNonExistenceProofAmino): CompressedNonExistenceProof;
      fromAminoMsg(object: CompressedNonExistenceProofAminoMsg): CompressedNonExistenceProof;
      fromPartial(object: {
          key?: Uint8Array;
          left?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          };
          right?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          };
      }): CompressedNonExistenceProof;
      fromProtoMsg(message: CompressedNonExistenceProofProtoMsg): CompressedNonExistenceProof;
      toAmino(message: CompressedNonExistenceProof): CompressedNonExistenceProofAmino;
      toProto(message: CompressedNonExistenceProof): Uint8Array;
      toProtoMsg(message: CompressedNonExistenceProof): CompressedNonExistenceProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): CompressedNonExistenceProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns CompressedNonExistenceProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: CompressedNonExistenceProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): CompressedNonExistenceProof

    • Parameters

      • object: CompressedNonExistenceProofAmino

      Returns CompressedNonExistenceProof

  • fromAminoMsg:function

    • fromAminoMsg(object): CompressedNonExistenceProof

    • Parameters

      • object: CompressedNonExistenceProofAminoMsg

      Returns CompressedNonExistenceProof

  • fromPartial:function

    • fromPartial(object): CompressedNonExistenceProof

    • Parameters

      • object: {
            key?: Uint8Array;
            left?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: number[];
                value?: Uint8Array;
            };
            right?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: number[];
                value?: Uint8Array;
            };
        }

        • Optionalkey?: Uint8Array

          TODO: remove this as unnecessary??? we prove a range

        • Optionalleft?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: number[]

            these are indexes into the lookup_inners table in CompressedBatchProof

          • Optionalvalue?: Uint8Array

        • Optionalright?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: number[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: number[]

            these are indexes into the lookup_inners table in CompressedBatchProof

          • Optionalvalue?: Uint8Array

      Returns CompressedNonExistenceProof

  • fromProtoMsg:function

    • fromProtoMsg(message): CompressedNonExistenceProof

    • Parameters

      • message: CompressedNonExistenceProofProtoMsg

      Returns CompressedNonExistenceProof

  • toAmino:function

    • toAmino(message): CompressedNonExistenceProofAmino

    • Parameters

      • message: CompressedNonExistenceProof

      Returns CompressedNonExistenceProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: CompressedNonExistenceProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): CompressedNonExistenceProofProtoMsg

    • Parameters

      • message: CompressedNonExistenceProof

      Returns CompressedNonExistenceProofProtoMsg

• ExistenceProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ExistenceProof;
      encode(message: ExistenceProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ExistenceProofAmino): ExistenceProof;
      fromAminoMsg(object: ExistenceProofAminoMsg): ExistenceProof;
      fromPartial(object: {
          key?: Uint8Array;
          leaf?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          };
          path?: {
              hash?: HashOp;
              prefix?: Uint8Array;
              suffix?: Uint8Array;
          }[];
          value?: Uint8Array;
      }): ExistenceProof;
      fromProtoMsg(message: ExistenceProofProtoMsg): ExistenceProof;
      toAmino(message: ExistenceProof): ExistenceProofAmino;
      toProto(message: ExistenceProof): Uint8Array;
      toProtoMsg(message: ExistenceProof): ExistenceProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ExistenceProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ExistenceProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ExistenceProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ExistenceProof

    • Parameters

      • object: ExistenceProofAmino

      Returns ExistenceProof

  • fromAminoMsg:function

    • fromAminoMsg(object): ExistenceProof

    • Parameters

      • object: ExistenceProofAminoMsg

      Returns ExistenceProof

  • fromPartial:function

    • fromPartial(object): ExistenceProof

    • Parameters

      • object: {
            key?: Uint8Array;
            leaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            };
            path?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[];
            value?: Uint8Array;
        }

        • Optionalkey?: Uint8Array

        • Optionalleaf?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          }

          • Optionalhash?: HashOp

          • Optionallength?: LengthOp

          • Optionalprefix?: Uint8Array

            prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

          • OptionalprehashKey?: HashOp

          • OptionalprehashValue?: HashOp

        • Optionalpath?: {
              hash?: HashOp;
              prefix?: Uint8Array;
              suffix?: Uint8Array;
          }[]

        • Optionalvalue?: Uint8Array

      Returns ExistenceProof

  • fromProtoMsg:function

    • fromProtoMsg(message): ExistenceProof

    • Parameters

      • message: ExistenceProofProtoMsg

      Returns ExistenceProof

  • toAmino:function

    • toAmino(message): ExistenceProofAmino

    • Parameters

      • message: ExistenceProof

      Returns ExistenceProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ExistenceProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ExistenceProofProtoMsg

    • Parameters

      • message: ExistenceProof

      Returns ExistenceProofProtoMsg

• HashOpAmino: typeof HashOp

• HashOpSDKType: typeof HashOp

• InnerOp: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): InnerOp;
      encode(message: InnerOp, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: InnerOpAmino): InnerOp;
      fromAminoMsg(object: InnerOpAminoMsg): InnerOp;
      fromPartial(object: {
          hash?: HashOp;
          prefix?: Uint8Array;
          suffix?: Uint8Array;
      }): InnerOp;
      fromProtoMsg(message: InnerOpProtoMsg): InnerOp;
      toAmino(message: InnerOp): InnerOpAmino;
      toProto(message: InnerOp): Uint8Array;
      toProtoMsg(message: InnerOp): InnerOpProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): InnerOp

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns InnerOp

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: InnerOp
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): InnerOp

    • Parameters

      • object: InnerOpAmino

      Returns InnerOp

  • fromAminoMsg:function

    • fromAminoMsg(object): InnerOp

    • Parameters

      • object: InnerOpAminoMsg

      Returns InnerOp

  • fromPartial:function

    • fromPartial(object): InnerOp

    • Parameters

      • object: {
            hash?: HashOp;
            prefix?: Uint8Array;
            suffix?: Uint8Array;
        }

        • Optionalhash?: HashOp

        • Optionalprefix?: Uint8Array

        • Optionalsuffix?: Uint8Array

      Returns InnerOp

  • fromProtoMsg:function

    • fromProtoMsg(message): InnerOp

    • Parameters

      • message: InnerOpProtoMsg

      Returns InnerOp

  • toAmino:function

    • toAmino(message): InnerOpAmino

    • Parameters

      • message: InnerOp

      Returns InnerOpAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: InnerOp

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): InnerOpProtoMsg

    • Parameters

      • message: InnerOp

      Returns InnerOpProtoMsg

• InnerSpec: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): InnerSpec;
      encode(message: InnerSpec, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: InnerSpecAmino): InnerSpec;
      fromAminoMsg(object: InnerSpecAminoMsg): InnerSpec;
      fromPartial(object: {
          childOrder?: number[];
          childSize?: number;
          emptyChild?: Uint8Array;
          hash?: HashOp;
          maxPrefixLength?: number;
          minPrefixLength?: number;
      }): InnerSpec;
      fromProtoMsg(message: InnerSpecProtoMsg): InnerSpec;
      toAmino(message: InnerSpec): InnerSpecAmino;
      toProto(message: InnerSpec): Uint8Array;
      toProtoMsg(message: InnerSpec): InnerSpecProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): InnerSpec

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns InnerSpec

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: InnerSpec
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): InnerSpec

    • Parameters

      • object: InnerSpecAmino

      Returns InnerSpec

  • fromAminoMsg:function

    • fromAminoMsg(object): InnerSpec

    • Parameters

      • object: InnerSpecAminoMsg

      Returns InnerSpec

  • fromPartial:function

    • fromPartial(object): InnerSpec

    • Parameters

      • object: {
            childOrder?: number[];
            childSize?: number;
            emptyChild?: Uint8Array;
            hash?: HashOp;
            maxPrefixLength?: number;
            minPrefixLength?: number;
        }

        • OptionalchildOrder?: number[]

          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)

        • OptionalchildSize?: number

        • OptionalemptyChild?: Uint8Array

          empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0)

        • Optionalhash?: HashOp

          hash is the algorithm that must be used for each InnerOp

        • OptionalmaxPrefixLength?: number

        • OptionalminPrefixLength?: number

      Returns InnerSpec

  • fromProtoMsg:function

    • fromProtoMsg(message): InnerSpec

    • Parameters

      • message: InnerSpecProtoMsg

      Returns InnerSpec

  • toAmino:function

    • toAmino(message): InnerSpecAmino

    • Parameters

      • message: InnerSpec

      Returns InnerSpecAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: InnerSpec

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): InnerSpecProtoMsg

    • Parameters

      • message: InnerSpec

      Returns InnerSpecProtoMsg

• LeafOp: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): LeafOp;
      encode(message: LeafOp, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: LeafOpAmino): LeafOp;
      fromAminoMsg(object: LeafOpAminoMsg): LeafOp;
      fromPartial(object: {
          hash?: HashOp;
          length?: LengthOp;
          prefix?: Uint8Array;
          prehashKey?: HashOp;
          prehashValue?: HashOp;
      }): LeafOp;
      fromProtoMsg(message: LeafOpProtoMsg): LeafOp;
      toAmino(message: LeafOp): LeafOpAmino;
      toProto(message: LeafOp): Uint8Array;
      toProtoMsg(message: LeafOp): LeafOpProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): LeafOp

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns LeafOp

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: LeafOp
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): LeafOp

    • Parameters

      • object: LeafOpAmino

      Returns LeafOp

  • fromAminoMsg:function

    • fromAminoMsg(object): LeafOp

    • Parameters

      • object: LeafOpAminoMsg

      Returns LeafOp

  • fromPartial:function

    • fromPartial(object): LeafOp

    • Parameters

      • object: {
            hash?: HashOp;
            length?: LengthOp;
            prefix?: Uint8Array;
            prehashKey?: HashOp;
            prehashValue?: HashOp;
        }

        • Optionalhash?: HashOp

        • Optionallength?: LengthOp

        • Optionalprefix?: Uint8Array

          prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

        • OptionalprehashKey?: HashOp

        • OptionalprehashValue?: HashOp

      Returns LeafOp

  • fromProtoMsg:function

    • fromProtoMsg(message): LeafOp

    • Parameters

      • message: LeafOpProtoMsg

      Returns LeafOp

  • toAmino:function

    • toAmino(message): LeafOpAmino

    • Parameters

      • message: LeafOp

      Returns LeafOpAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: LeafOp

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): LeafOpProtoMsg

    • Parameters

      • message: LeafOp

      Returns LeafOpProtoMsg

• LengthOpAmino: typeof LengthOp

• LengthOpSDKType: typeof LengthOp

• NonExistenceProof: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): NonExistenceProof;
      encode(message: NonExistenceProof, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: NonExistenceProofAmino): NonExistenceProof;
      fromAminoMsg(object: NonExistenceProofAminoMsg): NonExistenceProof;
      fromPartial(object: {
          key?: Uint8Array;
          left?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          };
          right?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          };
      }): NonExistenceProof;
      fromProtoMsg(message: NonExistenceProofProtoMsg): NonExistenceProof;
      toAmino(message: NonExistenceProof): NonExistenceProofAmino;
      toProto(message: NonExistenceProof): Uint8Array;
      toProtoMsg(message: NonExistenceProof): NonExistenceProofProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): NonExistenceProof

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns NonExistenceProof

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: NonExistenceProof
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): NonExistenceProof

    • Parameters

      • object: NonExistenceProofAmino

      Returns NonExistenceProof

  • fromAminoMsg:function

    • fromAminoMsg(object): NonExistenceProof

    • Parameters

      • object: NonExistenceProofAminoMsg

      Returns NonExistenceProof

  • fromPartial:function

    • fromPartial(object): NonExistenceProof

    • Parameters

      • object: {
            key?: Uint8Array;
            left?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: HashOp;
                    prefix?: Uint8Array;
                    suffix?: Uint8Array;
                }[];
                value?: Uint8Array;
            };
            right?: {
                key?: Uint8Array;
                leaf?: {
                    hash?: HashOp;
                    length?: LengthOp;
                    prefix?: Uint8Array;
                    prehashKey?: HashOp;
                    prehashValue?: HashOp;
                };
                path?: {
                    hash?: HashOp;
                    prefix?: Uint8Array;
                    suffix?: Uint8Array;
                }[];
                value?: Uint8Array;
            };
        }

        • Optionalkey?: Uint8Array

          TODO: remove this as unnecessary??? we prove a range

        • Optionalleft?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[]

          • Optionalvalue?: Uint8Array

        • Optionalright?: {
              key?: Uint8Array;
              leaf?: {
                  hash?: HashOp;
                  length?: LengthOp;
                  prefix?: Uint8Array;
                  prehashKey?: HashOp;
                  prehashValue?: HashOp;
              };
              path?: {
                  hash?: HashOp;
                  prefix?: Uint8Array;
                  suffix?: Uint8Array;
              }[];
              value?: Uint8Array;
          }

          • Optionalkey?: Uint8Array

          • Optionalleaf?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            }

            • Optionalhash?: HashOp

            • Optionallength?: LengthOp

            • Optionalprefix?: Uint8Array

              prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

            • OptionalprehashKey?: HashOp

            • OptionalprehashValue?: HashOp

          • Optionalpath?: {
                hash?: HashOp;
                prefix?: Uint8Array;
                suffix?: Uint8Array;
            }[]

          • Optionalvalue?: Uint8Array

      Returns NonExistenceProof

  • fromProtoMsg:function

    • fromProtoMsg(message): NonExistenceProof

    • Parameters

      • message: NonExistenceProofProtoMsg

      Returns NonExistenceProof

  • toAmino:function

    • toAmino(message): NonExistenceProofAmino

    • Parameters

      • message: NonExistenceProof

      Returns NonExistenceProofAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: NonExistenceProof

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): NonExistenceProofProtoMsg

    • Parameters

      • message: NonExistenceProof

      Returns NonExistenceProofProtoMsg

• ProofSpec: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ProofSpec;
      encode(message: ProofSpec, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ProofSpecAmino): ProofSpec;
      fromAminoMsg(object: ProofSpecAminoMsg): ProofSpec;
      fromPartial(object: {
          innerSpec?: {
              childOrder?: number[];
              childSize?: number;
              emptyChild?: Uint8Array;
              hash?: HashOp;
              maxPrefixLength?: number;
              minPrefixLength?: number;
          };
          leafSpec?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          };
          maxDepth?: number;
          minDepth?: number;
      }): ProofSpec;
      fromProtoMsg(message: ProofSpecProtoMsg): ProofSpec;
      toAmino(message: ProofSpec): ProofSpecAmino;
      toProto(message: ProofSpec): Uint8Array;
      toProtoMsg(message: ProofSpec): ProofSpecProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ProofSpec

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ProofSpec

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ProofSpec
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ProofSpec

    • Parameters

      • object: ProofSpecAmino

      Returns ProofSpec

  • fromAminoMsg:function

    • fromAminoMsg(object): ProofSpec

    • Parameters

      • object: ProofSpecAminoMsg

      Returns ProofSpec

  • fromPartial:function

    • fromPartial(object): ProofSpec

    • Parameters

      • object: {
            innerSpec?: {
                childOrder?: number[];
                childSize?: number;
                emptyChild?: Uint8Array;
                hash?: HashOp;
                maxPrefixLength?: number;
                minPrefixLength?: number;
            };
            leafSpec?: {
                hash?: HashOp;
                length?: LengthOp;
                prefix?: Uint8Array;
                prehashKey?: HashOp;
                prehashValue?: HashOp;
            };
            maxDepth?: number;
            minDepth?: number;
        }

        • OptionalinnerSpec?: {
              childOrder?: number[];
              childSize?: number;
              emptyChild?: Uint8Array;
              hash?: HashOp;
              maxPrefixLength?: number;
              minPrefixLength?: number;
          }

          • OptionalchildOrder?: number[]

            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)

          • OptionalchildSize?: number

          • OptionalemptyChild?: Uint8Array

            empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0)

          • Optionalhash?: HashOp

            hash is the algorithm that must be used for each InnerOp

          • OptionalmaxPrefixLength?: number

          • OptionalminPrefixLength?: number

        • OptionalleafSpec?: {
              hash?: HashOp;
              length?: LengthOp;
              prefix?: Uint8Array;
              prehashKey?: HashOp;
              prehashValue?: HashOp;
          }

          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)

          • Optionalhash?: HashOp

          • Optionallength?: LengthOp

          • Optionalprefix?: Uint8Array

            prefix is a fixed bytes that may optionally be included at the beginning to differentiate a leaf node from an inner node.

          • OptionalprehashKey?: HashOp

          • OptionalprehashValue?: HashOp

        • OptionalmaxDepth?: number

          max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries)

        • OptionalminDepth?: number

          min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries)

      Returns ProofSpec

  • fromProtoMsg:function

    • fromProtoMsg(message): ProofSpec

    • Parameters

      • message: ProofSpecProtoMsg

      Returns ProofSpec

  • toAmino:function

    • toAmino(message): ProofSpecAmino

    • Parameters

      • message: ProofSpec

      Returns ProofSpecAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ProofSpec

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ProofSpecProtoMsg

    • Parameters

      • message: ProofSpec

      Returns ProofSpecProtoMsg

• hashOpFromJSON:function

  • hashOpFromJSON(object): HashOp

  • Parameters

    • object: any

    Returns HashOp

• hashOpToJSON:function

  • hashOpToJSON(object): string

  • Parameters

    • object: HashOp

    Returns string

• lengthOpFromJSON:function

  • lengthOpFromJSON(object): LengthOp

  • Parameters

    • object: any

    Returns LengthOp

• lengthOpToJSON:function

  • lengthOpToJSON(object): string

  • Parameters

    • object: LengthOp

    Returns string