@lightprotocol/stateless.js 0.20.8 → 0.21.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, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, Signer, DataSlice, MemcmpFilter, ConnectionConfig, ParsedTransactionWithMeta, AccountMeta } 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 { Buffer as Buffer$1 } from 'buffer';
 import { Struct } from 'superstruct';
 import BN from 'bn.js';
@@ -13,12 +13,13 @@ import { Layout } from '@coral-xyz/borsh';
  * are used to from working with the web3.js PublicKey type.
  */
 type BN254 = BN;
-declare const bn: (number: string | number | BN | Buffer$1 | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => BN;
 /** Create a bigint instance with <254-bit max size and base58 capabilities */
 declare const createBN254: (number: string | number | BN | Buffer$1 | Uint8Array | number[], base?: number | "hex" | "base58" | undefined) => BN254;
 /** Convert <254-bit bigint to Base58 string.  */
 declare function encodeBN254toBase58(bigintNumber: BN): string;
 
+declare const bn: (number: string | number | BN | Buffer$1 | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => BN;
+
 declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
 /**
  * Derive an address for a compressed account from a seed and an address Merkle
@@ -89,6 +90,14 @@ declare function airdropSol({ connection, lamports, recipientPublicKey, }: {
 }): Promise<string>;
 declare function confirmTransaction(connection: Connection, signature: string, confirmation?: Commitment): Promise<_solana_web3_js.RpcResponseAndContext<_solana_web3_js.SignatureResult>>;
 
+/**
+ * @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`)
+ */
+declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;
+
 declare function byteArrayToKeypair(byteArray: number[]): Keypair;
 /**
  * @internal
@@ -120,6 +129,162 @@ declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
 /** Mutates array in place */
 declare function pushUniqueItems<T>(items: T[], map: T[]): void;
 
+/** @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[][];
@@ -135,9 +300,9 @@ declare const placeholderValidityProof: () => {
     b: number[];
     c: number[];
 };
-declare const checkValidityProofShape: (proof: CompressedProof) => void;
+declare const checkValidityProofShape: (proof: ValidityProof) => void;
 declare function proofFromJsonStruct(json: GnarkProofJson): ProofABC;
-declare function negateAndCompressProof(proof: ProofABC): CompressedProof;
+declare function negateAndCompressProof(proof: ProofABC): ValidityProof;
 
 /** pipe function */
 declare function pipe<T, R>(initialFunction: (arg: T) => R, ...functions: ((arg: R) => R)[]): (initialValue: T) => R;
@@ -195,30 +360,15 @@ declare function buildAndSignTx(instructions: TransactionInstruction[], payer: S
 
 declare function sleep(ms: number): Promise<void>;
 
-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;
-
-/**
- * @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`)
- */
-declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;
-
 /**
  * Create two lookup tables storing all public state tree and queue addresses
  * returns lookup table addresses and txId
  *
  * @internal
- * @param connection - Connection to the Solana network
- * @param payer - Keypair of the payer
- * @param authority - Keypair of the authority
- * @param recentSlot - Slot of the recent block
+ * @param connection    Connection to the Solana network
+ * @param payer         Keypair of the payer
+ * @param authority     Keypair of the authority
+ * @param recentSlot    Slot of the recent block
  */
 declare function createStateTreeLookupTable({ connection, payer, authority, recentSlot, }: {
     connection: Connection;
@@ -231,14 +381,15 @@ declare function createStateTreeLookupTable({ connection, payer, authority, rece
 }>;
 /**
  * Extend state tree lookup table with new state tree and queue addresses
+ *
  * @internal
- * @param connection - Connection to the Solana network
- * @param tableAddress - Address of the lookup table to extend
- * @param newStateTreeAddresses - Addresses of the new state trees to add
- * @param newQueueAddresses - Addresses of the new queues to add
- * @param newCpiContextAddresses - Addresses of the new cpi contexts to add
- * @param payer - Keypair of the payer
- * @param authority - Keypair of the authority
+ * @param connection                Connection to the Solana network
+ * @param tableAddress              Address of the lookup table to extend
+ * @param newStateTreeAddresses     Addresses of the new state trees to add
+ * @param newQueueAddresses         Addresses of the new queues to add
+ * @param newCpiContextAddresses    Addresses of the new cpi contexts to add
+ * @param payer                     Keypair of the payer
+ * @param authority                 Keypair of the authority
  */
 declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, newCpiContextAddresses, payer, authority, }: {
     connection: Connection;
@@ -255,60 +406,112 @@ declare function extendStateTreeLookupTable({ connection, tableAddress, newState
 /**
  * Adds state tree address to lookup table. Acts as nullifier lookup for rolled
  * over state trees.
+ *
  * @internal
- * @param connection - Connection to the Solana network
- * @param stateTreeAddress - Address of the state tree to nullify
- * @param nullifyTableAddress - Address of the nullifier lookup table to store
- * address in
- * @param stateTreeLookupTableAddress - lookup table storing all state tree
- * addresses
- * @param payer - Keypair of the payer
- * @param authority - Keypair of the authority
- */
-declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
+ * @param connection                    Connection to the Solana network
+ * @param stateTreeAddress              Address of the state tree to nullify
+ * @param nullifyLookupTableAddress     Address of the nullifier lookup table to
+ *                                      store address in
+ * @param stateTreeLookupTableAddress   lookup table storing all state tree
+ *                                      addresses
+ * @param payer                         Keypair of the payer
+ * @param authority                     Keypair of the authority
+ */
+declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyLookupTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
     connection: Connection;
     fullStateTreeAddress: PublicKey;
-    nullifyTableAddress: PublicKey;
+    nullifyLookupTableAddress: PublicKey;
     stateTreeLookupTableAddress: PublicKey;
     payer: Keypair;
     authority: Keypair;
 }): Promise<{
     txId: string;
 }>;
-/**
- *  Get most recent , active state tree data
- * we store in lookup table for each public state tree
- */
-declare function getLightStateTreeInfo({ connection, stateTreeLookupTableAddress, nullifyTableAddress, }: {
-    connection: Connection;
-    stateTreeLookupTableAddress: PublicKey;
-    nullifyTableAddress: PublicKey;
-}): Promise<ActiveTreeBundle[]>;
+
+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
      */
-    State = 0,
+    StateV1 = 1,
     /**
      * v1 address merkle tree
      */
-    Address = 1,
+    AddressV1 = 2,
     /**
      * v2 state merkle tree
      */
-    BatchedState = 2,
+    StateV2 = 3,
     /**
      * v2 address merkle tree
      */
-    BatchedAddress = 3
+    AddressV2 = 4
 }
+/**
+ * @deprecated Use {@link StateTreeInfo} instead.
+ *
+ * A bundle of active trees for a given tree type.
+ */
 type ActiveTreeBundle = {
     tree: PublicKey;
     queue: PublicKey | null;
     cpiContext: PublicKey | null;
     treeType: TreeType;
 };
+/**
+ * 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
+ * });
+ * ```
+ */
+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;
+};
+/**
+ * Address tree info, versioned via {@link TreeType}. The protocol
+ * stores PDAs in address trees.
+ */
+type AddressTreeInfo = Omit<StateTreeInfo, 'cpiContext' | 'nextTreeInfo'> & {
+    nextTreeInfo: AddressTreeInfo | null;
+};
 interface PackedCompressedAccountWithMerkleContext {
     compressedAccount: CompressedAccount;
     merkleContext: PackedMerkleContext;
@@ -330,22 +533,27 @@ interface QueueIndex {
  * compressed account.
  * */
 interface CompressedAccount {
-    /** Public key of program or user that owns the account */
+    /**
+     * Public key of program or user owning the account.
+     */
     owner: PublicKey;
-    /** Lamports attached to the account */
+    /**
+     * Lamports attached to the account.
+     */
     lamports: BN;
     /**
-     * TODO: use PublicKey. Optional unique account ID that is persistent across
-     * transactions.
+     * Optional unique account ID that is persistent across transactions.
      */
     address: number[] | null;
-    /** Optional data attached to the account */
+    /**
+     * Optional data attached to the account.
+     */
     data: CompressedAccountData | null;
 }
 /**
  * Describe the generic compressed account details applicable to every
  * compressed account.
- * */
+ */
 interface OutputCompressedAccountWithPackedContext {
     compressedAccount: CompressedAccount;
     merkleTreeIndex: number;
@@ -372,7 +580,7 @@ interface PublicTransactionEvent {
     message: Uint8Array | null;
 }
 interface InstructionDataInvoke {
-    proof: CompressedProof | null;
+    proof: ValidityProof | null;
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     relayFee: BN | null;
@@ -381,7 +589,7 @@ interface InstructionDataInvoke {
     isCompress: boolean;
 }
 interface InstructionDataInvokeCpi {
-    proof: CompressedProof | null;
+    proof: ValidityProof | null;
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     relayFee: BN | null;
@@ -395,11 +603,28 @@ interface CompressedCpiContext {
     first_set_context: boolean;
     cpi_context_account_index: number;
 }
+/**
+ * @deprecated Use {@link ValidityProof} instead.
+ */
 interface CompressedProof {
     a: number[];
     b: number[];
     c: number[];
 }
+/**
+ * Validity proof.
+ *
+ * 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.
+ */
+interface ValidityProof {
+    a: number[];
+    b: number[];
+    c: number[];
+}
 interface InputTokenDataWithContext {
     amount: BN;
     delegateIndex: number | null;
@@ -421,29 +646,69 @@ type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
     readOnly: boolean;
 };
 /**
- * Context for compressed account inserted into a state Merkle tree
- * */
-type MerkleContext = {
-    /** State Merkle tree */
+ * @deprecated use {@link MerkleContext} instead.
+ *
+ * Legacy MerkleContext
+ */
+type MerkleContextLegacy = {
+    /**
+     * State tree
+     */
     merkleTree: PublicKey;
-    /** The state nullfier queue belonging to merkleTree */
+    /**
+     * Nullifier queue
+     */
     nullifierQueue: PublicKey;
-    /** Poseidon hash of the utxo preimage. Is a leaf in state merkle tree  */
+    /**
+     * Poseidon hash of the account. Stored as leaf in state tree
+     */
     hash: number[];
-    /** 'hash' position within the Merkle tree */
+    /**
+     * Position of `hash` in the State tree
+     */
     leafIndex: number;
 };
+/**
+ * Context for compressed account stored in a state tree
+ */
+type MerkleContext = {
+    /**
+     * Tree info
+     */
+    treeInfo: StateTreeInfo;
+    /**
+     * Poseidon hash of the account. Stored as leaf in state tree
+     */
+    hash: BN;
+    /**
+     * Position of `hash` in the State tree
+     */
+    leafIndex: number;
+    /**
+     * Whether the account can be proven by index or by merkle proof
+     */
+    proveByIndex: boolean;
+};
+/**
+ * MerkleContext with merkle proof
+ */
 type MerkleContextWithMerkleProof = MerkleContext & {
-    /** Recent valid 'hash' proof path, expires after n slots */
+    /**
+     * Recent valid 'hash' proof path, expires after n slots
+     */
     merkleProof: BN254[];
-    /** Index of state root the merkleproof is valid for, expires after n slots */
+    /**
+     * Index of state root the merkleproof is valid for, expires after n slots
+     */
     rootIndex: number;
-    /** Current root */
+    /**
+     * Current root
+     */
     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: (merkleTree: PublicKey, nullifierQueue: PublicKey, hash: number[], leafIndex: number) => MerkleContext;
+declare const createMerkleContext: (treeInfo: StateTreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => MerkleContext;
 
 interface LatestNonVotingSignatures {
     context: {
@@ -486,6 +751,19 @@ interface SignatureWithMetadata {
     signature: string;
     slot: number;
 }
+/**
+ * Account hash and associated state tree info.
+ */
+interface HashWithTreeInfo {
+    /**
+     * Account hash.
+     */
+    hash: BN254;
+    /**
+     * State tree info.
+     */
+    stateTreeInfo: StateTreeInfo;
+}
 interface HashWithTree {
     hash: BN254;
     tree: PublicKey;
@@ -496,6 +774,23 @@ interface AddressWithTree {
     tree: PublicKey;
     queue: PublicKey;
 }
+/**
+ * Address and associated address tree info.
+ */
+interface AddressWithTreeInfo {
+    /**
+     * Address.
+     */
+    address: BN254;
+    /**
+     * Address tree info.
+     */
+    addressTreeInfo: AddressTreeInfo;
+}
+interface AddressWithTreeInfo {
+    address: BN254;
+    treeInfo: AddressTreeInfo;
+}
 interface CompressedTransaction {
     compressionInfo: {
         closedAccounts: {
@@ -528,6 +823,41 @@ interface HexInputsForProver {
     pathElements: string[];
     leaf: string;
 }
+/**
+ * Validity proof with context.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ */
+type ValidityProofWithContext = {
+    /**
+     * Validity proof.
+     */
+    compressedProof: ValidityProof;
+    /**
+     * Roots.
+     */
+    roots: BN[];
+    /**
+     * Root indices.
+     */
+    rootIndices: number[];
+    /**
+     * Leaf indices.
+     */
+    leafIndices: number[];
+    /**
+     * Leaves.
+     */
+    leaves: BN[];
+    /**
+     * Tree infos.
+     */
+    treeInfos: StateTreeInfo[];
+};
+/**
+ * @deprecated use {@link ValidityProofWithContext} instead
+ */
 type CompressedProofWithContext = {
     compressedProof: CompressedProof;
     roots: BN[];
@@ -606,6 +936,8 @@ declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Struct<RpcR
  * @internal
  */
 declare const CompressedAccountResult: Struct<{
+    lamports: BN;
+    tree: PublicKey;
     data: {
         data: string;
         dataHash: BN;
@@ -613,10 +945,8 @@ declare const CompressedAccountResult: Struct<{
     } | null;
     address: number[] | null;
     hash: BN;
-    lamports: BN;
     owner: PublicKey;
     leafIndex: number;
-    tree: PublicKey;
     seq: BN | null;
     slotCreated: BN;
 }, {
@@ -663,6 +993,8 @@ declare const CompressedTokenAccountResult: Struct<{
         state: string;
     };
     account: {
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -670,10 +1002,8 @@ declare const CompressedTokenAccountResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     };
@@ -692,6 +1022,8 @@ declare const CompressedTokenAccountResult: Struct<{
         state: Struct<string, null>;
     }>;
     account: Struct<{
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -699,10 +1031,8 @@ declare const CompressedTokenAccountResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -730,6 +1060,8 @@ declare const CompressedTokenAccountResult: Struct<{
  */
 declare const MultipleCompressedAccountsResult: Struct<{
     items: {
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -737,15 +1069,15 @@ declare const MultipleCompressedAccountsResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[];
 }, {
     items: Struct<{
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -753,13 +1085,13 @@ declare const MultipleCompressedAccountsResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -767,10 +1099,8 @@ declare const MultipleCompressedAccountsResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -798,6 +1128,8 @@ declare const MultipleCompressedAccountsResult: Struct<{
  */
 declare const CompressedAccountsByOwnerResult: Struct<{
     items: {
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -805,16 +1137,16 @@ declare const CompressedAccountsByOwnerResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -822,13 +1154,13 @@ declare const CompressedAccountsByOwnerResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
+        lamports: BN;
+        tree: PublicKey;
         data: {
             data: string;
             dataHash: BN;
@@ -836,10 +1168,8 @@ declare const CompressedAccountsByOwnerResult: Struct<{
         } | null;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -876,6 +1206,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: string;
         };
         account: {
+            lamports: BN;
+            tree: PublicKey;
             data: {
                 data: string;
                 dataHash: BN;
@@ -883,10 +1215,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             } | null;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -902,6 +1232,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: string;
         };
         account: {
+            lamports: BN;
+            tree: PublicKey;
             data: {
                 data: string;
                 dataHash: BN;
@@ -909,10 +1241,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             } | null;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -925,6 +1255,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: string;
         };
         account: {
+            lamports: BN;
+            tree: PublicKey;
             data: {
                 data: string;
                 dataHash: BN;
@@ -932,10 +1264,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             } | null;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -954,6 +1284,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             state: Struct<string, null>;
         }>;
         account: Struct<{
+            lamports: BN;
+            tree: PublicKey;
             data: {
                 data: string;
                 dataHash: BN;
@@ -961,10 +1293,8 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
             } | null;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         }, {
@@ -1002,21 +1332,21 @@ declare const HealthResult: Struct<string, null>;
  */
 declare const LatestNonVotingSignaturesResult: Struct<{
     items: {
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }[];
 }, {
     items: Struct<{
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }[], Struct<{
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }, {
         signature: Struct<string, null>;
@@ -1030,19 +1360,19 @@ declare const LatestNonVotingSignaturesResult: Struct<{
  */
 declare const LatestNonVotingSignaturesResultPaginated: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         signature: Struct<string, null>;
@@ -1055,12 +1385,12 @@ declare const LatestNonVotingSignaturesResultPaginated: Struct<{
  * @internal
  */
 declare const MerkeProofResult: Struct<{
+    root: BN;
     hash: BN;
     leafIndex: number;
     merkleTree: PublicKey;
     proof: BN[];
     rootSeq: number;
-    root: BN;
 }, {
     hash: Struct<BN, null>;
     leafIndex: Struct<number, null>;
@@ -1073,11 +1403,11 @@ declare const MerkeProofResult: Struct<{
  * @internal
  */
 declare const NewAddressProofResult: Struct<{
+    root: BN;
     address: BN;
     merkleTree: PublicKey;
     proof: BN[];
     rootSeq: number;
-    root: BN;
     nextIndex: number;
     lowerRangeAddress: BN;
     higherRangeAddress: BN;
@@ -1127,19 +1457,19 @@ declare const ValidityProofResult: Struct<{
  * @internal
  */
 declare const MultipleMerkleProofsResult: Struct<{
+    root: BN;
     hash: BN;
     leafIndex: number;
     merkleTree: PublicKey;
     proof: BN[];
     rootSeq: number;
-    root: BN;
 }[], Struct<{
+    root: BN;
     hash: BN;
     leafIndex: number;
     merkleTree: PublicKey;
     proof: BN[];
     rootSeq: number;
-    root: BN;
 }, {
     hash: Struct<BN, null>;
     leafIndex: Struct<number, null>;
@@ -1222,9 +1552,9 @@ declare const CompressedMintTokenHoldersResult: Struct<{
     }>>;
 }>;
 declare const AccountProofResult: Struct<{
+    root: number[];
     hash: number[];
     proof: number[][];
-    root: number[];
 }, {
     hash: Struct<number[], Struct<number, null>>;
     root: Struct<number[], Struct<number, null>>;
@@ -1233,18 +1563,18 @@ declare const AccountProofResult: Struct<{
 declare const toUnixTimestamp: (blockTime: string) => number;
 declare const SignatureListResult: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -1254,19 +1584,19 @@ declare const SignatureListResult: Struct<{
 }>;
 declare const SignatureListWithCursorResult: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -1279,6 +1609,8 @@ declare const CompressedTransactionResult: Struct<{
     compressionInfo: {
         closedAccounts: {
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1286,10 +1618,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1303,6 +1633,8 @@ declare const CompressedTransactionResult: Struct<{
         }[];
         openedAccounts: {
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1310,10 +1642,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1331,6 +1661,8 @@ declare const CompressedTransactionResult: Struct<{
     compressionInfo: Struct<{
         closedAccounts: {
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1338,10 +1670,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1355,6 +1685,8 @@ declare const CompressedTransactionResult: Struct<{
         }[];
         openedAccounts: {
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1362,10 +1694,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1380,6 +1710,8 @@ declare const CompressedTransactionResult: Struct<{
     }, {
         closedAccounts: Struct<{
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1387,10 +1719,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1403,6 +1733,8 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }[], Struct<{
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1410,10 +1742,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1426,6 +1756,8 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }, {
             account: Struct<{
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1433,10 +1765,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1474,6 +1804,8 @@ declare const CompressedTransactionResult: Struct<{
         }>>;
         openedAccounts: Struct<{
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1481,10 +1813,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1497,6 +1827,8 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }[], Struct<{
             account: {
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1504,10 +1836,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1520,6 +1850,8 @@ declare const CompressedTransactionResult: Struct<{
             } | null;
         }, {
             account: Struct<{
+                lamports: BN;
+                tree: PublicKey;
                 data: {
                     data: string;
                     dataHash: BN;
@@ -1527,10 +1859,8 @@ declare const CompressedTransactionResult: Struct<{
                 } | null;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1576,9 +1906,9 @@ interface CompressionApiInterface {
     getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
     getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
-    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<CompressedProofWithContext>;
-    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     getCompressedTokenAccountsByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
@@ -1664,7 +1994,7 @@ interface LightWasm {
  * @param depth                   Depth of the merkle tree.
  * @param log                     Log proof generation time.
  */
-declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, depth?: number, log?: boolean): Promise<TestRpc>;
+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.
@@ -1677,14 +2007,13 @@ declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compression
 declare class TestRpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    merkleTreeAddress: PublicKey;
-    nullifierQueueAddress: PublicKey;
-    addressTreeAddress: PublicKey;
-    addressQueueAddress: PublicKey;
     lightWasm: LightWasm;
     depth: number;
     log: boolean;
-    activeStateTreeInfo: ActiveTreeBundle[] | null;
+    allStateTreeInfos: StateTreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    fetchPromise: Promise<StateTreeInfo[]> | null;
+    CACHE_TTL: number;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
      *
@@ -1699,17 +2028,14 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      */
     constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
     /**
-     * Manually set state tree addresses
-     */
-    setStateTreeInfo(info: ActiveTreeBundle[]): void;
-    /**
-     * Returns local test state trees.
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
      * Returns local test state trees.
      */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<StateTreeInfo[]>;
+    doFetch(): Promise<StateTreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -1847,12 +2173,12 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * Note: Use RPC class for forested trees. TestRpc is only for custom
      * testing purposes.
      */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @deprecated This method is not available for TestRpc. Please use
      * {@link getValidityProof} instead.
      */
-    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -1867,8 +2193,8 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
 }
 
 declare class IndexedElement {
@@ -2086,7 +2412,7 @@ declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccount, p
  * @param owner     PublicKey of the token owner
  * @param mint      PublicKey of the token mint
  */
-declare function getCompressedTokenAccounts(events: PublicTransactionEvent[]): Promise<ParsedTokenAccount[]>;
+declare function getCompressedTokenAccounts(events: PublicTransactionEvent[], rpc: Rpc): Promise<ParsedTokenAccount[]>;
 /** @internal */
 declare function getCompressedTokenAccountsByOwnerTest(rpc: Rpc, owner: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
 declare function getCompressedTokenAccountsByDelegateTest(rpc: Rpc, delegate: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
@@ -2152,7 +2478,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<CompressedProof>;
+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;
@@ -2171,8 +2497,7 @@ type MerkleContextWithNewAddressProof = {
     nextIndex: BN;
     merkleProofHashedIndexedElementLeaf: BN[];
     indexHashedIndexedElementLeaf: BN;
-    merkleTree: PublicKey;
-    nullifierQueue: PublicKey;
+    treeInfo: AddressTreeInfo;
 };
 type NonInclusionJsonStruct = {
     root: string;
@@ -2186,14 +2511,6 @@ 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 queue for a given tree
- *
- * @param info - The active state tree addresses
- * @param tree - The tree to get the queue for
- * @returns The queue for the given tree, or undefined if not found
- */
-declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKey): PublicKey;
 /**
  * Get the tree for a given queue
  *
@@ -2201,40 +2518,31 @@ declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKey): Pub
  * @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: ActiveTreeBundle[], queue: PublicKey): PublicKey;
-/**
- * Get a random tree and queue from the active state tree addresses.
- *
- * Prevents write lock contention on state trees.
- *
- * @param info - The active state tree addresses
- * @returns A random tree and queue
- */
-declare function pickRandomTreeAndQueue(info: ActiveTreeBundle[]): {
-    tree: PublicKey;
-    queue: PublicKey;
-};
+declare function getTreeForQueue(info: StateTreeInfo[], queue: PublicKey): PublicKey;
 /**
  *
  */
 declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    activeStateTreeInfo: ActiveTreeBundle[] | null;
+    allStateTreeInfos: StateTreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    CACHE_TTL: number;
+    fetchPromise: Promise<StateTreeInfo[]> | null;
     constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
-     * Manually set state tree addresses
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    setStateTreeInfo(info: ActiveTreeBundle[]): void;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
-     * Get the active state tree addresses from the cluster.
-     * If not already cached, fetches from the cluster.
+     * Get a list of all state tree infos. If not already cached, fetches from
+     * the cluster.
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<StateTreeInfo[]>;
     /**
-     * Fetch the latest state tree addresses from the cluster.
+     * @internal
      */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    doFetch(): Promise<StateTreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -2382,12 +2690,10 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @deprecated use {@link getValidityProofV0} 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.
@@ -2401,7 +2707,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -2416,7 +2722,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of { address: BN254, tree: PublicKey, queue: PublicKey }.
      * @returns             validity proof with context
      */
-    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -2433,96 +2739,85 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      *                      state tree/queue.
      * @returns             validity proof with context
      */
-    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
 }
 
 /**
  * Compress lamports to a solana address
  *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction and initialization fees
- * @param lamports        Amount of lamports to compress
- * @param toAddress       Address of the recipient compressed account
- * @param outputStateTree Optional output state tree. Defaults to a current shared state tree.
- * @param confirmOptions  Options for confirming the transaction
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param lamports              Amount of lamports to compress
+ * @param toAddress             Address of the recipient compressed account
+ * @param outputStateTreeInfo   Optional output state tree. If not provided,
+ *                              fetches a random active state tree.
+ * @param confirmOptions        Options for confirming the transaction
  *
  * @return Transaction signature
  */
-declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create compressed account with address
  *
- * @param rpc               RPC to use
- * @param payer             Payer of the transaction and initialization fees
- * @param seeds             Seeds to derive the new account address
- * @param programId         Owner of the new account
- * @param addressTree       Optional address tree. Defaults to a current shared
- *                          address tree.
- * @param addressQueue      Optional address queue. Defaults to a current shared
- *                          address queue.
- * @param outputStateTree   Optional output state tree. Defaults to a current
- *                          shared state tree.
- * @param confirmOptions    Options for confirming the transaction
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param seeds                 Seeds to derive the new account address
+ * @param programId             Owner of the new account
+ * @param addressTreeInfo       Optional address tree info. Defaults to a current
+ *                              shared address tree.
+ * @param outputStateTreeInfo   Optional output state tree. Defaults to fetching
+ *                              a current shared state tree.
+ * @param confirmOptions        Options for confirming the transaction
  *
- * @return                  Transaction signature
+ * @return Transaction signature
  */
-declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Create compressed account with address and lamports
  *
- * @param rpc               RPC to use
- * @param payer             Payer of the transaction and initialization fees
- * @param seeds             Seeds to derive the new account address
- * @param lamports          Number of compressed lamports to initialize the
- *                          account with
- * @param programId         Owner of the new account
- * @param addressTree       Optional address tree. Defaults to a current shared
- *                          address tree.
- * @param addressQueue      Optional address queue. Defaults to a current shared
- *                          address queue.
- * @param outputStateTree   Optional output state tree. Defaults to a current
- *                          shared state tree.
- * @param confirmOptions    Options for confirming the transaction
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param seeds                 Seeds to derive the new account address
+ * @param lamports              Number of compressed lamports to initialize the
+ *                              account with
+ * @param programId             Owner of the new account
+ * @param addressTreeInfo       Optional address tree info. Defaults to a
+ *                              current shared address tree.
+ * @param outputStateTreeInfo   Optional output state tree. Defaults to a
+ *                              current shared state tree.
+ * @param confirmOptions        Options for confirming the transaction
  *
- * @return                  Transaction signature
+ * @return Transaction signature
  */
-declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Decompress lamports into a solana account
  *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction and initialization fees
- * @param lamports        Amount of lamports to compress
- * @param toAddress       Address of the recipient compressed account
- * @param outputStateTree Optional output state tree. Defaults to a current shared state tree.
- * @param confirmOptions  Options for confirming the transaction
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param lamports              Amount of lamports to compress
+ * @param toAddress             Address of the recipient compressed account
+ * @param confirmOptions        Options for confirming the transaction
  *
  * @return Transaction signature
  */
-declare function decompress(rpc: Rpc, payer: Signer, lamports: number | BN, recipient: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
-/** @internal remove signer from signers if part of signers */
-declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];
+declare function decompress(rpc: Rpc, payer: Signer, lamports: number | BN, recipient: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer compressed lamports from one owner to another
  *
- * @param rpc            Rpc to use
- * @param payer          Payer of transaction fees
- * @param lamports       Number of lamports to transfer
- * @param owner          Owner of the compressed lamports
- * @param toAddress      Destination address of the recipient
- * @param merkleTree     State tree account that the compressed lamports should be
- *                       inserted into. Defaults to the default state tree account.
- * @param confirmOptions Options for confirming the transaction
- * @param config         Configuration for fetching compressed accounts
- *
+ * @param rpc                   Rpc to use
+ * @param payer                 Payer of transaction fees
+ * @param lamports              Number of lamports to transfer
+ * @param owner                 Owner of the compressed lamports
+ * @param toAddress             Destination address of the recipient
+ * @param confirmOptions        Options for confirming the transaction
  *
  * @return Signature of the confirmed transaction
  */
-declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * @internal Finds the index of a PublicKey in an array, or adds it if not
@@ -2542,20 +2837,10 @@ declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): numb
  *                                                  outputCompressedAccounts.
  * @param numberOfOutputCompressedAccounts          The number of output
  *                                                  compressed accounts.
- * @param inputCompressedAccountsWithMerkleContext  The input compressed
- *                                                  accounts with merkle
- *                                                  context.
- * @param activeTreeBundles                         Optional active tree bundles
- *                                                  to be used as fallback for
- *                                                  padding. Prioritizes ones
- *                                                  that are explicitly passed
- *                                                  via outputStateMerkleTrees
- *                                                  or
- *                                                  inputCompressedAccountsWithMerkleContext.
  *
  * @returns Padded output state trees.
  */
-declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey[] | PublicKey | undefined, numberOfOutputCompressedAccounts: number, inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[], activeTreeBundles?: ActiveTreeBundle[]): PublicKey[];
+declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
 declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
 /**
  * Packs Compressed Accounts.
@@ -2568,22 +2853,14 @@ declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
  *                                          input state. The expiry is tied to
  *                                          the proof.
  * @param outputCompressedAccounts          Ix output state to be created
- * @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 activeTreeBundles                 Optional active tree bundles to be
- *                                          used as fallback for padding.
- *                                          Prioritizes ones that are explicitly
- *                                          passed via outputStateMerkleTrees or
- *                                          inputCompressedAccountsWithMerkleContext.
+ * @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[], outputStateMerkleTrees?: PublicKey[] | PublicKey, remainingAccounts?: PublicKey[], activeTreeBundles?: ActiveTreeBundle[]): {
+declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccount[], outputStateTreeInfo?: StateTreeInfo, remainingAccounts?: PublicKey[]): {
     packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
     packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     remainingAccounts: PublicKey[];
@@ -2599,21 +2876,24 @@ type CreateAccountWithSeedParams = {
      */
     payer: PublicKey;
     /**
-     * Address params for the new compressed account
+     * 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: CompressedProof;
+    recentValidityProof: ValidityProof;
     /**
      * State tree pubkey. Defaults to a public state tree if unspecified.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo?: StateTreeInfo;
     /**
-     * Public key of the program to assign as the owner of the created account
+     * Public key of the program to assign as the owner of the created account.
      */
     programId?: PublicKey;
     /**
@@ -2644,11 +2924,11 @@ type TransferParams = {
      */
     inputCompressedAccounts: CompressedAccountWithMerkleContext[];
     /**
-     * Recipient address
+     * Recipient address.
      */
     toAddress: PublicKey;
     /**
-     * amount of lamports to transfer.
+     * Amount of lamports to transfer.
      */
     lamports: number | BN;
     /**
@@ -2662,13 +2942,7 @@ type TransferParams = {
      * The recent validity proof for state inclusion of the input state. It
      * expires after n slots.
      */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state trees that the tx output should be inserted into. This can be a
-     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
-     * of input state.
-     */
-    outputStateTrees?: PublicKey[] | PublicKey;
+    recentValidityProof: ValidityProof;
 };
 /**
  * Defines the parameters for the transfer method
@@ -2690,7 +2964,7 @@ type CompressParams = {
      * The state tree that the tx output should be inserted into. Defaults to a
      * public state tree if unspecified.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo: StateTreeInfo;
 };
 /**
  * Defines the parameters for the transfer method
@@ -2723,13 +2997,7 @@ type DecompressParams = {
      * The recent validity proof for state inclusion of the input state. It
      * expires after n slots.
      */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state trees that the tx output should be inserted into. This can be a
-     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
-     * of input state.
-     */
-    outputStateTree?: PublicKey;
+    recentValidityProof: ValidityProof;
 };
 declare class LightSystemProgram$1 {
     /**
@@ -2737,7 +3005,7 @@ declare class LightSystemProgram$1 {
      */
     constructor();
     /**
-     * Public key that identifies the CompressedPda program
+     * The LightSystemProgram program ID.
      */
     static programId: PublicKey;
     /**
@@ -2758,22 +3026,22 @@ declare class LightSystemProgram$1 {
      *
      * TODO: support transfer of lamports to the new account.
      */
-    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTree, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
+    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, outputStateTrees, }: TransferParams): Promise<TransactionInstruction>;
+    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, outputStateTree, }: CompressParams): Promise<TransactionInstruction>;
+    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, outputStateTree, }: DecompressParams): Promise<TransactionInstruction>;
+    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: DecompressParams): Promise<TransactionInstruction>;
 }
 /**
  * Selects the minimal number of compressed SOL accounts for a transfer.
@@ -2793,14 +3061,41 @@ 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[];
@@ -2822,110 +3117,6 @@ declare function deserializeAppendNullifyCreateAddressInputsIndexer(buffer: Buff
 };
 declare function convertToPublicTransactionEvent(decoded: any, remainingAccounts: PublicKey[], invokeData: InstructionDataInvoke): PublicTransactionEvent;
 
-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;
-    nullifyTable: 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: () => ActiveTreeBundle[];
-/**
- * Use only with Localnet testing.
- * For public networks, fetch via {@link defaultStateTreeLookupTables} and {@link getLightStateTreeInfo}.
- */
-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 stateTreeLookupTableMainnet = "7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st";
-declare const nullifiedStateTreeLookupTableMainnet = "H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT";
-declare const stateTreeLookupTableDevnet = "8n8rH2bFRVA6cSGNDpgqcKHCndbFCT1bXxAQG89ejVsh";
-declare const nullifiedStateTreeLookupTableDevnet = "5dhaJLBjnVBQFErr8oiCJmcVsx3Zj6xDekGB2zULPsnP";
-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;
-
 declare enum UtxoErrorCode {
     NEGATIVE_LAMPORTS = "NEGATIVE_LAMPORTS",
     NOT_U64 = "NOT_U64",
@@ -4020,4 +4211,4 @@ type LightSystemProgram = {
 };
 declare const IDL: LightSystemProgram;
 
-export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, AccountProofResult, type ActiveTreeBundle, type AddressWithTree, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, 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, 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 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 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, ValidityProofResult, 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, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getIndexOrAdd, getLightStateTreeInfo, getParsedEvents, getPublicInputHash, getQueueForTree, 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, 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, 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 };