@lightprotocol/stateless.js 0.21.0 → 0.22.0

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, Connection, Commitment, Keypair, Signer, ConfirmOptions, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, TransactionSignature, RpcResponseAndContext, SignatureResult, DataSlice, MemcmpFilter, ConnectionConfig, ParsedTransactionWithMeta, AccountMeta } from '@solana/web3.js';
+import { PublicKey, Connection, Commitment, Keypair, Signer, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, DataSlice, MemcmpFilter, ConnectionConfig, ParsedTransactionWithMeta, AccountMeta } from '@solana/web3.js';
 import { Buffer as Buffer$1 } from 'buffer';
 import { Struct } from 'superstruct';
 import BN from 'bn.js';
@@ -94,7 +94,7 @@ declare function confirmTransaction(connection: Connection, signature: string, c
  * @param targetLamports - Target priority fee in lamports
  * @param computeUnits - Expected compute units used by the transaction
  * @returns microLamports per compute unit (use in
- * `ComputeBudgetProgram.setComputeUnitPrice`)
+ * {@link https://github.com/solana-foundation/solana-web3.js/blob/maintenance/v1.x/src/programs/compute-budget.ts#L218})
  */
 declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;
 
@@ -128,163 +128,11 @@ declare function hashToBn254FieldSizeBe(bytes: Buffer$1): [Buffer$1, number] | n
 declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
 /** Mutates array in place */
 declare function pushUniqueItems<T>(items: T[], map: T[]): void;
+declare function convertInvokeCpiWithReadOnlyToInvoke(data: any): InstructionDataInvoke;
 
 /** @internal remove signer from signers if part of signers */
 declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];
 
-declare const FIELD_SIZE: BN;
-declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
-declare const COMPUTE_BUDGET_PATTERN: number[];
-declare const INVOKE_DISCRIMINATOR: Buffer$1;
-declare const INVOKE_CPI_DISCRIMINATOR: Buffer$1;
-declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer$1;
-declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
-declare const lightProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
-declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
-declare const getRegisteredProgramPda: () => PublicKey;
-declare const getAccountCompressionAuthority: () => PublicKey;
-declare const defaultStaticAccounts: () => PublicKey[];
-declare const defaultStaticAccountsStruct: () => {
-    registeredProgramPda: PublicKey;
-    noopProgram: PublicKey;
-    accountCompressionProgram: PublicKey;
-    accountCompressionAuthority: PublicKey;
-    cpiSignatureAccount: null;
-};
-type StateTreeLUTPair = {
-    stateTreeLookupTable: PublicKey;
-    nullifyLookupTable: PublicKey;
-};
-/**
- * Returns the Default Public State Tree LUTs for Devnet and Mainnet-Beta.
- */
-declare const defaultStateTreeLookupTables: () => {
-    mainnet: StateTreeLUTPair[];
-    devnet: StateTreeLUTPair[];
-};
-/**
- * @internal
- */
-declare const isLocalTest: (url: string) => boolean;
-/**
- * @internal
- */
-declare const localTestActiveStateTreeInfo: () => StateTreeInfo[];
-declare const getDefaultAddressTreeInfo: () => {
-    tree: PublicKey;
-    queue: PublicKey;
-    cpiContext: null;
-    treeType: TreeType;
-    nextTreeInfo: null;
-};
-/**
- * @deprecated use {@link rpc.getStateTreeInfos} and {@link selectStateTreeInfo} instead.
- * for address trees, use {@link getDefaultAddressTreeInfo} instead.
- * Use only with Localnet testing.
- * For public networks, fetch via {@link defaultStateTreeLookupTables} and {@link getAllStateTreeInfos}.
- */
-declare const defaultTestStateTreeAccounts: () => {
-    nullifierQueue: PublicKey;
-    merkleTree: PublicKey;
-    merkleTreeHeight: number;
-    addressTree: PublicKey;
-    addressQueue: PublicKey;
-};
-/**
- * @internal testing only
- */
-declare const defaultTestStateTreeAccounts2: () => {
-    nullifierQueue2: PublicKey;
-    merkleTree2: PublicKey;
-};
-declare const COMPRESSED_TOKEN_PROGRAM_ID: PublicKey;
-declare const stateTreeLookupTableMainnet = "7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st";
-declare const nullifiedStateTreeLookupTableMainnet = "H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT";
-declare const stateTreeLookupTableDevnet = "Dk9mNkbiZXJZ4By8DfSP6HEE4ojZzRvucwpawLeuwq8q";
-declare const nullifiedStateTreeLookupTableDevnet = "AXbHzp1NgjLvpfnD6JRTTovXZ7APUCdtWZFCRr5tCxse";
-declare const nullifierQueuePubkey = "nfq1NvQDJ2GEgnS8zt9prAe8rjjpAW1zFkrvZoBR148";
-declare const cpiContextPubkey = "cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fonubE4";
-declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
-declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
-declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
-declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
-declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
-declare const cpiContext2Pubkey = "cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK";
-declare const confirmConfig: ConfirmOptions;
-declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
-declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;
-/** Threshold (per asset) at which new in-UTXOs get merged, in order to reduce UTXO pool size */
-declare const UTXO_MERGE_THRESHOLD = 20;
-declare const UTXO_MERGE_MAXIMUM = 10;
-/**
- * Treshold after which the currently used transaction Merkle tree is switched
- * to the next one
- */
-declare const TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD: BN;
-/**
- * Fee to provide continous funding for the state Merkle tree.
- * Once the state Merkle tree is at 95% capacity the accumulated fees
- * will be used to fund the next state Merkle tree with the same parameters.
- *
- * Is charged per output compressed account.
- */
-declare const STATE_MERKLE_TREE_ROLLOVER_FEE: BN;
-/**
- * Fee to provide continous funding for the address queue and address Merkle tree.
- * Once the address Merkle tree is at 95% capacity the accumulated fees
- * will be used to fund the next address queue and address tree with the same parameters.
- *
- * Is charged per newly created address.
- */
-declare const ADDRESS_QUEUE_ROLLOVER_FEE: BN;
-/**
- * Is charged if the transaction nullifies at least one compressed account.
- */
-declare const STATE_MERKLE_TREE_NETWORK_FEE: BN;
-/**
- * Is charged if the transaction creates at least one address.
- */
-declare const ADDRESS_TREE_NETWORK_FEE: BN;
-
-/**
- * @deprecated use {@link selectStateTreeInfo} instead.
- *
- * Get a random tree and queue from a set of provided state tree infos.
- *
- * @param infos Set of state tree infos
- * @returns A random tree and queue
- */
-declare function pickRandomTreeAndQueue(infos: StateTreeInfo[]): {
-    tree: PublicKey;
-    queue: PublicKey;
-};
-/**
- * Get a pseudo-random active state tree info from the set of provided state
- * tree infos.
- *
- * Using this mitigates write lock contention on state trees.
- *
- * @param infos                 Set of state tree infos
- * @param treeType              The type of tree. Defaults to `TreeType.StateV1`
- * @param useMaxConcurrency     If true, return all infos. If false, return at
- *                              most {@link MAX_HOTSPOTS}. Defaults to `false`.
- *
- * @returns A pseudo-randomly selected tree info
- */
-declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): StateTreeInfo;
-/**
- * Get active state tree infos from LUTs.
- *
- * @param connection            The connection to the cluster
- * @param stateTreeLUTPairs     The state tree lookup table pairs
- *
- * @returns The active state tree infos
- */
-declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
-    connection: Connection;
-    stateTreeLUTPairs: StateTreeLUTPair[];
-}): Promise<StateTreeInfo[]>;
-
 interface GnarkProofJson {
     ar: string[];
     bs: string[][];
@@ -341,7 +189,7 @@ declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, confirmOpt
  * @param blockHashCtx      blockhash context for confirmation
  * @return SignatureResult
  */
-declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, _blockHashCtx?: {
     blockhash: string;
     lastValidBlockHeight: number;
 }): Promise<RpcResponseAndContext<SignatureResult>>;
@@ -360,6 +208,13 @@ declare function buildAndSignTx(instructions: TransactionInstruction[], payer: S
 
 declare function sleep(ms: number): Promise<void>;
 
+declare const validateSufficientBalance: (balance: BN) => void;
+declare const validateSameOwner: (compressedAccounts: CompressedAccountLegacy[] | CompressedAccountWithMerkleContext[]) => void;
+declare const validateNumbersForProof: (hashesLength: number, newAddressesLength: number) => void;
+declare const validateNumbersForInclusionProof: (hashesLength: number) => void;
+declare const validateNumbersForNonInclusionProof: (newAddressesLength: number) => void;
+declare const validateNumbers: (length: number, allowedNumbers: number[], type: string) => void;
+
 /**
  * Create two lookup tables storing all public state tree and queue addresses
  * returns lookup table addresses and txId
@@ -428,111 +283,320 @@ declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyL
     txId: string;
 }>;
 
-declare const validateSufficientBalance: (balance: BN) => void;
-declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | CompressedAccountWithMerkleContext[]) => void;
-declare const validateNumbersForProof: (hashesLength: number, newAddressesLength: number) => void;
-declare const validateNumbersForInclusionProof: (hashesLength: number) => void;
-declare const validateNumbersForNonInclusionProof: (newAddressesLength: number) => void;
-declare const validateNumbers: (length: number, allowedNumbers: number[], type: string) => void;
-
-declare enum TreeType {
-    /**
-     * v1 state merkle tree
-     */
-    StateV1 = 1,
-    /**
-     * v1 address merkle tree
-     */
-    AddressV1 = 2,
-    /**
-     * v2 state merkle tree
-     */
-    StateV2 = 3,
-    /**
-     * v2 address merkle tree
-     */
-    AddressV2 = 4
+declare enum VERSION {
+    V1 = "V1",
+    V2 = "V2"
 }
 /**
- * @deprecated Use {@link StateTreeInfo} instead.
- *
- * A bundle of active trees for a given tree type.
+/**
+ * @internal
+ * Feature flags. Only use if you know what you are doing.
  */
-type ActiveTreeBundle = {
-    tree: PublicKey;
-    queue: PublicKey | null;
-    cpiContext: PublicKey | null;
-    treeType: TreeType;
+declare const featureFlags: {
+    version: VERSION;
+    isV2: () => boolean;
 };
 /**
- * State tree info, versioned via {@link TreeType}. The protocol
- * stores compressed accounts in state trees.
- *
- * Onchain Accounts are subject to Solana's write-lock limits.
- *
- * To load balance transactions, use {@link selectStateTreeInfo} to
- * select a random tree from a range of active trees.
- *
- * Example:
- * ```typescript
- * const infos = await rpc.getStateTreeInfos();
- * const info = selectStateTreeInfo(infos);
- * const ix = await CompressedTokenProgram.compress({
- *     // ...
- *     outputStateTreeInfo: info
- * });
- * ```
+ * Returns the correct endpoint name for the current API version. E.g.
+ * versionedEndpoint('getCompressedAccount') -> 'getCompressedAccount' (V1)
+ * or 'getCompressedAccountV2' (V2)
  */
-type StateTreeInfo = {
-    /**
-     * Pubkey of the tree account.
-     */
-    tree: PublicKey;
-    /**
-     * Pubkey of the queue account associated with the tree.
-     */
-    queue: PublicKey;
-    /**
-     * The type of tree. One of {@link TreeType}.
-     */
-    treeType: TreeType;
-    /**
-     * Optional compressed cpi context account.
-     */
-    cpiContext?: PublicKey;
-    /**
-     * Optional next tree info if the tree is full.
-     */
-    nextTreeInfo: StateTreeInfo | null;
+declare const versionedEndpoint: (base: string) => string;
+declare const FIELD_SIZE: BN;
+declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
+declare const COMPUTE_BUDGET_PATTERN: number[];
+declare const INVOKE_DISCRIMINATOR: Buffer$1;
+declare const INVOKE_CPI_DISCRIMINATOR: Buffer$1;
+declare const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR: Buffer$1;
+declare const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR: Buffer$1;
+declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer$1;
+declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
+declare const lightSystemProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
+declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
+declare const getRegisteredProgramPda: () => PublicKey;
+declare const getAccountCompressionAuthority: () => PublicKey;
+declare const defaultStaticAccounts: () => PublicKey[];
+declare const defaultStaticAccountsStruct: () => {
+    registeredProgramPda: PublicKey;
+    noopProgram: PublicKey;
+    accountCompressionProgram: PublicKey;
+    accountCompressionAuthority: PublicKey;
+    cpiSignatureAccount: null;
+};
+type StateTreeLUTPair = {
+    stateTreeLookupTable: PublicKey;
+    nullifyLookupTable: PublicKey;
 };
 /**
- * Address tree info, versioned via {@link TreeType}. The protocol
- * stores PDAs in address trees.
+ * Returns the Default Public State Tree LUTs for Devnet and Mainnet-Beta.
  */
-type AddressTreeInfo = Omit<StateTreeInfo, 'cpiContext' | 'nextTreeInfo'> & {
-    nextTreeInfo: AddressTreeInfo | null;
+declare const defaultStateTreeLookupTables: () => {
+    mainnet: StateTreeLUTPair[];
+    devnet: StateTreeLUTPair[];
 };
-interface PackedCompressedAccountWithMerkleContext {
-    compressedAccount: CompressedAccount;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    readOnly: boolean;
-}
-interface PackedMerkleContext {
-    merkleTreePubkeyIndex: number;
-    nullifierQueuePubkeyIndex: number;
-    leafIndex: number;
-    queueIndex: null | QueueIndex;
-}
-interface QueueIndex {
-    queueId: number;
-    index: number;
-}
 /**
- * Describe the generic compressed account details applicable to every
- * compressed account.
- * */
-interface CompressedAccount {
+ * @internal
+ */
+declare const isLocalTest: (url: string) => boolean;
+/**
+ * @internal
+ */
+declare const localTestActiveStateTreeInfos: () => TreeInfo[];
+declare const getDefaultAddressTreeInfo: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: null;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
+/**
+ * @deprecated use {@link rpc.getStateTreeInfos} and {@link selectStateTreeInfo} instead.
+ * for address trees, use {@link getDefaultAddressTreeInfo} instead.
+ * Use only with Localnet testing.
+ * For public networks, fetch via {@link defaultStateTreeLookupTables} and {@link getAllStateTreeInfos}.
+ */
+declare const defaultTestStateTreeAccounts: () => {
+    nullifierQueue: PublicKey;
+    merkleTree: PublicKey;
+    merkleTreeHeight: number;
+    addressTree: PublicKey;
+    addressQueue: PublicKey;
+};
+/**
+ * @internal testing only
+ */
+declare const defaultTestStateTreeAccounts2: () => {
+    nullifierQueue2: PublicKey;
+    merkleTree2: PublicKey;
+};
+declare const COMPRESSED_TOKEN_PROGRAM_ID: PublicKey;
+declare const stateTreeLookupTableMainnet = "7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st";
+declare const nullifiedStateTreeLookupTableMainnet = "H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT";
+declare const stateTreeLookupTableDevnet = "Dk9mNkbiZXJZ4By8DfSP6HEE4ojZzRvucwpawLeuwq8q";
+declare const nullifiedStateTreeLookupTableDevnet = "AXbHzp1NgjLvpfnD6JRTTovXZ7APUCdtWZFCRr5tCxse";
+declare const nullifierQueuePubkey = "nfq1NvQDJ2GEgnS8zt9prAe8rjjpAW1zFkrvZoBR148";
+declare const cpiContextPubkey = "cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fonubE4";
+declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
+declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
+declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
+declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
+declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
+declare const cpiContext2Pubkey = "cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK";
+declare const batchMerkleTree = "HLKs5NJ8FXkJg8BrzJt56adFYYuwg5etzDtBbQYTsixu";
+declare const batchQueue = "6L7SzhYB3anwEQ9cphpJ1U7Scwj57bx2xueReg7R9cKU";
+declare const confirmConfig: ConfirmOptions;
+declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
+declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;
+/** Threshold (per asset) at which new in-UTXOs get merged, in order to reduce UTXO pool size */
+declare const UTXO_MERGE_THRESHOLD = 20;
+declare const UTXO_MERGE_MAXIMUM = 10;
+/**
+ * Treshold after which the currently used transaction Merkle tree is switched
+ * to the next one
+ */
+declare const TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD: BN;
+/**
+ * Fee to provide continous funding for the state Merkle tree.
+ * Once the state Merkle tree is at 95% capacity the accumulated fees
+ * will be used to fund the next state Merkle tree with the same parameters.
+ *
+ * Is charged per output compressed account.
+ */
+declare const STATE_MERKLE_TREE_ROLLOVER_FEE: BN;
+/**
+ * Fee to provide continous funding for the address queue and address Merkle tree.
+ * Once the address Merkle tree is at 95% capacity the accumulated fees
+ * will be used to fund the next address queue and address tree with the same parameters.
+ *
+ * Is charged per newly created address.
+ */
+declare const ADDRESS_QUEUE_ROLLOVER_FEE: BN;
+/**
+ * Is charged if the transaction nullifies at least one compressed account.
+ */
+declare const STATE_MERKLE_TREE_NETWORK_FEE: BN;
+/**
+ * Is charged if the transaction creates at least one address.
+ */
+declare const ADDRESS_TREE_NETWORK_FEE: BN;
+
+/**
+ * @deprecated use {@link getTreeInfoByPubkey} instead
+ */
+declare function getStateTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+declare function getTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+/**
+ * @deprecated use {@link selectStateTreeInfo} instead.
+ *
+ * Get a random tree and queue from a set of provided state tree infos.
+ *
+ * @param infos Set of state tree infos
+ * @returns A random tree and queue
+ */
+declare function pickRandomTreeAndQueue(infos: TreeInfo[]): {
+    tree: PublicKey;
+    queue: PublicKey;
+};
+/**
+ * Select a pseudo-random active state tree info from the set of provided state
+ * tree infos.
+ *
+ * Using this reduces write-lock contention on state trees.
+ *
+ * @param infos                 Set of state tree infos
+ *
+ * @param treeType              Optional: Only use if you know what you are
+ *                              doing. The type of tree.
+ * @param useMaxConcurrency     Optional: Only use if you know what you are
+ *                              doing. If true, select from all infos.
+ *
+ * @returns A pseudo-randomly selected tree info
+ */
+declare function selectStateTreeInfo(infos: TreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): TreeInfo;
+/**
+ * Get active state tree infos from LUTs.
+ *
+ * @param connection            The connection to the cluster
+ * @param stateTreeLUTPairs     The state tree lookup table pairs
+ *
+ * @returns The active state tree infos
+ */
+declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
+    connection: Connection;
+    stateTreeLUTPairs: StateTreeLUTPair[];
+}): Promise<TreeInfo[]>;
+
+declare enum TreeType {
+    /**
+     * v1 state merkle tree
+     */
+    StateV1 = 1,
+    /**
+     * v1 address merkle tree
+     */
+    AddressV1 = 2,
+    /**
+     * v2 state merkle tree
+     */
+    StateV2 = 3,
+    /**
+     * v2 address merkle tree
+     */
+    AddressV2 = 4
+}
+/**
+ * @deprecated Use {@link TreeInfo} instead.
+ *
+ * A bundle of active trees for a given tree type.
+ */
+type ActiveTreeBundle = {
+    /**
+     * Tree.
+     */
+    tree: PublicKey;
+    /**
+     * Queue.
+     */
+    queue: PublicKey | null;
+    /**
+     * CPI context.
+     */
+    cpiContext: PublicKey | null;
+    /**
+     * Tree type.
+     */
+    treeType: TreeType;
+};
+/**
+ * @deprecated Use {@link TreeInfo} instead.
+ *
+ * State tree info, versioned via {@link TreeType}. The protocol
+ * stores compressed accounts in state trees.
+ */
+type StateTreeInfo = TreeInfo;
+/**
+ * Tree info, versioned via {@link TreeType}. The protocol
+ * stores compressed accounts in state trees, and PDAs in address trees.
+ *
+ * Onchain Accounts are subject to Solana's write-lock limits.
+ *
+ * To load balance transactions, use {@link selectStateTreeInfo} to
+ * randomly select a tree from a range of active trees.
+ *
+ * Example:
+ * ```typescript
+ * const infos = await rpc.getStateTreeInfos();
+ * const info = selectStateTreeInfo(infos);
+ * const ix = await CompressedTokenProgram.compress({
+ *     // ...
+ *     outputStateTreeInfo: info
+ * });
+ * ```
+ */
+type TreeInfo = {
+    /**
+     * Pubkey of the tree account.
+     */
+    tree: PublicKey;
+    /**
+     * Pubkey of the queue account associated with the tree.
+     */
+    queue: PublicKey;
+    /**
+     * The type of tree. One of {@link TreeType}.
+     */
+    treeType: TreeType;
+    /**
+     * Optional compressed cpi context account.
+     */
+    cpiContext?: PublicKey;
+    /**
+     * Next tree info. Is `some` if the next tree should be used for the next
+     * state transition.
+     */
+    nextTreeInfo: TreeInfo | null;
+};
+/**
+ * @deprecated Use {@link TreeInfo} instead.
+ *
+ * Address tree info, versioned via {@link TreeType}. The protocol
+ * stores PDAs in address trees.
+ */
+type AddressTreeInfo = Omit<StateTreeInfo, 'cpiContext' | 'nextTreeInfo'> & {
+    /**
+     * Next tree info.
+     */
+    nextTreeInfo: AddressTreeInfo | null;
+};
+/**
+ * Packed merkle context.
+ */
+interface PackedMerkleContextLegacy {
+    /**
+     * Merkle tree pubkey index.
+     */
+    merkleTreePubkeyIndex: number;
+    /**
+     * Queue pubkey index in remaining accounts.
+     */
+    queuePubkeyIndex: number;
+    /**
+     * Leaf index.
+     */
+    leafIndex: number;
+    /**
+     * Whether to prove by index or validity proof.
+     */
+    proveByIndex: boolean;
+}
+/**
+ * @deprecated Use {@link CompressedAccount} instead.
+ *
+ * Describe the generic compressed account details applicable to every
+ * compressed account.
+ *
+ * */
+interface CompressedAccountLegacy {
     /**
      * Public key of program or user owning the account.
      */
@@ -551,64 +615,217 @@ interface CompressedAccount {
     data: CompressedAccountData | null;
 }
 /**
+ * @deprecated Use {@link CompressedAccountMeta} instead.
+ *
  * Describe the generic compressed account details applicable to every
  * compressed account.
  */
 interface OutputCompressedAccountWithPackedContext {
-    compressedAccount: CompressedAccount;
+    compressedAccount: CompressedAccountLegacy;
     merkleTreeIndex: number;
 }
+/**
+ * Compressed account-related proof metadata.
+ */
+type AccountProofInput = {
+    hash: BN;
+    treeInfo: TreeInfo;
+    leafIndex: number;
+    rootIndex: number;
+    proveByIndex: boolean;
+};
+/**
+ * New address proof metadata.
+ */
+type NewAddressProofInput = {
+    treeInfo: TreeInfo;
+    address: number[];
+    rootIndex: number;
+    root: BN;
+};
+/**
+ * Describes compressed account data.
+ */
 interface CompressedAccountData {
+    /**
+     * 8 bytes.
+     */
     discriminator: number[];
+    /**
+     * Data.
+     */
     data: Buffer$1;
+    /**
+     * 32 bytes.
+     */
     dataHash: number[];
 }
+/**
+ * Merkle tree sequence number.
+ */
 interface MerkleTreeSequenceNumber {
+    /**
+     * Public key.
+     */
     pubkey: PublicKey;
+    /**
+     * Sequence number.
+     */
     seq: BN;
 }
+/**
+ * Public transaction event.
+ */
 interface PublicTransactionEvent {
+    /**
+     * Input compressed account hashes.
+     */
     inputCompressedAccountHashes: number[][];
+    /**
+     * Output compressed account hashes.
+     */
     outputCompressedAccountHashes: number[][];
-    outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Output compressed accounts.
+     */
+    outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Output leaf indices.
+     */
     outputLeafIndices: number[];
+    /**
+     * Sequence numbers.
+     */
     sequenceNumbers: MerkleTreeSequenceNumber[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Whether it's a compress or decompress instruction.
+     */
     isCompress: boolean;
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * Public keys.
+     */
     pubkeyArray: PublicKey[];
+    /**
+     * Message. Default is null.
+     */
     message: Uint8Array | null;
 }
+/**
+ * Instruction data for invoke.
+ */
 interface InstructionDataInvoke {
+    /**
+     * Validity proof.
+     */
     proof: ValidityProof | null;
+    /**
+     * Input compressed accounts with merkle context.
+     */
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
+    /**
+     * Output compressed accounts.
+     */
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Params for creating new addresses.
+     */
     newAddressParams: NewAddressParamsPacked[];
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * Whether it's a compress or decompress instruction.
+     */
     isCompress: boolean;
 }
+/**
+ * Instruction data for invoking a CPI.
+ */
 interface InstructionDataInvokeCpi {
+    /**
+     * Validity proof.
+     */
     proof: ValidityProof | null;
+    /**
+     * Input compressed accounts with merkle context.
+     */
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
+    /**
+     * Output compressed accounts.
+     */
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Params for creating new addresses.
+     */
     newAddressParams: NewAddressParamsPacked[];
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * If `compressOrDecompressLamports` is some, whether it's a compress or
+     * decompress instruction.
+     */
     isCompress: boolean;
+    /**
+     * Optional compressed CPI context.
+     */
     compressedCpiContext: CompressedCpiContext | null;
 }
+/**
+ * Compressed CPI context.
+ *
+ * Use if you want to use a single {@link ValidityProof} to update two
+ * compressed accounts owned by separate programs.
+ */
 interface CompressedCpiContext {
-    set_context: boolean;
-    first_set_context: boolean;
-    cpi_context_account_index: number;
+    /**
+     * Is set by the program that is invoking the CPI to signal that it should
+     * set the cpi context.
+     */
+    setContext: boolean;
+    /**
+     * Is set to wipe the cpi context since someone could have set it before
+     * with unrelated data.
+     */
+    firstSetContext: boolean;
+    /**
+     * Index of cpi context account in remaining accounts.
+     */
+    cpiContextAccountIndex: number;
 }
 /**
  * @deprecated Use {@link ValidityProof} instead.
  */
 interface CompressedProof {
+    /**
+     * 32 bytes.
+     */
     a: number[];
+    /**
+     * 64 bytes.
+     */
     b: number[];
+    /**
+     * 32 bytes.
+     */
     c: number[];
 }
 /**
@@ -617,38 +834,124 @@ interface CompressedProof {
  * You can request proofs via `rpc.getValidityProof` or
  * `rpc.getValidityProofV0`.
  *
- * One proof is 128 bytes large, and can prove the existence of N compressed
- * accounts or the uniqueness of N PDAs.
+ * One proof can prove the existence of N compressed accounts or the uniqueness
+ * of N PDAs.
  */
 interface ValidityProof {
+    /**
+     * 32 bytes.
+     */
     a: number[];
+    /**
+     * 64 bytes.
+     */
     b: number[];
+    /**
+     * 32 bytes.
+     */
     c: number[];
 }
+/**
+ * Packed token data for input compressed accounts.
+ */
 interface InputTokenDataWithContext {
+    /**
+     * Amount of tokens.
+     */
     amount: BN;
+    /**
+     * Delegate index.
+     */
     delegateIndex: number | null;
-    merkleContext: PackedMerkleContext;
+    /**
+     * Merkle context.
+     */
+    merkleContext: PackedMerkleContextLegacy;
+    /**
+     * Root index.
+     */
     rootIndex: number;
+    /**
+     * Lamports.
+     */
     lamports: BN | null;
+    /**
+     * Tlv.
+     */
     tlv: Buffer$1 | null;
 }
+/**
+ * Token data.
+ */
 type TokenData$1 = {
+    /**
+     * The mint associated with this account.
+     */
     mint: PublicKey;
+    /**
+     * The owner of this account.
+     */
     owner: PublicKey;
+    /**
+     * The amount of tokens this account holds.
+     */
     amount: BN;
+    /**
+     * If `delegate` is `Some` then `delegated_amount` represents the amount
+     * authorized by the delegate.
+     */
     delegate: PublicKey | null;
+    /**
+     * The account's state.
+     */
     state: number;
+    /**
+     * Token extension tlv.
+     */
     tlv: Buffer$1 | null;
 };
 
+/**
+ * @deprecated use {@link CompressedAccount} instead
+ */
 type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
     readOnly: boolean;
 };
+/**
+ * @deprecated use {@link CompressedAccount} instead
+ */
+type CompressedAccountWithMerkleContextLegacy = CompressedAccount & MerkleContext;
+/**
+ * Compressed account + metadata about the state tree in which the account is
+ * stored.
+ */
+type CompressedAccount = {
+    /**
+     * Public key of program or user owning the account.
+     */
+    owner: PublicKey;
+    /**
+     * Lamports attached to the account.
+     */
+    lamports: BN;
+    /**
+     * Optional unique account ID that is persistent across transactions.
+     */
+    address: number[] | null;
+    /**
+     * Optional data attached to the account.
+     */
+    data: CompressedAccountData | null;
+} & MerkleContext & {
+    /**
+     * Read only.
+     */
+    readOnly: boolean;
+};
 /**
  * @deprecated use {@link MerkleContext} instead.
  *
- * Legacy MerkleContext
+ * Legacy MerkleContext.
  */
 type MerkleContextLegacy = {
     /**
@@ -675,7 +978,7 @@ type MerkleContext = {
     /**
      * Tree info
      */
-    treeInfo: StateTreeInfo;
+    treeInfo: TreeInfo;
     /**
      * Poseidon hash of the account. Stored as leaf in state tree
      */
@@ -706,9 +1009,109 @@ type MerkleContextWithMerkleProof = MerkleContext & {
      */
     root: BN254;
 };
-declare const createCompressedAccount: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccount;
-declare const createCompressedAccountWithMerkleContext: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
-declare const createMerkleContext: (treeInfo: StateTreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => MerkleContext;
+/**
+ * Packed compressed account and state tree info.
+ */
+type PackedStateTreeInfo = {
+    /**
+     * Recent valid root index.
+     */
+    rootIndex: number;
+    /**
+     * Whether the account can be proven by index or by merkle proof
+     */
+    proveByIndex: boolean;
+    /**
+     * Index of the merkle tree in which the account is stored.
+     */
+    merkleTreePubkeyIndex: number;
+    /**
+     * Index of the queue in which the account is stored.
+     */
+    queuePubkeyIndex: number;
+    /**
+     * Index of the leaf in the state tree.
+     */
+    leafIndex: number;
+};
+/**
+ * Packed tree info for a new program-derived address (PDA).
+ */
+type PackedAddressTreeInfo = {
+    /**
+     * Index of the merkle tree in which the account is stored.
+     */
+    addressMerkleTreePubkeyIndex: number;
+    /**
+     * Index of the queue in which the account is stored.
+     */
+    addressQueuePubkeyIndex: number;
+    /**
+     * Recent valid root index.
+     */
+    rootIndex: number;
+};
+/**
+ * Compressed account meta in instruction.
+ *
+ */
+type CompressedAccountMeta = {
+    /**
+     * Packed Tree info.
+     */
+    treeInfo: PackedStateTreeInfo;
+    /**
+     * Address.
+     */
+    address: number[] | null;
+    /**
+     * Lamports.
+     */
+    lamports: BN | null;
+    /**
+     * index of state tree in which the new account state is stored.
+     */
+    outputStateTreeIndex: number;
+};
+/**
+ * Create an output compressed account meta for a new account.
+ * Client-side only.
+ */
+declare const createCompressedAccountMeta: (treeInfo: PackedStateTreeInfo, outputStateTreeIndex: number, address?: number[], lamports?: BN) => CompressedAccountMeta;
+/**
+ * @deprecated Use {@link PackedStateTreeInfo} instead.
+ * Packed compressed account with merkle context.
+ */
+interface PackedCompressedAccountWithMerkleContext {
+    /**
+     * Compressed account.
+     */
+    compressedAccount: CompressedAccountLegacy;
+    /**
+     * Merkle context.
+     */
+    merkleContext: PackedMerkleContextLegacy;
+    /**
+     * Root index.
+     */
+    rootIndex: number;
+    /**
+     * Read only.
+     */
+    readOnly: boolean;
+}
+/**
+ * @deprecated use {@link createCompressedAccountMeta} instead.
+ */
+declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountLegacy;
+/**
+ * @deprecated.
+ */
+declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
+/**
+ * @deprecated use {@link createCompressedAccountMeta} instead.
+ */
+declare const createMerkleContextLegacy: (treeInfo: TreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => MerkleContext;
 
 interface LatestNonVotingSignatures {
     context: {
@@ -762,7 +1165,7 @@ interface HashWithTreeInfo {
     /**
      * State tree info.
      */
-    stateTreeInfo: StateTreeInfo;
+    stateTreeInfo: TreeInfo;
 }
 interface HashWithTree {
     hash: BN254;
@@ -833,7 +1236,7 @@ type ValidityProofWithContext = {
     /**
      * Validity proof.
      */
-    compressedProof: ValidityProof;
+    compressedProof: ValidityProof | null;
     /**
      * Roots.
      */
@@ -853,7 +1256,11 @@ type ValidityProofWithContext = {
     /**
      * Tree infos.
      */
-    treeInfos: StateTreeInfo[];
+    treeInfos: TreeInfo[];
+    /**
+     * Whether to prove by indices.
+     */
+    proveByIndices: boolean[];
 };
 /**
  * @deprecated use {@link ValidityProofWithContext} instead
@@ -936,26 +1343,71 @@ declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Struct<RpcR
  * @internal
  */
 declare const CompressedAccountResult: Struct<{
+    owner: PublicKey;
     lamports: BN;
-    tree: PublicKey;
+    address: number[] | null;
     data: {
         data: string;
-        dataHash: BN;
         discriminator: BN;
+        dataHash: BN;
     } | null;
-    address: number[] | null;
+    leafIndex: number;
+    seq: BN | null;
+    tree: PublicKey;
     hash: BN;
+    slotCreated: BN;
+}, {
+    address: Struct<number[] | null, null>;
+    hash: Struct<BN, null>;
+    data: Struct<{
+        data: string;
+        discriminator: BN;
+        dataHash: 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>;
+}>;
+declare const CompressedAccountResultV2: Struct<{
     owner: PublicKey;
+    lamports: BN;
+    address: number[] | null;
+    data: {
+        data: string;
+        discriminator: BN;
+        dataHash: BN;
+    } | null;
+    merkleContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
     leafIndex: number;
+    proveByIndex: boolean;
     seq: BN | null;
+    hash: BN;
     slotCreated: BN;
 }, {
     address: Struct<number[] | null, null>;
     hash: Struct<BN, null>;
     data: Struct<{
         data: string;
-        dataHash: BN;
         discriminator: BN;
+        dataHash: BN;
     } | null, {
         data: Struct<string, null>;
         dataHash: Struct<BN, null>;
@@ -964,9 +1416,37 @@ declare const CompressedAccountResult: 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>;
 }>;
 declare const TokenDataResult: Struct<{
     owner: PublicKey;
@@ -993,19 +1473,19 @@ declare const CompressedTokenAccountResult: Struct<{
         state: string;
     };
     account: {
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
-        slotCreated: BN;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
     };
 }, {
     tokenData: Struct<{
@@ -1022,26 +1502,124 @@ declare const CompressedTokenAccountResult: Struct<{
         state: Struct<string, null>;
     }>;
     account: Struct<{
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: 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
+ */
+declare const CompressedTokenAccountResultV2: Struct<{
+    tokenData: {
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    };
+    account: {
+        owner: PublicKey;
+        lamports: BN;
         address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
         hash: BN;
+        slotCreated: BN;
+    };
+}, {
+    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<{
         owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
         leafIndex: number;
+        proveByIndex: boolean;
         seq: BN | null;
+        hash: BN;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -1050,9 +1628,37 @@ declare const CompressedTokenAccountResult: 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>;
     }>;
 }>;
 /**
@@ -1060,56 +1666,56 @@ declare const CompressedTokenAccountResult: Struct<{
  */
 declare const MultipleCompressedAccountsResult: Struct<{
     items: {
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }[];
 }, {
     items: Struct<{
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }[], Struct<{
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -1126,59 +1732,191 @@ declare const MultipleCompressedAccountsResult: Struct<{
 /**
  * @internal
  */
-declare const CompressedAccountsByOwnerResult: Struct<{
+declare const MultipleCompressedAccountsResultV2: Struct<{
     items: {
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
+            discriminator: BN;
             dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+}, {
+    items: Struct<{
+        owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
             discriminator: BN;
+            dataHash: BN;
         } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        owner: PublicKey;
+        lamports: BN;
         address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
         hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: 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
+ */
+declare const CompressedAccountsByOwnerResult: Struct<{
+    items: {
         owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }[], Struct<{
+        owner: PublicKey;
         lamports: BN;
-        tree: PublicKey;
+        address: number[] | null;
         data: {
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null;
-        address: number[] | null;
-        hash: BN;
-        owner: PublicKey;
         leafIndex: number;
         seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            dataHash: BN;
             discriminator: BN;
+            dataHash: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -1196,28 +1934,162 @@ declare const CompressedAccountsByOwnerResult: Struct<{
 /**
  * @internal
  */
-declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+declare const CompressedAccountsByOwnerResultV2: Struct<{
     items: {
-        tokenData: {
-            owner: PublicKey;
-            mint: PublicKey;
-            amount: BN;
-            delegate: PublicKey | null;
-            state: string;
-        };
-        account: {
-            lamports: BN;
+        owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
             tree: PublicKey;
-            data: {
-                data: string;
-                dataHash: BN;
-                discriminator: BN;
-            } | null;
-            address: number[] | null;
-            hash: BN;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        owner: PublicKey;
+        lamports: BN;
+        address: number[] | null;
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: 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
+ */
+declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+    items: {
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
             owner: PublicKey;
+            lamports: BN;
+            address: number[] | null;
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
             leafIndex: number;
             seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
             slotCreated: BN;
         };
     }[];
@@ -1232,18 +2104,18 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: string;
         };
         account: {
+            owner: PublicKey;
             lamports: BN;
-            tree: PublicKey;
+            address: number[] | null;
             data: {
                 data: string;
-                dataHash: BN;
                 discriminator: BN;
+                dataHash: BN;
             } | null;
-            address: number[] | null;
-            hash: BN;
-            owner: PublicKey;
             leafIndex: number;
             seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
             slotCreated: BN;
         };
     }[], Struct<{
@@ -1255,18 +2127,18 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: string;
         };
         account: {
+            owner: PublicKey;
             lamports: BN;
-            tree: PublicKey;
+            address: number[] | null;
             data: {
                 data: string;
-                dataHash: BN;
                 discriminator: BN;
+                dataHash: BN;
             } | null;
-            address: number[] | null;
-            hash: BN;
-            owner: PublicKey;
             leafIndex: number;
             seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
             slotCreated: BN;
         };
     }, {
@@ -1284,26 +2156,200 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: Struct<string, null>;
         }>;
         account: Struct<{
+            owner: PublicKey;
             lamports: BN;
+            address: number[] | null;
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            leafIndex: number;
+            seq: BN | null;
             tree: PublicKey;
+            hash: BN;
+            slotCreated: BN;
+        }, {
+            address: Struct<number[] | null, null>;
+            hash: Struct<BN, null>;
+            data: Struct<{
+                data: string;
+                discriminator: BN;
+                dataHash: 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
+ */
+declare const CompressedTokenAccountsByOwnerOrDelegateResultV2: Struct<{
+    items: {
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            owner: PublicKey;
+            lamports: BN;
+            address: number[] | null;
             data: {
                 data: string;
+                discriminator: BN;
                 dataHash: BN;
+            } | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            owner: PublicKey;
+            lamports: BN;
+            address: number[] | null;
+            data: {
+                data: string;
                 discriminator: BN;
+                dataHash: BN;
             } | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            owner: PublicKey;
+            lamports: BN;
             address: number[] | null;
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
             hash: BN;
+            slotCreated: BN;
+        };
+    }, {
+        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<{
             owner: PublicKey;
+            lamports: BN;
+            address: number[] | null;
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
             leafIndex: number;
+            proveByIndex: boolean;
             seq: BN | null;
+            hash: BN;
             slotCreated: BN;
         }, {
             address: Struct<number[] | null, null>;
             hash: Struct<BN, null>;
             data: Struct<{
                 data: string;
-                dataHash: BN;
                 discriminator: BN;
+                dataHash: BN;
             } | null, {
                 data: Struct<string, null>;
                 dataHash: Struct<BN, null>;
@@ -1312,9 +2358,37 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: 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>;
@@ -1384,12 +2458,12 @@ declare const LatestNonVotingSignaturesResultPaginated: Struct<{
 /**
  * @internal
  */
-declare const MerkeProofResult: Struct<{
+declare const MerkleProofResult: Struct<{
+    proof: BN[];
+    leafIndex: number;
     root: BN;
     hash: BN;
-    leafIndex: number;
     merkleTree: PublicKey;
-    proof: BN[];
     rootSeq: number;
 }, {
     hash: Struct<BN, null>;
@@ -1402,11 +2476,69 @@ declare const MerkeProofResult: Struct<{
 /**
  * @internal
  */
-declare const NewAddressProofResult: Struct<{
-    root: BN;
+declare const MerkleProofResultV2: Struct<{
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    root: BN;
+    hash: 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
+ */
+declare const NewAddressProofResult: Struct<{
+    proof: BN[];
     address: BN;
+    root: BN;
     merkleTree: PublicKey;
-    proof: BN[];
     rootSeq: number;
     nextIndex: number;
     lowerRangeAddress: BN;
@@ -1423,6 +2555,16 @@ declare const NewAddressProofResult: Struct<{
     higherRangeAddress: Struct<BN, null>;
     lowElementLeafIndex: Struct<number, null>;
 }>;
+/**
+ * @internal
+ */
+declare const RootIndexResultV2: Struct<{
+    rootIndex: number;
+    proveByIndex: boolean;
+}, {
+    rootIndex: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+}>;
 /**
  * @internal
  */
@@ -1453,22 +2595,222 @@ declare const ValidityProofResult: Struct<{
     roots: Struct<BN[], Struct<BN, null>>;
     merkleTrees: Struct<PublicKey[], Struct<PublicKey, null>>;
 }>;
+declare const ValidityProofResultV2: Struct<{
+    compressedProof: {
+        a: number[];
+        b: number[];
+        c: number[];
+    } | null;
+    accounts: {
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        root: BN;
+        hash: BN;
+    }[];
+    addresses: {
+        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;
+        root: BN;
+    }[];
+}, {
+    compressedProof: Struct<{
+        a: number[];
+        b: number[];
+        c: number[];
+    } | null, {
+        a: Struct<number[], Struct<number, null>>;
+        b: Struct<number[], Struct<number, null>>;
+        c: Struct<number[], Struct<number, null>>;
+    }>;
+    accounts: Struct<{
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        root: BN;
+        hash: BN;
+    }[], Struct<{
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        root: BN;
+        hash: BN;
+    }, {
+        hash: Struct<BN, null>;
+        root: Struct<BN, null>;
+        rootIndex: Struct<{
+            rootIndex: number;
+            proveByIndex: boolean;
+        }, {
+            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<{
+        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;
+        root: BN;
+    }[], Struct<{
+        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;
+        root: BN;
+    }, {
+        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
  */
 declare const MultipleMerkleProofsResult: Struct<{
+    proof: BN[];
+    leafIndex: number;
     root: BN;
     hash: BN;
-    leafIndex: number;
     merkleTree: PublicKey;
-    proof: BN[];
     rootSeq: number;
 }[], Struct<{
+    proof: BN[];
+    leafIndex: number;
     root: BN;
     hash: BN;
-    leafIndex: number;
     merkleTree: PublicKey;
-    proof: BN[];
     rootSeq: number;
 }, {
     hash: Struct<BN, null>;
@@ -1478,6 +2820,83 @@ declare const MultipleMerkleProofsResult: Struct<{
     rootSeq: Struct<number, null>;
     root: Struct<BN, null>;
 }>>;
+/**
+ * @internal
+ */
+declare const MultipleMerkleProofsResultV2: Struct<{
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    root: BN;
+    hash: 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<{
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    root: BN;
+    hash: 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
  */
@@ -1552,9 +2971,9 @@ declare const CompressedMintTokenHoldersResult: Struct<{
     }>>;
 }>;
 declare const AccountProofResult: Struct<{
+    proof: number[][];
     root: number[];
     hash: number[];
-    proof: number[][];
 }, {
     hash: Struct<number[], Struct<number, null>>;
     root: Struct<number[], Struct<number, null>>;
@@ -1605,22 +3024,25 @@ declare const SignatureListWithCursorResult: Struct<{
     }>>;
     cursor: Struct<string | null, null>;
 }>;
+/**
+ * @internal
+ */
 declare const CompressedTransactionResult: Struct<{
     compressionInfo: {
         closedAccounts: {
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1633,18 +3055,18 @@ declare const CompressedTransactionResult: Struct<{
         }[];
         openedAccounts: {
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1661,18 +3083,18 @@ declare const CompressedTransactionResult: Struct<{
     compressionInfo: Struct<{
         closedAccounts: {
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1685,18 +3107,18 @@ declare const CompressedTransactionResult: Struct<{
         }[];
         openedAccounts: {
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1710,18 +3132,18 @@ declare const CompressedTransactionResult: Struct<{
     }, {
         closedAccounts: Struct<{
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1733,18 +3155,18 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }[], Struct<{
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1756,26 +3178,26 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }, {
             account: Struct<{
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             }, {
                 address: Struct<number[] | null, null>;
                 hash: Struct<BN, null>;
                 data: Struct<{
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null, {
                     data: Struct<string, null>;
                     dataHash: Struct<BN, null>;
@@ -1804,18 +3226,18 @@ declare const CompressedTransactionResult: Struct<{
         }>>;
         openedAccounts: Struct<{
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1827,18 +3249,18 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }[], Struct<{
             account: {
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
                 leafIndex: number;
                 seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1850,26 +3272,521 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }, {
             account: Struct<{
+                owner: PublicKey;
                 lamports: BN;
-                tree: PublicKey;
+                address: number[] | null;
                 data: {
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    discriminator: BN;
+                    dataHash: 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>;
+            }>;
+            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>;
+}>;
+/**
+ * @internal
+ */
+declare const CompressedTransactionResultV2: Struct<{
+    compressionInfo: {
+        closedAccounts: {
+            account: {
+                account: {
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                owner: PublicKey;
+                lamports: BN;
+                address: number[] | null;
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    };
+    transaction?: any;
+}, {
+    compressionInfo: Struct<{
+        closedAccounts: {
+            account: {
+                account: {
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                owner: PublicKey;
+                lamports: BN;
+                address: number[] | null;
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    }, {
+        closedAccounts: Struct<{
+            account: {
+                account: {
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                account: {
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                account: {
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            }, {
+                account: Struct<{
+                    owner: PublicKey;
+                    lamports: BN;
+                    address: number[] | null;
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                }, {
+                    address: Struct<number[] | null, null>;
+                    hash: Struct<BN, null>;
+                    data: Struct<{
+                        data: string;
+                        discriminator: BN;
+                        dataHash: 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: {
+                owner: PublicKey;
+                lamports: BN;
+                address: number[] | null;
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                owner: PublicKey;
+                lamports: BN;
                 address: number[] | null;
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
                 hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
                 owner: PublicKey;
+                lamports: BN;
+                address: number[] | null;
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
                 leafIndex: number;
+                proveByIndex: boolean;
                 seq: BN | null;
+                hash: BN;
                 slotCreated: BN;
             }, {
                 address: Struct<number[] | null, null>;
                 hash: Struct<BN, null>;
                 data: Struct<{
                     data: string;
-                    dataHash: BN;
                     discriminator: BN;
+                    dataHash: BN;
                 } | null, {
                     data: Struct<string, null>;
                     dataHash: Struct<BN, null>;
@@ -1878,9 +3795,37 @@ declare const CompressedTransactionResult: 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>;
             }>;
             optionalTokenData: Struct<{
                 owner: PublicKey;
@@ -1945,15 +3890,6 @@ type RpcResultError = {
 type RpcResult<T> = RpcResultSuccess<T> | RpcResultError;
 
 interface TestRpcConfig {
-    /**
-     * Address of the state tree to index. Default: public default test state
-     * tree.
-     */
-    merkleTreeAddress?: PublicKey;
-    /**
-     * Nullifier queue associated with merkleTreeAddress
-     */
-    nullifierQueueAddress?: PublicKey;
     /**
      * Depth of state tree. Defaults to the public default test state tree depth
      */
@@ -1962,15 +3898,6 @@ interface TestRpcConfig {
      * Log proof generation time
      */
     log?: boolean;
-    /**
-     * Address of the address tree to index. Default: public default test
-     * address tree.
-     */
-    addressTreeAddress?: PublicKey;
-    /**
-     * Address queue associated with addressTreeAddress
-     */
-    addressQueueAddress?: PublicKey;
 }
 type ClientSubscriptionId = number;
 interface LightWasm {
@@ -1996,13 +3923,13 @@ interface LightWasm {
  */
 declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, depth?: number, log?: boolean): Promise<TestRpc>;
 /**
- * Simple mock rpc for unit tests that simulates the compression rpc interface.
- * Fetches, parses events and builds merkletree on-demand, i.e. it does not persist state.
+ * Mock RPC for unit tests that simulates the ZK Compression RPC interface.
+ * Parses events and builds merkletree on-demand. It does not persist state.
  * Constraints:
- * - Can only index 1 merkletree
  * - Can only index up to 1000 transactions
  *
- * For advanced testing use photon: https://github.com/helius-labs/photon
+ * For advanced testing use `Rpc` class which uses photon:
+ * https://github.com/helius-labs/photon
  */
 declare class TestRpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
@@ -2010,9 +3937,9 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
     lightWasm: LightWasm;
     depth: number;
     log: boolean;
-    allStateTreeInfos: StateTreeInfo[] | null;
+    allStateTreeInfos: TreeInfo[] | null;
     lastStateTreeFetchTime: number | null;
-    fetchPromise: Promise<StateTreeInfo[]> | null;
+    fetchPromise: Promise<TreeInfo[]> | null;
     CACHE_TTL: number;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
@@ -2027,6 +3954,10 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * @param testRpcConfig             Config for the mock rpc
      */
     constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
+    /**
+     * @deprecated Use {@link getStateTreeInfos} instead
+     */
+    getCachedActiveStateTreeInfo(): Promise<void>;
     /**
      * @deprecated Use {@link getStateTreeInfos} instead
      */
@@ -2034,8 +3965,8 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
     /**
      * Returns local test state trees.
      */
-    getStateTreeInfos(): Promise<StateTreeInfo[]>;
-    doFetch(): Promise<StateTreeInfo[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -2123,7 +4054,7 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * Fetch a confirmed or finalized transaction from the cluster. Return with
      * CompressionInfo
      */
-    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction | null>;
+    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction>;
     /**
      * Returns confirmed signatures for transactions involving the specified
      * address forward in time from genesis to the most recent confirmed
@@ -2164,16 +4095,6 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      */
     getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
     getCompressedMintTokenHolders(_mint: PublicKey, _options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
-    /**
-     * Advanced usage of getValidityProof: fetches ZKP directly from a custom
-     * non-rpcprover. Note: This uses the proverEndpoint specified in the
-     * constructor. For normal usage, please use {@link getValidityProof}
-     * instead.
-     *
-     * Note: Use RPC class for forested trees. TestRpc is only for custom
-     * testing purposes.
-     */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @deprecated This method is not available for TestRpc. Please use
      * {@link getValidityProof} instead.
@@ -2402,7 +4323,7 @@ type EventWithParsedTokenTlvData = {
  * @param compressedAccount - The compressed account
  * @returns The parsed token data
  */
-declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccount, programId?: PublicKey): TokenData | null;
+declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccountLegacy, programId?: PublicKey): TokenData | null;
 /**
  * Retrieves all compressed token accounts for a given mint and owner.
  *
@@ -2478,7 +4399,7 @@ declare function wrapBigNumbersAsStrings(text: string): string;
 /** @internal */
 declare const rpcRequest: (rpcEndpoint: string, method: string, params?: any, convertToCamelCase?: boolean, debug?: boolean) => Promise<any>;
 /** @internal */
-declare const proverRequest: (proverEndpoint: string, method: "inclusion" | "new-address" | "combined", params?: any, log?: boolean, publicInputHash?: BN | undefined) => Promise<ValidityProof>;
+declare const proverRequest: (proverEndpoint: string, method: "inclusion" | "new-address" | "combined", params?: any, log?: boolean, _publicInputHash?: BN | undefined) => Promise<ValidityProof>;
 type NonInclusionMerkleProofInputs = {
     root: BN;
     value: BN;
@@ -2511,25 +4432,25 @@ type NonInclusionJsonStruct = {
 declare function convertMerkleProofsWithContextToHex(merkleProofsWithContext: MerkleContextWithMerkleProof[]): HexInputsForProver[];
 declare function convertNonInclusionMerkleProofInputsToHex(nonInclusionMerkleProofInputs: MerkleContextWithNewAddressProof[]): NonInclusionJsonStruct[];
 declare function getPublicInputHash(accountProofs: MerkleContextWithMerkleProof[], accountHashes: BN254[], newAddressProofs: MerkleContextWithNewAddressProof[], lightWasm: LightWasm): BN;
-/**
- * Get the tree for a given queue
- *
- * @param info - The active state tree addresses
- * @param queue - The queue to get the tree for
- * @returns The tree for the given queue, or undefined if not found
- */
-declare function getTreeForQueue(info: StateTreeInfo[], queue: PublicKey): PublicKey;
+interface NullifierMetadata {
+    nullifier: BN254;
+    txHash: BN254;
+}
 /**
  *
  */
 declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    allStateTreeInfos: StateTreeInfo[] | null;
+    allStateTreeInfos: TreeInfo[] | null;
     lastStateTreeFetchTime: number | null;
     CACHE_TTL: number;
-    fetchPromise: Promise<StateTreeInfo[]> | null;
+    fetchPromise: Promise<TreeInfo[]> | null;
     constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
+    /**
+     * @deprecated Use {@link getStateTreeInfos} instead
+     */
+    getCachedActiveStateTreeInfo(): Promise<void>;
     /**
      * @deprecated Use {@link getStateTreeInfos} instead
      */
@@ -2538,11 +4459,11 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * Get a list of all state tree infos. If not already cached, fetches from
      * the cluster.
      */
-    getStateTreeInfos(): Promise<StateTreeInfo[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
     /**
      * @internal
      */
-    doFetch(): Promise<StateTreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -2671,26 +4592,6 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns Array of validity proofs for new addresses
      */
     getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
-    /**
-     * Advanced usage of getValidityProof: fetches ZKP directly from a custom
-     * non-rpcprover. Note: This uses the proverEndpoint specified in the
-     * constructor. For normal usage, please use {@link getValidityProof}
-     * instead.
-     *
-     * Fetch the latest validity proof for (1) compressed accounts specified by
-     * an array of account hashes. (2) new unique addresses specified by an
-     * array of addresses.
-     *
-     * Validity proofs prove the presence of compressed accounts in state trees
-     * and the non-existence of addresses in address trees, respectively. They
-     * enable verification without recomputing the merkle proof path, thus
-     * lowering verification and data costs.
-     *
-     * @param hashes        Array of BN254 hashes.
-     * @param newAddresses  Array of BN254 new addresses.
-     * @returns             validity proof with context
-     */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @deprecated use {@link getValidityProofV0} instead.
      *
@@ -2755,7 +4656,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
  *
  * @return Transaction signature
  */
-declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create compressed account with address
@@ -2772,7 +4673,7 @@ declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddr
  *
  * @return Transaction signature
  */
-declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Create compressed account with address and lamports
  *
@@ -2790,7 +4691,7 @@ declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], pro
  *
  * @return Transaction signature
  */
-declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Decompress lamports into a solana account
@@ -2817,381 +4718,9 @@ declare function decompress(rpc: Rpc, payer: Signer, lamports: number | BN, reci
  *
  * @return Signature of the confirmed transaction
  */
-declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
-/**
- * @internal Finds the index of a PublicKey in an array, or adds it if not
- * present
- * */
-declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): number;
-/**
- * @internal
- * Pads output state trees with the 0th state tree of the input state.
- *
- * @param outputStateMerkleTrees                    Optional output state trees
- *                                                  to be inserted into the
- *                                                  output state. Defaults to
- *                                                  the 0th state tree of the
- *                                                  input state. Gets padded to
- *                                                  the length of
- *                                                  outputCompressedAccounts.
- * @param numberOfOutputCompressedAccounts          The number of output
- *                                                  compressed accounts.
- *
- * @returns Padded output state trees.
- */
-declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
-declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
-/**
- * Packs Compressed Accounts.
- *
- * Replaces PublicKey with index pointer to remaining accounts.
- *
- *
- * @param inputCompressedAccounts           Ix input state to be consumed
- * @param inputStateRootIndices             The recent state root indices of the
- *                                          input state. The expiry is tied to
- *                                          the proof.
- * @param outputCompressedAccounts          Ix output state to be created
- * @param outputStateTreeInfo               The output state tree info. Gets
- *                                          padded to the length of
- *                                          outputCompressedAccounts.
- *
- * @param remainingAccounts                 Optional existing array of accounts
- *                                          to append to.
- **/
-declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccount[], outputStateTreeInfo?: StateTreeInfo, remainingAccounts?: PublicKey[]): {
-    packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
-    packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
-    remainingAccounts: PublicKey[];
-};
-
-declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
-/**
- * Create compressed account system transaction params
- */
-type CreateAccountWithSeedParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * Address params for the new compressed account.
-     */
-    newAddressParams: NewAddressParams;
-    /**
-     * Address of the new compressed account
-     */
-    newAddress: number[];
-    /**
-     * Recent validity proof proving that there's no existing compressed account
-     * registered with newAccountAddress
-     */
-    recentValidityProof: ValidityProof;
-    /**
-     * State tree pubkey. Defaults to a public state tree if unspecified.
-     */
-    outputStateTreeInfo?: StateTreeInfo;
-    /**
-     * Public key of the program to assign as the owner of the created account.
-     */
-    programId?: PublicKey;
-    /**
-     * Optional input accounts to transfer lamports from into the new compressed
-     * account.
-     */
-    inputCompressedAccounts?: CompressedAccountWithMerkleContext[];
-    /**
-     * Optional input state root indices of 'inputCompressedAccounts'. The
-     * expiry is tied to the 'recentValidityProof'.
-     */
-    inputStateRootIndices?: number[];
-    /**
-     * Optional lamports to transfer into the new compressed account.
-     */
-    lamports?: number | BN;
-};
-/**
- * Defines the parameters for the transfer method
- */
-type TransferParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * The input state to be consumed.
-     */
-    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
-    /**
-     * Recipient address.
-     */
-    toAddress: PublicKey;
-    /**
-     * Amount of lamports to transfer.
-     */
-    lamports: number | BN;
-    /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
-     *
-     * TODO: Add support for passing recent-values after instruction creation.
-     */
-    recentInputStateRootIndices: number[];
-    /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
-     */
-    recentValidityProof: ValidityProof;
-};
-/**
- * Defines the parameters for the transfer method
- */
-type CompressParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * address that the lamports are attached to. also defaults to the recipient owner
-     */
-    toAddress: PublicKey;
-    /**
-     * amount of lamports to compress.
-     */
-    lamports: number | BN;
-    /**
-     * The state tree that the tx output should be inserted into. Defaults to a
-     * public state tree if unspecified.
-     */
-    outputStateTreeInfo: StateTreeInfo;
-};
-/**
- * Defines the parameters for the transfer method
- */
-type DecompressParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * The input state to be consumed.
-     */
-    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
-    /**
-     * Recipient address of uncompressed lamports
-     */
-    toAddress: PublicKey;
-    /**
-     * amount of lamports to decompress.
-     */
-    lamports: number | BN;
-    /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
-     *
-     * TODO: Add support for passing recent-values after instruction creation.
-     */
-    recentInputStateRootIndices: number[];
-    /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
-     */
-    recentValidityProof: ValidityProof;
-};
-declare class LightSystemProgram$1 {
-    /**
-     * @internal
-     */
-    constructor();
-    /**
-     * The LightSystemProgram program ID.
-     */
-    static programId: PublicKey;
-    /**
-     * @internal
-     * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
-     *
-     */
-    static deriveCompressedSolPda(): PublicKey;
-    static createTransferOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], toAddress: PublicKey, lamports: number | BN): CompressedAccount[];
-    static createDecompressOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], lamports: number | BN): CompressedAccount[];
-    /**
-     * No data by default
-     */
-    static createNewAddressOutputState(address: number[], owner: PublicKey, lamports?: BN | number, inputCompressedAccounts?: CompressedAccountWithMerkleContext[]): CompressedAccount[];
-    /**
-     * Creates instruction to create compressed account with PDA.
-     * Cannot write data.
-     *
-     * TODO: support transfer of lamports to the new account.
-     */
-    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTreeInfo, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
-    /**
-     * Creates a transaction instruction that transfers compressed lamports from
-     * one owner to another.
-     */
-    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: TransferParams): Promise<TransactionInstruction>;
-    /**
-     * Creates a transaction instruction that transfers compressed lamports from
-     * one owner to another.
-     */
-    static compress({ payer, toAddress, lamports, outputStateTreeInfo, }: CompressParams): Promise<TransactionInstruction>;
-    /**
-     * Creates a transaction instruction that transfers compressed lamports from
-     * one owner to another.
-     */
-    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: DecompressParams): Promise<TransactionInstruction>;
-}
-/**
- * Selects the minimal number of compressed SOL accounts for a transfer.
- *
- * 1. Sorts the accounts by amount in descending order
- * 2. Accumulates the amount until it is greater than or equal to the transfer
- *    amount
- */
-declare function selectMinCompressedSolAccountsForTransfer(accounts: CompressedAccountWithMerkleContext[], transferLamports: BN | number): [selectedAccounts: CompressedAccountWithMerkleContext[], total: BN];
-
-declare const CompressedAccountLayout: buffer_layout.Layout<unknown>;
-declare const MerkleContextLayout: buffer_layout.Layout<unknown>;
-declare const NewAddressParamsLayout: buffer_layout.Layout<unknown>;
-declare const InstructionDataInvokeLayout: Layout<InstructionDataInvoke>;
-declare function encodeInstructionDataInvoke(data: InstructionDataInvoke): Buffer$1;
-declare const InstructionDataInvokeCpiLayout: Layout<InstructionDataInvokeCpi>;
-declare function decodeInstructionDataInvoke(buffer: Buffer$1): InstructionDataInvoke;
-declare function decodeInstructionDataInvokeCpi(buffer: Buffer$1): InstructionDataInvokeCpi;
-type invokeAccountsLayoutParams = {
-    /**
-     * Fee payer.
-     */
-    feePayer: PublicKey;
-    /**
-     * Authority.
-     */
-    authority: PublicKey;
-    /**
-     * The registered program pda
-     */
-    registeredProgramPda: PublicKey;
-    /**
-     * Noop program.
-     */
-    noopProgram: PublicKey;
-    /**
-     * Account compression authority.
-     */
-    accountCompressionAuthority: PublicKey;
-    /**
-     * Account compression program.
-     */
-    accountCompressionProgram: PublicKey;
-    /**
-     * Solana pool pda. Some() if compression or decompression is done.
-     */
-    solPoolPda: PublicKey | null;
-    /**
-     * Decompression recipient.
-     */
-    decompressionRecipient: PublicKey | null;
-    /**
-     * Solana system program.
-     */
-    systemProgram: PublicKey;
-};
-declare const invokeAccountsLayout: (accounts: invokeAccountsLayoutParams) => AccountMeta[];
-declare const PublicTransactionEventLayout: Layout<PublicTransactionEvent>;
-declare function encodePublicTransactionEvent(data: PublicTransactionEvent): Buffer$1;
-declare function decodePublicTransactionEvent(buffer: Buffer$1): PublicTransactionEvent;
-declare const AppendNullifyCreateAddressInputsMetaLayout: buffer_layout.Layout<unknown>;
-declare const AppendLeavesInputLayout: buffer_layout.Layout<unknown>;
-declare const InsertNullifierInputLayout: buffer_layout.Layout<unknown>;
-declare const InsertAddressInputLayout: buffer_layout.Layout<unknown>;
-declare const MerkleTreeSequenceNumberLayout: buffer_layout.Layout<unknown>;
-declare function deserializeAppendNullifyCreateAddressInputsIndexer(buffer: Buffer$1): {
-    meta: unknown;
-    leaves: unknown[];
-    nullifiers: unknown[];
-    addresses: unknown[];
-    sequence_numbers: unknown[];
-    output_leaf_indices: number[];
-};
-declare function convertToPublicTransactionEvent(decoded: any, remainingAccounts: PublicKey[], invokeData: InstructionDataInvoke): PublicTransactionEvent;
-
-declare enum UtxoErrorCode {
-    NEGATIVE_LAMPORTS = "NEGATIVE_LAMPORTS",
-    NOT_U64 = "NOT_U64",
-    BLINDING_EXCEEDS_FIELD_SIZE = "BLINDING_EXCEEDS_FIELD_SIZE"
-}
-declare enum SelectInUtxosErrorCode {
-    FAILED_TO_FIND_UTXO_COMBINATION = "FAILED_TO_FIND_UTXO_COMBINATION",
-    INVALID_NUMBER_OF_IN_UTXOS = "INVALID_NUMBER_OF_IN_UTXOS"
-}
-declare enum CreateUtxoErrorCode {
-    OWNER_UNDEFINED = "OWNER_UNDEFINED",
-    INVALID_OUTPUT_UTXO_LENGTH = "INVALID_OUTPUT_UTXO_LENGTH",
-    UTXO_DATA_UNDEFINED = "UTXO_DATA_UNDEFINED"
-}
-declare enum RpcErrorCode {
-    CONNECTION_UNDEFINED = "CONNECTION_UNDEFINED",
-    RPC_PUBKEY_UNDEFINED = "RPC_PUBKEY_UNDEFINED",
-    RPC_METHOD_NOT_IMPLEMENTED = "RPC_METHOD_NOT_IMPLEMENTED",
-    RPC_INVALID = "RPC_INVALID"
-}
-declare enum LookupTableErrorCode {
-    LOOK_UP_TABLE_UNDEFINED = "LOOK_UP_TABLE_UNDEFINED",
-    LOOK_UP_TABLE_NOT_INITIALIZED = "LOOK_UP_TABLE_NOT_INITIALIZED"
-}
-declare enum HashErrorCode {
-    NO_POSEIDON_HASHER_PROVIDED = "NO_POSEIDON_HASHER_PROVIDED"
-}
-declare enum ProofErrorCode {
-    INVALID_PROOF = "INVALID_PROOF",
-    PROOF_INPUT_UNDEFINED = "PROOF_INPUT_UNDEFINED",
-    PROOF_GENERATION_FAILED = "PROOF_GENERATION_FAILED"
-}
-declare enum MerkleTreeErrorCode {
-    MERKLE_TREE_NOT_INITIALIZED = "MERKLE_TREE_NOT_INITIALIZED",
-    SOL_MERKLE_TREE_UNDEFINED = "SOL_MERKLE_TREE_UNDEFINED",
-    MERKLE_TREE_UNDEFINED = "MERKLE_TREE_UNDEFINED",
-    INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE = "INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE",
-    MERKLE_TREE_INDEX_UNDEFINED = "MERKLE_TREE_INDEX_UNDEFINED",
-    MERKLE_TREE_SET_SPACE_UNDEFINED = "MERKLE_TREE_SET_SPACE_UNDEFINED"
-}
-declare enum UtilsErrorCode {
-    ACCOUNT_NAME_UNDEFINED_IN_IDL = "ACCOUNT_NAME_UNDEFINED_IN_IDL",
-    PROPERTY_UNDEFINED = "PROPERTY_UNDEFINED",
-    LOOK_UP_TABLE_CREATION_FAILED = "LOOK_UP_TABLE_CREATION_FAILED",
-    UNSUPPORTED_ARCHITECTURE = "UNSUPPORTED_ARCHITECTURE",
-    UNSUPPORTED_PLATFORM = "UNSUPPORTED_PLATFORM",
-    ACCOUNTS_UNDEFINED = "ACCOUNTS_UNDEFINED",
-    INVALID_NUMBER = "INVALID_NUMBER"
-}
-declare class MetaError extends Error {
-    code: string;
-    functionName: string;
-    codeMessage?: string;
-    constructor(code: string, functionName: string, codeMessage?: string);
-}
-declare class UtxoError extends MetaError {
-}
-declare class SelectInUtxosError extends MetaError {
-}
-declare class CreateUtxoError extends MetaError {
-}
-declare class RpcError extends MetaError {
-}
-declare class LookupTableError extends MetaError {
-}
-declare class HashError extends MetaError {
-}
-declare class ProofError extends MetaError {
-}
-declare class MerkleTreeError extends MetaError {
-}
-declare class UtilsError extends MetaError {
-}
-
-type LightSystemProgram = {
+type LightSystemProgram$1 = {
     version: '1.2.0';
     name: 'light_system_program';
     constants: [
@@ -3891,7 +5420,7 @@ type LightSystemProgram = {
                         type: 'u8';
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex';
+                        name: 'queuePubkeyIndex';
                         type: 'u8';
                     },
                     {
@@ -3899,30 +5428,8 @@ type LightSystemProgram = {
                         type: 'u32';
                     },
                     {
-                        name: 'queueIndex';
-                        type: {
-                            option: {
-                                defined: 'QueueIndex';
-                            };
-                        };
-                    }
-                ];
-            };
-        },
-        {
-            name: 'QueueIndex';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
-                        name: 'queueId';
-                        docs: ['Id of queue in queue account.'];
-                        type: 'u8';
-                    },
-                    {
-                        name: 'index';
-                        docs: ['Index of compressed account hash in queue.'];
-                        type: 'u16';
+                        name: 'proveByIndex';
+                        type: 'bool';
                     }
                 ];
             };
@@ -4066,8 +5573,8 @@ type LightSystemProgram = {
         },
         {
             code: 6009;
-            name: 'DeCompressLamportsUndefinedForCompressSol';
-            msg: 'DeCompressLamportsUndefinedForCompressSol';
+            name: 'DecompressLamportsUndefinedForCompressSol';
+            msg: 'DecompressLamportsUndefinedForCompressSol';
         },
         {
             code: 6010;
@@ -4209,6 +5716,406 @@ type LightSystemProgram = {
         }
     ];
 };
-declare const IDL: LightSystemProgram;
+declare const IDL: LightSystemProgram$1;
+
+declare const CompressedAccountLayout: buffer_layout.Layout<unknown>;
+declare const MerkleContextLayout: buffer_layout.Layout<unknown>;
+declare const NewAddressParamsLayout: buffer_layout.Layout<unknown>;
+declare const InstructionDataInvokeLayout: Layout<InstructionDataInvoke>;
+declare function encodeInstructionDataInvoke(data: InstructionDataInvoke): Buffer$1;
+declare const InstructionDataInvokeCpiLayout: Layout<InstructionDataInvokeCpi>;
+declare const CompressedProofLayout: buffer_layout.Layout<unknown>;
+declare const CompressedCpiContextLayout: buffer_layout.Layout<unknown>;
+declare const NewAddressParamsAssignedPackedLayout: buffer_layout.Layout<unknown>;
+declare const PackedMerkleContextLayout: buffer_layout.Layout<unknown>;
+declare const InAccountLayout: buffer_layout.Layout<unknown>;
+declare const PackedReadOnlyAddressLayout: buffer_layout.Layout<unknown>;
+declare const PackedReadOnlyCompressedAccountLayout: buffer_layout.Layout<unknown>;
+declare const InstructionDataInvokeCpiWithReadOnlyLayout: buffer_layout.Layout<unknown>;
+declare function decodeInstructionDataInvokeCpiWithReadOnly(buffer: Buffer$1): unknown;
+declare function decodeInstructionDataInvoke(buffer: Buffer$1): InstructionDataInvoke;
+declare function decodeInstructionDataInvokeCpi(buffer: Buffer$1): InstructionDataInvokeCpi;
+type invokeAccountsLayoutParams = {
+    /**
+     * Fee payer.
+     */
+    feePayer: PublicKey;
+    /**
+     * Authority.
+     */
+    authority: PublicKey;
+    /**
+     * The registered program pda
+     */
+    registeredProgramPda: PublicKey;
+    /**
+     * Noop program.
+     */
+    noopProgram: PublicKey;
+    /**
+     * Account compression authority.
+     */
+    accountCompressionAuthority: PublicKey;
+    /**
+     * Account compression program.
+     */
+    accountCompressionProgram: PublicKey;
+    /**
+     * Solana pool pda. Some() if compression or decompression is done.
+     */
+    solPoolPda: PublicKey | null;
+    /**
+     * Decompression recipient.
+     */
+    decompressionRecipient: PublicKey | null;
+    /**
+     * Solana system program.
+     */
+    systemProgram: PublicKey;
+};
+declare const invokeAccountsLayout: (accounts: invokeAccountsLayoutParams) => AccountMeta[];
+declare const PublicTransactionEventLayout: Layout<PublicTransactionEvent>;
+declare function encodePublicTransactionEvent(data: PublicTransactionEvent): Buffer$1;
+declare function decodePublicTransactionEvent(buffer: Buffer$1): PublicTransactionEvent;
+declare const AppendNullifyCreateAddressInputsMetaLayout: buffer_layout.Layout<unknown>;
+declare const AppendLeavesInputLayout: buffer_layout.Layout<unknown>;
+declare const InsertNullifierInputLayout: buffer_layout.Layout<unknown>;
+declare const InsertAddressInputLayout: buffer_layout.Layout<unknown>;
+declare const MerkleTreeSequenceNumberLayout: buffer_layout.Layout<unknown>;
+declare function deserializeAppendNullifyCreateAddressInputsIndexer(buffer: Buffer$1): {
+    meta: unknown;
+    leaves: unknown[];
+    nullifiers: unknown[];
+    addresses: unknown[];
+    sequence_numbers: unknown[];
+    output_leaf_indices: number[];
+};
+declare function convertToPublicTransactionEvent(decoded: any, remainingAccounts: PublicKey[], invokeData: InstructionDataInvoke): PublicTransactionEvent;
+
+/**
+ * @internal Finds the index of a PublicKey in an array, or adds it if not
+ * present
+ * */
+declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): number;
+/**
+ * @internal
+ * Pads output state trees with the 0th state tree of the input state.
+ *
+ * @param outputStateMerkleTrees                    Optional output state trees
+ *                                                  to be inserted into the
+ *                                                  output state. Defaults to
+ *                                                  the 0th state tree of the
+ *                                                  input state. Gets padded to
+ *                                                  the length of
+ *                                                  outputCompressedAccounts.
+ * @param numberOfOutputCompressedAccounts          The number of output
+ *                                                  compressed accounts.
+ *
+ * @returns Padded output state trees.
+ */
+declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
+declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
+interface PackedStateTreeInfos {
+    packedTreeInfos: PackedStateTreeInfo[];
+    outputTreeIndex: number;
+}
+interface PackedTreeInfos {
+    stateTrees?: PackedStateTreeInfos;
+    addressTrees: PackedAddressTreeInfo[];
+}
+/**
+ * Packs TreeInfos. Replaces PublicKey with index pointer to remaining accounts.
+ *
+ * Only use for MUT, CLOSE, NEW_ADDRESSES. For INIT, pass
+ * {@link newAddressParamsPacked} and `outputStateTreeIndex` to your program
+ * instead.
+ *
+ *
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ * @param accountProofInputs                Account proof inputs.
+ * @param newAddressProofInputs             New address proof inputs.
+ *
+ * @returns Remaining accounts, packed state and address tree infos, state tree
+ * output index and address tree infos.
+ */
+declare function packTreeInfos(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
+/**
+ * Packs Compressed Accounts.
+ *
+ * Replaces PublicKey with index pointer to remaining accounts.
+ *
+ *
+ * @param inputCompressedAccounts           Ix input state to be consumed
+ * @param inputStateRootIndices             The recent state root indices of the
+ *                                          input state. The expiry is tied to
+ *                                          the proof.
+ * @param outputCompressedAccounts          Ix output state to be created
+ * @param outputStateTreeInfo               The output state tree info. Gets
+ *                                          padded to the length of
+ *                                          outputCompressedAccounts.
+ *
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ **/
+declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContextLegacy[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccountLegacy[], outputStateTreeInfo?: TreeInfo, remainingAccounts?: PublicKey[]): {
+    packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
+    packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    remainingAccounts: PublicKey[];
+};
+
+declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
+/**
+ * Create compressed account system transaction params
+ */
+type CreateAccountWithSeedParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * Address params for the new compressed account.
+     */
+    newAddressParams: NewAddressParams;
+    /**
+     * Address of the new compressed account
+     */
+    newAddress: number[];
+    /**
+     * Recent validity proof proving that there's no existing compressed account
+     * registered with newAccountAddress
+     */
+    recentValidityProof: ValidityProof | null;
+    /**
+     * State tree pubkey. Defaults to a public state tree if unspecified.
+     */
+    outputStateTreeInfo?: TreeInfo;
+    /**
+     * Public key of the program to assign as the owner of the created account.
+     */
+    programId?: PublicKey;
+    /**
+     * Optional input accounts to transfer lamports from into the new compressed
+     * account.
+     */
+    inputCompressedAccounts?: CompressedAccountWithMerkleContext[];
+    /**
+     * Optional input state root indices of 'inputCompressedAccounts'. The
+     * expiry is tied to the 'recentValidityProof'.
+     */
+    inputStateRootIndices?: number[];
+    /**
+     * Optional lamports to transfer into the new compressed account.
+     */
+    lamports?: number | BN;
+};
+/**
+ * Defines the parameters for the transfer method
+ */
+type TransferParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed.
+     */
+    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
+    /**
+     * Recipient address.
+     */
+    toAddress: PublicKey;
+    /**
+     * Amount of lamports to transfer.
+     */
+    lamports: number | BN;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. Expires
+     * after n slots.
+     */
+    recentValidityProof: ValidityProof | null;
+};
+/**
+ * Defines the parameters for the transfer method
+ */
+type CompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * address that the lamports are attached to. also defaults to the recipient owner
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of lamports to compress.
+     */
+    lamports: number | BN;
+    /**
+     * The state tree that the tx output should be inserted into.
+     */
+    outputStateTreeInfo: TreeInfo;
+};
+/**
+ * Defines the parameters for the transfer method
+ */
+type DecompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed.
+     */
+    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
+    /**
+     * Recipient address of uncompressed lamports
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of lamports to decompress.
+     */
+    lamports: number | BN;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: ValidityProof | null;
+};
+declare class LightSystemProgram {
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * The LightSystemProgram program ID.
+     */
+    static programId: PublicKey;
+    /**
+     * @internal
+     * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
+     *
+     */
+    static deriveCompressedSolPda(): PublicKey;
+    static createTransferOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], toAddress: PublicKey, lamports: number | BN): CompressedAccountLegacy[];
+    static createDecompressOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], lamports: number | BN): CompressedAccountLegacy[];
+    /**
+     * No data by default
+     */
+    static createNewAddressOutputState(address: number[], owner: PublicKey, lamports?: BN | number, inputCompressedAccounts?: CompressedAccountWithMerkleContext[]): CompressedAccountLegacy[];
+    /**
+     * Creates instruction to create compressed account with PDA.
+     * Cannot write data.
+     */
+    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTreeInfo, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: TransferParams): Promise<TransactionInstruction>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static compress({ payer, toAddress, lamports, outputStateTreeInfo, }: CompressParams): Promise<TransactionInstruction>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: DecompressParams): Promise<TransactionInstruction>;
+}
+
+/**
+ * Selects the minimal number of compressed SOL accounts for a transfer.
+ *
+ * 1. Sorts the accounts by amount in descending order
+ * 2. Accumulates the amount until it is greater than or equal to the transfer
+ *    amount
+ */
+declare function selectMinCompressedSolAccountsForTransfer(accounts: CompressedAccountWithMerkleContext[], transferLamports: BN | number): [selectedAccounts: CompressedAccountWithMerkleContext[], total: BN];
+
+declare enum UtxoErrorCode {
+    NEGATIVE_LAMPORTS = "NEGATIVE_LAMPORTS",
+    NOT_U64 = "NOT_U64",
+    BLINDING_EXCEEDS_FIELD_SIZE = "BLINDING_EXCEEDS_FIELD_SIZE"
+}
+declare enum SelectInUtxosErrorCode {
+    FAILED_TO_FIND_UTXO_COMBINATION = "FAILED_TO_FIND_UTXO_COMBINATION",
+    INVALID_NUMBER_OF_IN_UTXOS = "INVALID_NUMBER_OF_IN_UTXOS"
+}
+declare enum CreateUtxoErrorCode {
+    OWNER_UNDEFINED = "OWNER_UNDEFINED",
+    INVALID_OUTPUT_UTXO_LENGTH = "INVALID_OUTPUT_UTXO_LENGTH",
+    UTXO_DATA_UNDEFINED = "UTXO_DATA_UNDEFINED"
+}
+declare enum RpcErrorCode {
+    CONNECTION_UNDEFINED = "CONNECTION_UNDEFINED",
+    RPC_PUBKEY_UNDEFINED = "RPC_PUBKEY_UNDEFINED",
+    RPC_METHOD_NOT_IMPLEMENTED = "RPC_METHOD_NOT_IMPLEMENTED",
+    RPC_INVALID = "RPC_INVALID"
+}
+declare enum LookupTableErrorCode {
+    LOOK_UP_TABLE_UNDEFINED = "LOOK_UP_TABLE_UNDEFINED",
+    LOOK_UP_TABLE_NOT_INITIALIZED = "LOOK_UP_TABLE_NOT_INITIALIZED"
+}
+declare enum HashErrorCode {
+    NO_POSEIDON_HASHER_PROVIDED = "NO_POSEIDON_HASHER_PROVIDED"
+}
+declare enum ProofErrorCode {
+    INVALID_PROOF = "INVALID_PROOF",
+    PROOF_INPUT_UNDEFINED = "PROOF_INPUT_UNDEFINED",
+    PROOF_GENERATION_FAILED = "PROOF_GENERATION_FAILED"
+}
+declare enum MerkleTreeErrorCode {
+    MERKLE_TREE_NOT_INITIALIZED = "MERKLE_TREE_NOT_INITIALIZED",
+    SOL_MERKLE_TREE_UNDEFINED = "SOL_MERKLE_TREE_UNDEFINED",
+    MERKLE_TREE_UNDEFINED = "MERKLE_TREE_UNDEFINED",
+    INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE = "INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE",
+    MERKLE_TREE_INDEX_UNDEFINED = "MERKLE_TREE_INDEX_UNDEFINED",
+    MERKLE_TREE_SET_SPACE_UNDEFINED = "MERKLE_TREE_SET_SPACE_UNDEFINED"
+}
+declare enum UtilsErrorCode {
+    ACCOUNT_NAME_UNDEFINED_IN_IDL = "ACCOUNT_NAME_UNDEFINED_IN_IDL",
+    PROPERTY_UNDEFINED = "PROPERTY_UNDEFINED",
+    LOOK_UP_TABLE_CREATION_FAILED = "LOOK_UP_TABLE_CREATION_FAILED",
+    UNSUPPORTED_ARCHITECTURE = "UNSUPPORTED_ARCHITECTURE",
+    UNSUPPORTED_PLATFORM = "UNSUPPORTED_PLATFORM",
+    ACCOUNTS_UNDEFINED = "ACCOUNTS_UNDEFINED",
+    INVALID_NUMBER = "INVALID_NUMBER"
+}
+declare class MetaError extends Error {
+    code: string;
+    functionName: string;
+    codeMessage?: string;
+    constructor(code: string, functionName: string, codeMessage?: string);
+}
+declare class UtxoError extends MetaError {
+}
+declare class SelectInUtxosError extends MetaError {
+}
+declare class CreateUtxoError extends MetaError {
+}
+declare class RpcError extends MetaError {
+}
+declare class LookupTableError extends MetaError {
+}
+declare class HashError extends MetaError {
+}
+declare class ProofError extends MetaError {
+}
+declare class MerkleTreeError extends MetaError {
+}
+declare class UtilsError extends MetaError {
+}
 
-export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, AccountProofResult, type ActiveTreeBundle, type AddressTreeInfo, type AddressWithTree, type AddressWithTreeInfo, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, COMPRESSED_TOKEN_PROGRAM_ID, COMPUTE_BUDGET_PATTERN, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, CompressedAccountResult, type CompressedAccountWithMerkleContext, CompressedAccountsByOwnerResult, type CompressedCpiContext, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountsByOwnerOrDelegateResult, type CompressedTransaction, CompressedTransactionResult, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, type HashWithTreeInfo, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INSERT_INTO_QUEUES_DISCRIMINATOR, INVOKE_CPI_DISCRIMINATOR, INVOKE_DISCRIMINATOR, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, InsertAddressInputLayout, InsertNullifierInputLayout, type InstructionDataInvoke, type InstructionDataInvokeCpi, InstructionDataInvokeCpiLayout, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram$1 as LightSystemProgram, type LightSystemProgram as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, MerkeProofResult, type MerkleContext, MerkleContextLayout, type MerkleContextLegacy, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MerkleTreeSequenceNumberLayout, MultipleCompressedAccountsResult, MultipleMerkleProofsResult, NativeBalanceResult, type NewAddressParams, NewAddressParamsLayout, type NewAddressParamsPacked, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type OutputCompressedAccountWithPackedContext, type PackedCompressedAccountWithMerkleContext, type PackedMerkleContext, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, type QueueIndex, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, type StateTreeInfo, type StateTreeLUTPair, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, TreeType, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, type ValidityProof, ValidityProofResult, type ValidityProofWithContext, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, convertToPublicTransactionEvent, cpiContext2Pubkey, cpiContextPubkey, createAccount, createAccountWithLamports, createBN254, createCompressedAccount, createCompressedAccountWithMerkleContext, createMerkleContext, createRpc, createRpcResult, createStateTreeLookupTable, decodeInstructionDataInvoke, decodeInstructionDataInvokeCpi, decodePublicTransactionEvent, decompress, dedupeSigner, deepEqual, defaultStateTreeLookupTables, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, defaultTestStateTreeAccounts2, deriveAddress, deriveAddressSeed, deserializeAppendNullifyCreateAddressInputsIndexer, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, extendStateTreeLookupTable, getAccountCompressionAuthority, getAllStateTreeInfos, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getDefaultAddressTreeInfo, getIndexOrAdd, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getTestKeypair, getTestRpc, getTreeForQueue, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, invokeAccountsLayout, type invokeAccountsLayoutParams, isLocalTest, isSmallerThanBn254FieldSizeBe, jsonRpcResult, jsonRpcResultAndContext, lightProgram, localTestActiveStateTreeInfo, merkleTree2Pubkey, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifiedStateTreeLookupTableDevnet, nullifiedStateTreeLookupTableMainnet, nullifierQueue2Pubkey, nullifierQueuePubkey, nullifyLookupTable, packCompressedAccounts, packNewAddressParams, padOutputStateMerkleTrees, parseAccountData, parseEvents, parseLightTransaction, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pickRandomTreeAndQueue, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, selectStateTreeInfo, sendAndConfirmTx, sleep, stateTreeLookupTableDevnet, stateTreeLookupTableMainnet, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateNumbers, validateNumbersForInclusionProof, validateNumbersForNonInclusionProof, validateNumbersForProof, validateSameOwner, validateSufficientBalance, wrapBigNumbersAsStrings };
+export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, type AccountProofInput, AccountProofResult, type ActiveTreeBundle, type AddressTreeInfo, type AddressWithTree, type AddressWithTreeInfo, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, COMPRESSED_TOKEN_PROGRAM_ID, COMPUTE_BUDGET_PATTERN, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, type CompressedAccountLegacy, type CompressedAccountMeta, CompressedAccountResult, CompressedAccountResultV2, type CompressedAccountWithMerkleContext, type CompressedAccountWithMerkleContextLegacy, CompressedAccountsByOwnerResult, CompressedAccountsByOwnerResultV2, type CompressedCpiContext, CompressedCpiContextLayout, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, CompressedProofLayout, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountResultV2, CompressedTokenAccountsByOwnerOrDelegateResult, CompressedTokenAccountsByOwnerOrDelegateResultV2, type CompressedTransaction, CompressedTransactionResult, CompressedTransactionResultV2, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, type HashWithTreeInfo, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INSERT_INTO_QUEUES_DISCRIMINATOR, INVOKE_CPI_DISCRIMINATOR, INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR, INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR, INVOKE_DISCRIMINATOR, InAccountLayout, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, InsertAddressInputLayout, InsertNullifierInputLayout, type InstructionDataInvoke, type InstructionDataInvokeCpi, InstructionDataInvokeCpiLayout, InstructionDataInvokeCpiWithReadOnlyLayout, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram, type LightSystemProgram$1 as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, type MerkleContext, MerkleContextLayout, type MerkleContextLegacy, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleProofResult, MerkleProofResultV2, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MerkleTreeSequenceNumberLayout, MultipleCompressedAccountsResult, MultipleCompressedAccountsResultV2, MultipleMerkleProofsResult, MultipleMerkleProofsResultV2, NativeBalanceResult, type NewAddressParams, NewAddressParamsAssignedPackedLayout, NewAddressParamsLayout, type NewAddressParamsPacked, type NewAddressProofInput, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type NullifierMetadata, type OutputCompressedAccountWithPackedContext, type PackedAddressTreeInfo, type PackedCompressedAccountWithMerkleContext, PackedMerkleContextLayout, type PackedMerkleContextLegacy, PackedReadOnlyAddressLayout, PackedReadOnlyCompressedAccountLayout, type PackedStateTreeInfo, type PackedStateTreeInfos, type PackedTreeInfos, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, RootIndexResultV2, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, type StateTreeInfo, type StateTreeLUTPair, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, type TreeInfo, TreeType, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, VERSION, type ValidityProof, ValidityProofResult, ValidityProofResultV2, type ValidityProofWithContext, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, batchMerkleTree, batchQueue, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertInvokeCpiWithReadOnlyToInvoke, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, convertToPublicTransactionEvent, cpiContext2Pubkey, cpiContextPubkey, createAccount, createAccountWithLamports, createBN254, createCompressedAccountLegacy, createCompressedAccountMeta, createCompressedAccountWithMerkleContextLegacy, createMerkleContextLegacy, createRpc, createRpcResult, createStateTreeLookupTable, decodeInstructionDataInvoke, decodeInstructionDataInvokeCpi, decodeInstructionDataInvokeCpiWithReadOnly, decodePublicTransactionEvent, decompress, dedupeSigner, deepEqual, defaultStateTreeLookupTables, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, defaultTestStateTreeAccounts2, deriveAddress, deriveAddressSeed, deserializeAppendNullifyCreateAddressInputsIndexer, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, extendStateTreeLookupTable, featureFlags, getAccountCompressionAuthority, getAllStateTreeInfos, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getDefaultAddressTreeInfo, getIndexOrAdd, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getStateTreeInfoByPubkey, getTestKeypair, getTestRpc, getTreeInfoByPubkey, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, invokeAccountsLayout, type invokeAccountsLayoutParams, isLocalTest, isSmallerThanBn254FieldSizeBe, jsonRpcResult, jsonRpcResultAndContext, lightSystemProgram, localTestActiveStateTreeInfos, merkleTree2Pubkey, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifiedStateTreeLookupTableDevnet, nullifiedStateTreeLookupTableMainnet, nullifierQueue2Pubkey, nullifierQueuePubkey, nullifyLookupTable, packCompressedAccounts, packNewAddressParams, packTreeInfos, padOutputStateMerkleTrees, parseAccountData, parseEvents, parseLightTransaction, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pickRandomTreeAndQueue, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, selectStateTreeInfo, sendAndConfirmTx, sleep, stateTreeLookupTableDevnet, stateTreeLookupTableMainnet, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateNumbers, validateNumbersForInclusionProof, validateNumbersForNonInclusionProof, validateNumbersForProof, validateSameOwner, validateSufficientBalance, versionedEndpoint, wrapBigNumbersAsStrings };