@lightprotocol/stateless.js 0.20.9 → 0.22.0

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

@@ -1,6 +1,6 @@
 import { PublicKey, MemcmpFilter, DataSlice } from '@solana/web3.js';
 import { Struct } from 'superstruct';
-import { BN254, CompressedProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData } from './state';
+import { BN254, ValidityProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData, TreeInfo, AddressTreeInfo, CompressedProof } from './state';
 import BN from 'bn.js';
 export interface LatestNonVotingSignatures {
     context: {
@@ -43,6 +43,32 @@ export interface SignatureWithMetadata {
     signature: string;
     slot: number;
 }
+/**
+ * Account hash and associated state tree info.
+ */
+export interface HashWithTreeInfo {
+    /**
+     * Account hash.
+     */
+    hash: BN254;
+    /**
+     * State tree info.
+     */
+    stateTreeInfo: TreeInfo;
+}
+/**
+ * Address and associated address tree info.
+ */
+export interface AddressWithTreeInfo {
+    /**
+     * Address.
+     */
+    address: BN254;
+    /**
+     * Address tree info.
+     */
+    addressTreeInfo: AddressTreeInfo;
+}
 export interface HashWithTree {
     hash: BN254;
     tree: PublicKey;
@@ -53,6 +79,10 @@ export interface AddressWithTree {
     tree: PublicKey;
     queue: PublicKey;
 }
+export interface AddressWithTreeInfo {
+    address: BN254;
+    treeInfo: AddressTreeInfo;
+}
 export interface CompressedTransaction {
     compressionInfo: {
         closedAccounts: {
@@ -85,6 +115,45 @@ export interface HexInputsForProver {
     pathElements: string[];
     leaf: string;
 }
+/**
+ * Validity proof with context.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ */
+export type ValidityProofWithContext = {
+    /**
+     * Validity proof.
+     */
+    compressedProof: ValidityProof | null;
+    /**
+     * Roots.
+     */
+    roots: BN[];
+    /**
+     * Root indices.
+     */
+    rootIndices: number[];
+    /**
+     * Leaf indices.
+     */
+    leafIndices: number[];
+    /**
+     * Leaves.
+     */
+    leaves: BN[];
+    /**
+     * Tree infos.
+     */
+    treeInfos: TreeInfo[];
+    /**
+     * Whether to prove by indices.
+     */
+    proveByIndices: boolean[];
+};
+/**
+ * @deprecated use {@link ValidityProofWithContext} instead
+ */
 export type CompressedProofWithContext = {
     compressedProof: CompressedProof;
     roots: BN[];
@@ -169,11 +238,11 @@ export declare const CompressedAccountResult: Struct<{
         discriminator: BN;
     } | null;
     lamports: BN;
+    tree: PublicKey;
     address: number[] | null;
     hash: BN;
     owner: PublicKey;
     leafIndex: number;
-    tree: PublicKey;
     seq: BN | null;
     slotCreated: BN;
 }, {
@@ -195,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;
@@ -226,11 +368,11 @@ export declare const CompressedTokenAccountResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     };
@@ -255,11 +397,11 @@ export declare const CompressedTokenAccountResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -282,6 +424,132 @@ export declare const CompressedTokenAccountResult: Struct<{
         slotCreated: Struct<BN, null>;
     }>;
 }>;
+/**
+ * @internal
+ */
+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
  */
@@ -293,11 +561,11 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[];
@@ -309,11 +577,11 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
@@ -323,11 +591,11 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             discriminator: BN;
         } | null;
         lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -353,7 +621,7 @@ export declare const MultipleCompressedAccountsResult: Struct<{
 /**
  * @internal
  */
-export declare const CompressedAccountsByOwnerResult: Struct<{
+export declare const MultipleCompressedAccountsResultV2: Struct<{
     items: {
         data: {
             data: string;
@@ -365,11 +633,22 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         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<{
         data: {
@@ -382,9 +661,21 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         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;
@@ -396,9 +687,21 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
         hash: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         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>;
@@ -414,69 +717,277 @@ 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>;
 }>;
 /**
  * @internal
  */
-export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+export declare const CompressedAccountsByOwnerResult: 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;
-            tree: PublicKey;
-            seq: BN | null;
-            slotCreated: BN;
-        };
+        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;
     }[];
     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;
-            tree: PublicKey;
-            seq: BN | null;
-            slotCreated: BN;
-        };
+        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<{
-        tokenData: {
-            owner: PublicKey;
-            mint: PublicKey;
+        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>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountsByOwnerResultV2: 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;
+    }[];
+    cursor: string | null;
+}, {
+    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>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountsByOwnerOrDelegateResult: 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;
+            tree: PublicKey;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+        };
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
             amount: BN;
             delegate: PublicKey | null;
             state: string;
@@ -488,11 +999,34 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 discriminator: BN;
             } | null;
             lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
             owner: PublicKey;
             leafIndex: number;
+            seq: BN | null;
+            slotCreated: BN;
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            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;
         };
@@ -517,11 +1051,11 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 discriminator: BN;
             } | null;
             lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         }, {
@@ -546,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
  */
@@ -611,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;
@@ -626,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
  */
@@ -650,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
  */
@@ -680,30 +1484,307 @@ 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
+ */
+export declare const MultipleMerkleProofsResult: Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+}[], Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+}>>;
 /**
  * @internal
  */
-export declare const MultipleMerkleProofsResult: Struct<{
+export declare const MultipleMerkleProofsResultV2: Struct<{
     root: BN;
     hash: BN;
     leafIndex: number;
-    merkleTree: PublicKey;
+    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;
-    merkleTree: PublicKey;
+    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>;
-    merkleTree: Struct<PublicKey, null>;
     proof: Struct<BN[], Struct<BN, null>>;
-    rootSeq: Struct<number, 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
@@ -832,6 +1913,9 @@ export declare const SignatureListWithCursorResult: Struct<{
     }>>;
     cursor: Struct<string | null, null>;
 }>;
+/**
+ * @internal
+ */
 export declare const CompressedTransactionResult: Struct<{
     compressionInfo: {
         closedAccounts: {
@@ -842,11 +1926,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -866,11 +1950,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -894,11 +1978,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -918,11 +2002,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -943,11 +2027,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -966,11 +2050,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -989,11 +2073,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1037,11 +2121,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1060,11 +2144,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1083,11 +2167,11 @@ export declare const CompressedTransactionResult: Struct<{
                     discriminator: BN;
                 } | null;
                 lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1126,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>;
@@ -1133,9 +2740,9 @@ export interface CompressionApiInterface {
     getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
     getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
-    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<CompressedProofWithContext>;
-    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     getCompressedTokenAccountsByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;