@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

package/cosmos/ics23/v1/proofs.d.ts

@@ -68,6 +68,9 @@ export declare function lengthOpToJSON(object: LengthOp): string;
  * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
  * in the ProofSpec is valuable to prevent this mutability. And why all trees should
  * length-prefix the data before hashing it.
+ * @name ExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ExistenceProof
  */
 export interface ExistenceProof {
     key: Uint8Array;
@@ -99,6 +102,9 @@ export interface ExistenceProofProtoMsg {
  * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
  * in the ProofSpec is valuable to prevent this mutability. And why all trees should
  * length-prefix the data before hashing it.
+ * @name ExistenceProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ExistenceProof
  */
 export interface ExistenceProofAmino {
     key?: string;
@@ -114,9 +120,14 @@ export interface ExistenceProofAminoMsg {
  * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
  * one right of the desired key. If both proofs are valid AND they are neighbors,
  * then there is no valid proof for the given key.
+ * @name NonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.NonExistenceProof
  */
 export interface NonExistenceProof {
-    /** TODO: remove this as unnecessary??? we prove a range */
+    /**
+     * TODO: remove this as unnecessary??? we prove a range
+     */
     key: Uint8Array;
     left?: ExistenceProof;
     right?: ExistenceProof;
@@ -129,9 +140,14 @@ export interface NonExistenceProofProtoMsg {
  * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
  * one right of the desired key. If both proofs are valid AND they are neighbors,
  * then there is no valid proof for the given key.
+ * @name NonExistenceProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.NonExistenceProof
  */
 export interface NonExistenceProofAmino {
-    /** TODO: remove this as unnecessary??? we prove a range */
+    /**
+     * TODO: remove this as unnecessary??? we prove a range
+     */
     key?: string;
     left?: ExistenceProofAmino;
     right?: ExistenceProofAmino;
@@ -140,7 +156,12 @@ export interface NonExistenceProofAminoMsg {
     type: "cosmos-sdk/NonExistenceProof";
     value: NonExistenceProofAmino;
 }
-/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+/**
+ * CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+ * @name CommitmentProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CommitmentProof
+ */
 export interface CommitmentProof {
     exist?: ExistenceProof;
     nonexist?: NonExistenceProof;
@@ -151,7 +172,12 @@ export interface CommitmentProofProtoMsg {
     typeUrl: "/cosmos.ics23.v1.CommitmentProof";
     value: Uint8Array;
 }
-/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
+/**
+ * CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+ * @name CommitmentProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CommitmentProof
+ */
 export interface CommitmentProofAmino {
     exist?: ExistenceProofAmino;
     nonexist?: NonExistenceProofAmino;
@@ -177,6 +203,9 @@ export interface CommitmentProofAminoMsg {
  *
  * Then combine the bytes, and hash it
  * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ * @name LeafOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.LeafOp
  */
 export interface LeafOp {
     hash: HashOp;
@@ -208,6 +237,9 @@ export interface LeafOpProtoMsg {
  *
  * Then combine the bytes, and hash it
  * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ * @name LeafOpAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.LeafOp
  */
 export interface LeafOpAmino {
     hash?: HashOp;
@@ -240,6 +272,9 @@ export interface LeafOpAminoMsg {
  * Any special data, like prepending child with the length, or prepending the entire operation with
  * some value to differentiate from leaf nodes, should be included in prefix and suffix.
  * If either of prefix or suffix is empty, we just treat it as an empty string
+ * @name InnerOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerOp
  */
 export interface InnerOp {
     hash: HashOp;
@@ -266,6 +301,9 @@ export interface InnerOpProtoMsg {
  * Any special data, like prepending child with the length, or prepending the entire operation with
  * some value to differentiate from leaf nodes, should be included in prefix and suffix.
  * If either of prefix or suffix is empty, we just treat it as an empty string
+ * @name InnerOpAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerOp
  */
 export interface InnerOpAmino {
     hash?: HashOp;
@@ -287,6 +325,9 @@ export interface InnerOpAminoMsg {
  * generate a given hash (by interpretting the preimage differently).
  * We need this for proper security, requires client knows a priori what
  * tree format server uses. But not in code, rather a configuration object.
+ * @name ProofSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ProofSpec
  */
 export interface ProofSpec {
     /**
@@ -300,7 +341,9 @@ export interface ProofSpec {
      * the max_depth is interpreted as 128 if set to 0
      */
     maxDepth: number;
-    /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
+    /**
+     * min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries)
+     */
     minDepth: number;
     /**
      * prehash_key_before_comparison is a flag that indicates whether to use the
@@ -324,6 +367,9 @@ export interface ProofSpecProtoMsg {
  * generate a given hash (by interpretting the preimage differently).
  * We need this for proper security, requires client knows a priori what
  * tree format server uses. But not in code, rather a configuration object.
+ * @name ProofSpecAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ProofSpec
  */
 export interface ProofSpecAmino {
     /**
@@ -337,7 +383,9 @@ export interface ProofSpecAmino {
      * the max_depth is interpreted as 128 if set to 0
      */
     max_depth?: number;
-    /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
+    /**
+     * min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries)
+     */
     min_depth?: number;
     /**
      * prehash_key_before_comparison is a flag that indicates whether to use the
@@ -359,6 +407,9 @@ export interface ProofSpecAminoMsg {
  * isLeftMost(spec: InnerSpec, op: InnerOp)
  * isRightMost(spec: InnerSpec, op: InnerOp)
  * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+ * @name InnerSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerSpec
  */
 export interface InnerSpec {
     /**
@@ -369,11 +420,17 @@ export interface InnerSpec {
     childOrder: number[];
     childSize: number;
     minPrefixLength: number;
-    /** the max prefix length must be less than the minimum prefix length + child size */
+    /**
+     * the max prefix length must be less than the minimum prefix length + child size
+     */
     maxPrefixLength: number;
-    /** empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) */
+    /**
+     * 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 is the algorithm that must be used for each InnerOp
+     */
     hash: HashOp;
 }
 export interface InnerSpecProtoMsg {
@@ -389,6 +446,9 @@ export interface InnerSpecProtoMsg {
  * isLeftMost(spec: InnerSpec, op: InnerOp)
  * isRightMost(spec: InnerSpec, op: InnerOp)
  * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+ * @name InnerSpecAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerSpec
  */
 export interface InnerSpecAmino {
     /**
@@ -399,18 +459,29 @@ export interface InnerSpecAmino {
     child_order?: number[];
     child_size?: number;
     min_prefix_length?: number;
-    /** the max prefix length must be less than the minimum prefix length + child size */
+    /**
+     * the max prefix length must be less than the minimum prefix length + child size
+     */
     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 is the prehash image that is used when one child is nil (eg. 20 bytes of 0)
+     */
     empty_child?: string;
-    /** hash is the algorithm that must be used for each InnerOp */
+    /**
+     * hash is the algorithm that must be used for each InnerOp
+     */
     hash?: HashOp;
 }
 export interface InnerSpecAminoMsg {
     type: "cosmos-sdk/InnerSpec";
     value: InnerSpecAmino;
 }
-/** BatchProof is a group of multiple proof types than can be compressed */
+/**
+ * BatchProof is a group of multiple proof types than can be compressed
+ * @name BatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchProof
+ */
 export interface BatchProof {
     entries: BatchEntry[];
 }
@@ -418,7 +489,12 @@ export interface BatchProofProtoMsg {
     typeUrl: "/cosmos.ics23.v1.BatchProof";
     value: Uint8Array;
 }
-/** BatchProof is a group of multiple proof types than can be compressed */
+/**
+ * BatchProof is a group of multiple proof types than can be compressed
+ * @name BatchProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchProof
+ */
 export interface BatchProofAmino {
     entries?: BatchEntryAmino[];
 }
@@ -426,7 +502,12 @@ export interface BatchProofAminoMsg {
     type: "cosmos-sdk/BatchProof";
     value: BatchProofAmino;
 }
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name BatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchEntry
+ */
 export interface BatchEntry {
     exist?: ExistenceProof;
     nonexist?: NonExistenceProof;
@@ -435,7 +516,12 @@ export interface BatchEntryProtoMsg {
     typeUrl: "/cosmos.ics23.v1.BatchEntry";
     value: Uint8Array;
 }
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name BatchEntryAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchEntry
+ */
 export interface BatchEntryAmino {
     exist?: ExistenceProofAmino;
     nonexist?: NonExistenceProofAmino;
@@ -444,6 +530,11 @@ export interface BatchEntryAminoMsg {
     type: "cosmos-sdk/BatchEntry";
     value: BatchEntryAmino;
 }
+/**
+ * @name CompressedBatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchProof
+ */
 export interface CompressedBatchProof {
     entries: CompressedBatchEntry[];
     lookupInners: InnerOp[];
@@ -452,6 +543,11 @@ export interface CompressedBatchProofProtoMsg {
     typeUrl: "/cosmos.ics23.v1.CompressedBatchProof";
     value: Uint8Array;
 }
+/**
+ * @name CompressedBatchProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchProof
+ */
 export interface CompressedBatchProofAmino {
     entries?: CompressedBatchEntryAmino[];
     lookup_inners?: InnerOpAmino[];
@@ -460,7 +556,12 @@ export interface CompressedBatchProofAminoMsg {
     type: "cosmos-sdk/CompressedBatchProof";
     value: CompressedBatchProofAmino;
 }
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name CompressedBatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchEntry
+ */
 export interface CompressedBatchEntry {
     exist?: CompressedExistenceProof;
     nonexist?: CompressedNonExistenceProof;
@@ -469,7 +570,12 @@ export interface CompressedBatchEntryProtoMsg {
     typeUrl: "/cosmos.ics23.v1.CompressedBatchEntry";
     value: Uint8Array;
 }
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name CompressedBatchEntryAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchEntry
+ */
 export interface CompressedBatchEntryAmino {
     exist?: CompressedExistenceProofAmino;
     nonexist?: CompressedNonExistenceProofAmino;
@@ -478,30 +584,51 @@ export interface CompressedBatchEntryAminoMsg {
     type: "cosmos-sdk/CompressedBatchEntry";
     value: CompressedBatchEntryAmino;
 }
+/**
+ * @name CompressedExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedExistenceProof
+ */
 export interface CompressedExistenceProof {
     key: Uint8Array;
     value: Uint8Array;
     leaf?: LeafOp;
-    /** these are indexes into the lookup_inners table in CompressedBatchProof */
+    /**
+     * these are indexes into the lookup_inners table in CompressedBatchProof
+     */
     path: number[];
 }
 export interface CompressedExistenceProofProtoMsg {
     typeUrl: "/cosmos.ics23.v1.CompressedExistenceProof";
     value: Uint8Array;
 }
+/**
+ * @name CompressedExistenceProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedExistenceProof
+ */
 export interface CompressedExistenceProofAmino {
     key?: string;
     value?: string;
     leaf?: LeafOpAmino;
-    /** these are indexes into the lookup_inners table in CompressedBatchProof */
+    /**
+     * these are indexes into the lookup_inners table in CompressedBatchProof
+     */
     path?: number[];
 }
 export interface CompressedExistenceProofAminoMsg {
     type: "cosmos-sdk/CompressedExistenceProof";
     value: CompressedExistenceProofAmino;
 }
+/**
+ * @name CompressedNonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedNonExistenceProof
+ */
 export interface CompressedNonExistenceProof {
-    /** TODO: remove this as unnecessary??? we prove a range */
+    /**
+     * TODO: remove this as unnecessary??? we prove a range
+     */
     key: Uint8Array;
     left?: CompressedExistenceProof;
     right?: CompressedExistenceProof;
@@ -510,8 +637,15 @@ export interface CompressedNonExistenceProofProtoMsg {
     typeUrl: "/cosmos.ics23.v1.CompressedNonExistenceProof";
     value: Uint8Array;
 }
+/**
+ * @name CompressedNonExistenceProofAmino
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedNonExistenceProof
+ */
 export interface CompressedNonExistenceProofAmino {
-    /** TODO: remove this as unnecessary??? we prove a range */
+    /**
+     * TODO: remove this as unnecessary??? we prove a range
+     */
     key?: string;
     left?: CompressedExistenceProofAmino;
     right?: CompressedExistenceProofAmino;
@@ -520,6 +654,30 @@ export interface CompressedNonExistenceProofAminoMsg {
     type: "cosmos-sdk/CompressedNonExistenceProof";
     value: CompressedNonExistenceProofAmino;
 }
+/**
+ * ExistenceProof takes a key and a value and a set of steps to perform on it.
+ * The result of peforming all these steps will provide a "root hash", which can
+ * be compared to the value in a header.
+ *
+ * Since it is computationally infeasible to produce a hash collission for any of the used
+ * cryptographic hash functions, if someone can provide a series of operations to transform
+ * a given key and value into a root hash that matches some trusted root, these key and values
+ * must be in the referenced merkle tree.
+ *
+ * The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
+ * which should be controlled by a spec. Eg. with lengthOp as NONE,
+ * prefix = FOO, key = BAR, value = CHOICE
+ * and
+ * prefix = F, key = OOBAR, value = CHOICE
+ * would produce the same value.
+ *
+ * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
+ * in the ProofSpec is valuable to prevent this mutability. And why all trees should
+ * length-prefix the data before hashing it.
+ * @name ExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ExistenceProof
+ */
 export declare const ExistenceProof: {
     typeUrl: string;
     aminoType: string;
@@ -534,6 +692,14 @@ export declare const ExistenceProof: {
     toProto(message: ExistenceProof): Uint8Array;
     toProtoMsg(message: ExistenceProof): ExistenceProofProtoMsg;
 };
+/**
+ * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
+ * one right of the desired key. If both proofs are valid AND they are neighbors,
+ * then there is no valid proof for the given key.
+ * @name NonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.NonExistenceProof
+ */
 export declare const NonExistenceProof: {
     typeUrl: string;
     aminoType: string;
@@ -548,6 +714,12 @@ export declare const NonExistenceProof: {
     toProto(message: NonExistenceProof): Uint8Array;
     toProtoMsg(message: NonExistenceProof): NonExistenceProofProtoMsg;
 };
+/**
+ * CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
+ * @name CommitmentProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CommitmentProof
+ */
 export declare const CommitmentProof: {
     typeUrl: string;
     aminoType: string;
@@ -562,6 +734,25 @@ export declare const CommitmentProof: {
     toProto(message: CommitmentProof): Uint8Array;
     toProtoMsg(message: CommitmentProof): CommitmentProofProtoMsg;
 };
+/**
+ * LeafOp represents the raw key-value data we wish to prove, and
+ * must be flexible to represent the internal transformation from
+ * the original key-value pairs into the basis hash, for many existing
+ * merkle trees.
+ *
+ * key and value are passed in. So that the signature of this operation is:
+ * leafOp(key, value) -> output
+ *
+ * To process this, first prehash the keys and values if needed (ANY means no hash in this case):
+ * hkey = prehashKey(key)
+ * hvalue = prehashValue(value)
+ *
+ * Then combine the bytes, and hash it
+ * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
+ * @name LeafOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.LeafOp
+ */
 export declare const LeafOp: {
     typeUrl: string;
     aminoType: string;
@@ -576,6 +767,26 @@ export declare const LeafOp: {
     toProto(message: LeafOp): Uint8Array;
     toProtoMsg(message: LeafOp): LeafOpProtoMsg;
 };
+/**
+ * InnerOp represents a merkle-proof step that is not a leaf.
+ * It represents concatenating two children and hashing them to provide the next result.
+ *
+ * The result of the previous step is passed in, so the signature of this op is:
+ * innerOp(child) -> output
+ *
+ * The result of applying InnerOp should be:
+ * output = op.hash(op.prefix || child || op.suffix)
+ *
+ * where the || operator is concatenation of binary data,
+ * and child is the result of hashing all the tree below this step.
+ *
+ * Any special data, like prepending child with the length, or prepending the entire operation with
+ * some value to differentiate from leaf nodes, should be included in prefix and suffix.
+ * If either of prefix or suffix is empty, we just treat it as an empty string
+ * @name InnerOp
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerOp
+ */
 export declare const InnerOp: {
     typeUrl: string;
     aminoType: string;
@@ -590,6 +801,21 @@ export declare const InnerOp: {
     toProto(message: InnerOp): Uint8Array;
     toProtoMsg(message: InnerOp): InnerOpProtoMsg;
 };
+/**
+ * ProofSpec defines what the expected parameters are for a given proof type.
+ * This can be stored in the client and used to validate any incoming proofs.
+ *
+ * verify(ProofSpec, Proof) -> Proof | Error
+ *
+ * As demonstrated in tests, if we don't fix the algorithm used to calculate the
+ * LeafHash for a given tree, there are many possible key-value pairs that can
+ * generate a given hash (by interpretting the preimage differently).
+ * We need this for proper security, requires client knows a priori what
+ * tree format server uses. But not in code, rather a configuration object.
+ * @name ProofSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.ProofSpec
+ */
 export declare const ProofSpec: {
     typeUrl: string;
     aminoType: string;
@@ -604,6 +830,19 @@ export declare const ProofSpec: {
     toProto(message: ProofSpec): Uint8Array;
     toProtoMsg(message: ProofSpec): ProofSpecProtoMsg;
 };
+/**
+ * InnerSpec contains all store-specific structure info to determine if two proofs from a
+ * given store are neighbors.
+ *
+ * This enables:
+ *
+ * isLeftMost(spec: InnerSpec, op: InnerOp)
+ * isRightMost(spec: InnerSpec, op: InnerOp)
+ * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
+ * @name InnerSpec
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.InnerSpec
+ */
 export declare const InnerSpec: {
     typeUrl: string;
     aminoType: string;
@@ -618,6 +857,12 @@ export declare const InnerSpec: {
     toProto(message: InnerSpec): Uint8Array;
     toProtoMsg(message: InnerSpec): InnerSpecProtoMsg;
 };
+/**
+ * BatchProof is a group of multiple proof types than can be compressed
+ * @name BatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchProof
+ */
 export declare const BatchProof: {
     typeUrl: string;
     aminoType: string;
@@ -632,6 +877,12 @@ export declare const BatchProof: {
     toProto(message: BatchProof): Uint8Array;
     toProtoMsg(message: BatchProof): BatchProofProtoMsg;
 };
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name BatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.BatchEntry
+ */
 export declare const BatchEntry: {
     typeUrl: string;
     aminoType: string;
@@ -646,6 +897,11 @@ export declare const BatchEntry: {
     toProto(message: BatchEntry): Uint8Array;
     toProtoMsg(message: BatchEntry): BatchEntryProtoMsg;
 };
+/**
+ * @name CompressedBatchProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchProof
+ */
 export declare const CompressedBatchProof: {
     typeUrl: string;
     aminoType: string;
@@ -660,6 +916,12 @@ export declare const CompressedBatchProof: {
     toProto(message: CompressedBatchProof): Uint8Array;
     toProtoMsg(message: CompressedBatchProof): CompressedBatchProofProtoMsg;
 };
+/**
+ * Use BatchEntry not CommitmentProof, to avoid recursion
+ * @name CompressedBatchEntry
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedBatchEntry
+ */
 export declare const CompressedBatchEntry: {
     typeUrl: string;
     aminoType: string;
@@ -674,6 +936,11 @@ export declare const CompressedBatchEntry: {
     toProto(message: CompressedBatchEntry): Uint8Array;
     toProtoMsg(message: CompressedBatchEntry): CompressedBatchEntryProtoMsg;
 };
+/**
+ * @name CompressedExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedExistenceProof
+ */
 export declare const CompressedExistenceProof: {
     typeUrl: string;
     aminoType: string;
@@ -688,6 +955,11 @@ export declare const CompressedExistenceProof: {
     toProto(message: CompressedExistenceProof): Uint8Array;
     toProtoMsg(message: CompressedExistenceProof): CompressedExistenceProofProtoMsg;
 };
+/**
+ * @name CompressedNonExistenceProof
+ * @package cosmos.ics23.v1
+ * @see proto type: cosmos.ics23.v1.CompressedNonExistenceProof
+ */
 export declare const CompressedNonExistenceProof: {
     typeUrl: string;
     aminoType: string;