@lightprotocol/stateless.js 0.21.0 → 0.22.0

package/dist/cjs/node/rpc-interface.d.ts

@@ -1,6 +1,6 @@
 import { PublicKey, MemcmpFilter, DataSlice } from '@solana/web3.js';
 import { Struct } from 'superstruct';
-import { BN254, ValidityProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData, StateTreeInfo, AddressTreeInfo, CompressedProof } from './state';
+import { BN254, ValidityProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData, TreeInfo, AddressTreeInfo, CompressedProof } from './state';
 import BN from 'bn.js';
 export interface LatestNonVotingSignatures {
     context: {
@@ -54,7 +54,7 @@ export interface HashWithTreeInfo {
     /**
      * State tree info.
      */
-    stateTreeInfo: StateTreeInfo;
+    stateTreeInfo: TreeInfo;
 }
 /**
  * Address and associated address tree info.
@@ -125,7 +125,7 @@ export type ValidityProofWithContext = {
     /**
      * Validity proof.
      */
-    compressedProof: ValidityProof;
+    compressedProof: ValidityProof | null;
     /**
      * Roots.
      */
@@ -145,7 +145,11 @@ export type ValidityProofWithContext = {
     /**
      * Tree infos.
      */
-    treeInfos: StateTreeInfo[];
+    treeInfos: TreeInfo[];
+    /**
+     * Whether to prove by indices.
+     */
+    proveByIndices: boolean[];
 };
 /**
  * @deprecated use {@link ValidityProofWithContext} instead
@@ -260,6 +264,79 @@ export declare const CompressedAccountResult: Struct<{
     seq: Struct<BN | null, null>;
     slotCreated: Struct<BN, null>;
 }>;
+export declare const CompressedAccountResultV2: Struct<{
+    data: {
+        data: string;
+        dataHash: BN;
+        discriminator: BN;
+    } | null;
+    lamports: BN;
+    address: number[] | null;
+    hash: BN;
+    owner: PublicKey;
+    leafIndex: number;
+    seq: BN | null;
+    slotCreated: BN;
+    merkleContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+    proveByIndex: boolean;
+}, {
+    address: Struct<number[] | null, null>;
+    hash: Struct<BN, null>;
+    data: Struct<{
+        data: string;
+        dataHash: BN;
+        discriminator: BN;
+    } | null, {
+        data: Struct<string, null>;
+        dataHash: Struct<BN, null>;
+        discriminator: Struct<BN, null>;
+    }>;
+    lamports: Struct<BN, null>;
+    owner: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    seq: Struct<BN | null, null>;
+    slotCreated: Struct<BN, null>;
+    merkleContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+    proveByIndex: Struct<boolean, null>;
+}>;
 export declare const TokenDataResult: Struct<{
     owner: PublicKey;
     mint: PublicKey;
@@ -350,7 +427,333 @@ export declare const CompressedTokenAccountResult: Struct<{
 /**
  * @internal
  */
-export declare const MultipleCompressedAccountsResult: Struct<{
+export declare const CompressedTokenAccountResultV2: Struct<{
+    tokenData: {
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    };
+    account: {
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
+    };
+}, {
+    tokenData: Struct<{
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    }, {
+        mint: Struct<PublicKey, null>;
+        owner: Struct<PublicKey, null>;
+        amount: Struct<BN, null>;
+        delegate: Struct<PublicKey | null, null>;
+        state: Struct<string, null>;
+    }>;
+    account: Struct<{
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
+    }>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleCompressedAccountsResult: Struct<{
+    items: {
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        tree: PublicKey;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+    }[];
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        tree: PublicKey;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+    }[], Struct<{
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        tree: PublicKey;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleCompressedAccountsResultV2: Struct<{
+    items: {
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
+    }[];
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
+    }[], Struct<{
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        lamports: BN;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        seq: BN | null;
+        slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountsByOwnerResult: Struct<{
     items: {
         data: {
             data: string;
@@ -366,6 +769,7 @@ export declare const MultipleCompressedAccountsResult: Struct<{
         seq: BN | null;
         slotCreated: BN;
     }[];
+    cursor: string | null;
 }, {
     items: Struct<{
         data: {
@@ -414,11 +818,12 @@ export declare const MultipleCompressedAccountsResult: Struct<{
         seq: Struct<BN | null, null>;
         slotCreated: Struct<BN, null>;
     }>>;
+    cursor: Struct<string | null, null>;
 }>;
 /**
  * @internal
  */
-export declare const CompressedAccountsByOwnerResult: Struct<{
+export declare const CompressedAccountsByOwnerResultV2: Struct<{
     items: {
         data: {
             data: string;
@@ -426,13 +831,25 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
-        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
         slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
     }[];
     cursor: string | null;
 }, {
@@ -443,13 +860,25 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
-        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
         slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
     }[], Struct<{
         data: {
             data: string;
@@ -457,13 +886,25 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
-        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
         slotCreated: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        proveByIndex: boolean;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
@@ -479,9 +920,37 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
         lamports: Struct<BN, null>;
         owner: Struct<PublicKey, null>;
         leafIndex: Struct<number, null>;
-        tree: Struct<PublicKey, null>;
         seq: Struct<BN | null, null>;
         slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
     }>>;
     cursor: Struct<string | null, null>;
 }>;
@@ -611,6 +1080,208 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
     }>>;
     cursor: Struct<string | null, null>;
 }>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountsByOwnerOrDelegateResultV2: Struct<{
+    items: {
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null;
+            lamports: BN;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            proveByIndex: boolean;
+        };
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null;
+            lamports: BN;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            proveByIndex: boolean;
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null;
+            lamports: BN;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            proveByIndex: boolean;
+        };
+    }, {
+        tokenData: Struct<{
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        }, {
+            mint: Struct<PublicKey, null>;
+            owner: Struct<PublicKey, null>;
+            amount: Struct<BN, null>;
+            delegate: Struct<PublicKey | null, null>;
+            state: Struct<string, null>;
+        }>;
+        account: Struct<{
+            data: {
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null;
+            lamports: BN;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            proveByIndex: boolean;
+        }, {
+            address: Struct<number[] | null, null>;
+            hash: Struct<BN, null>;
+            data: Struct<{
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null, {
+                data: Struct<string, null>;
+                dataHash: Struct<BN, null>;
+                discriminator: Struct<BN, null>;
+            }>;
+            lamports: Struct<BN, null>;
+            owner: Struct<PublicKey, null>;
+            leafIndex: Struct<number, null>;
+            seq: Struct<BN | null, null>;
+            slotCreated: Struct<BN, null>;
+            merkleContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            }, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+                nextTreeContext: Struct<{
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined, {
+                    treeType: Struct<number, null>;
+                    tree: Struct<PublicKey, null>;
+                    queue: Struct<PublicKey, null>;
+                    cpiContext: Struct<PublicKey | null, null>;
+                }>;
+            }>;
+            proveByIndex: Struct<boolean, null>;
+        }>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
 /**
  * @internal
  */
@@ -676,7 +1347,7 @@ export declare const LatestNonVotingSignaturesResultPaginated: Struct<{
 /**
  * @internal
  */
-export declare const MerkeProofResult: Struct<{
+export declare const MerkleProofResult: Struct<{
     root: BN;
     hash: BN;
     leafIndex: number;
@@ -691,6 +1362,64 @@ export declare const MerkeProofResult: Struct<{
     rootSeq: Struct<number, null>;
     root: Struct<BN, null>;
 }>;
+/**
+ * @internal
+ */
+export declare const MerkleProofResultV2: Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    proveByIndex: boolean;
+    proof: BN[];
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    root: Struct<BN, null>;
+    rootSeq: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+    treeContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+}>;
 /**
  * @internal
  */
@@ -715,6 +1444,16 @@ export declare const NewAddressProofResult: Struct<{
     higherRangeAddress: Struct<BN, null>;
     lowElementLeafIndex: Struct<number, null>;
 }>;
+/**
+ * @internal
+ */
+export declare const RootIndexResultV2: Struct<{
+    proveByIndex: boolean;
+    rootIndex: number;
+}, {
+    rootIndex: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+}>;
 /**
  * @internal
  */
@@ -745,6 +1484,206 @@ export declare const ValidityProofResult: Struct<{
     roots: Struct<BN[], Struct<BN, null>>;
     merkleTrees: Struct<PublicKey[], Struct<PublicKey, null>>;
 }>;
+export declare const ValidityProofResultV2: Struct<{
+    accounts: {
+        root: BN;
+        hash: BN;
+        leafIndex: number;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            proveByIndex: boolean;
+            rootIndex: number;
+        };
+    }[];
+    compressedProof: {
+        a: number[];
+        c: number[];
+        b: number[];
+    } | null;
+    addresses: {
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }[];
+}, {
+    compressedProof: Struct<{
+        a: number[];
+        c: number[];
+        b: number[];
+    } | null, {
+        a: Struct<number[], Struct<number, null>>;
+        b: Struct<number[], Struct<number, null>>;
+        c: Struct<number[], Struct<number, null>>;
+    }>;
+    accounts: Struct<{
+        root: BN;
+        hash: BN;
+        leafIndex: number;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            proveByIndex: boolean;
+            rootIndex: number;
+        };
+    }[], Struct<{
+        root: BN;
+        hash: BN;
+        leafIndex: number;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            proveByIndex: boolean;
+            rootIndex: number;
+        };
+    }, {
+        hash: Struct<BN, null>;
+        root: Struct<BN, null>;
+        rootIndex: Struct<{
+            proveByIndex: boolean;
+            rootIndex: number;
+        }, {
+            rootIndex: Struct<number, null>;
+            proveByIndex: Struct<boolean, null>;
+        }>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        leafIndex: Struct<number, null>;
+    }>>;
+    addresses: Struct<{
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }[], Struct<{
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }, {
+        address: Struct<BN, null>;
+        root: Struct<BN, null>;
+        rootIndex: Struct<number, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+    }>>;
+}>;
 /**
  * @internal
  */
@@ -770,6 +1709,83 @@ export declare const MultipleMerkleProofsResult: Struct<{
     rootSeq: Struct<number, null>;
     root: Struct<BN, null>;
 }>>;
+/**
+ * @internal
+ */
+export declare const MultipleMerkleProofsResultV2: Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    proveByIndex: boolean;
+    proof: BN[];
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}[], Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    proveByIndex: boolean;
+    proof: BN[];
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    root: Struct<BN, null>;
+    rootSeq: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+    treeContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+}>>;
 /**
  * @internal
  */
@@ -897,6 +1913,9 @@ export declare const SignatureListWithCursorResult: Struct<{
     }>>;
     cursor: Struct<string | null, null>;
 }>;
+/**
+ * @internal
+ */
 export declare const CompressedTransactionResult: Struct<{
     compressionInfo: {
         closedAccounts: {
@@ -1191,6 +2210,529 @@ export declare const CompressedTransactionResult: Struct<{
     }>;
     transaction: Struct<any, null>;
 }>;
+/**
+ * @internal
+ */
+export declare const CompressedTransactionResultV2: Struct<{
+    compressionInfo: {
+        closedAccounts: {
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                lamports: BN;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                seq: BN | null;
+                slotCreated: BN;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                proveByIndex: boolean;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    };
+    transaction?: any;
+}, {
+    compressionInfo: Struct<{
+        closedAccounts: {
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                lamports: BN;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                seq: BN | null;
+                slotCreated: BN;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                proveByIndex: boolean;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    }, {
+        closedAccounts: Struct<{
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                account: {
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                };
+                txHash: BN;
+                nullifier: BN;
+            }, {
+                account: Struct<{
+                    data: {
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null;
+                    lamports: BN;
+                    address: number[] | null;
+                    hash: BN;
+                    owner: PublicKey;
+                    leafIndex: number;
+                    seq: BN | null;
+                    slotCreated: BN;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    proveByIndex: boolean;
+                }, {
+                    address: Struct<number[] | null, null>;
+                    hash: Struct<BN, null>;
+                    data: Struct<{
+                        data: string;
+                        dataHash: BN;
+                        discriminator: BN;
+                    } | null, {
+                        data: Struct<string, null>;
+                        dataHash: Struct<BN, null>;
+                        discriminator: Struct<BN, null>;
+                    }>;
+                    lamports: Struct<BN, null>;
+                    owner: Struct<PublicKey, null>;
+                    leafIndex: Struct<number, null>;
+                    seq: Struct<BN | null, null>;
+                    slotCreated: Struct<BN, null>;
+                    merkleContext: Struct<{
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    }, {
+                        treeType: Struct<number, null>;
+                        tree: Struct<PublicKey, null>;
+                        queue: Struct<PublicKey, null>;
+                        cpiContext: Struct<PublicKey | null, null>;
+                        nextTreeContext: Struct<{
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined, {
+                            treeType: Struct<number, null>;
+                            tree: Struct<PublicKey, null>;
+                            queue: Struct<PublicKey, null>;
+                            cpiContext: Struct<PublicKey | null, null>;
+                        }>;
+                    }>;
+                    proveByIndex: Struct<boolean, null>;
+                }>;
+                txHash: Struct<BN, null>;
+                nullifier: Struct<BN, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+        openedAccounts: Struct<{
+            account: {
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                lamports: BN;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                seq: BN | null;
+                slotCreated: BN;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                proveByIndex: boolean;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                lamports: BN;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                seq: BN | null;
+                slotCreated: BN;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                proveByIndex: boolean;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                lamports: BN;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                seq: BN | null;
+                slotCreated: BN;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                proveByIndex: boolean;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+                merkleContext: Struct<{
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                }, {
+                    treeType: Struct<number, null>;
+                    tree: Struct<PublicKey, null>;
+                    queue: Struct<PublicKey, null>;
+                    cpiContext: Struct<PublicKey | null, null>;
+                    nextTreeContext: Struct<{
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined, {
+                        treeType: Struct<number, null>;
+                        tree: Struct<PublicKey, null>;
+                        queue: Struct<PublicKey, null>;
+                        cpiContext: Struct<PublicKey | null, null>;
+                    }>;
+                }>;
+                proveByIndex: Struct<boolean, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+    }>;
+    transaction: Struct<any, null>;
+}>;
 export interface CompressionApiInterface {
     getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
     getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN | null>;