@lightprotocol/stateless.js 0.20.3 → 0.20.4

package/dist/types/index.d.ts

@@ -1,23 +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, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, Signer, 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';
@@ -31,23 +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;
+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;
+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 function deriveAddressSeed(
-    seeds: Uint8Array[],
-    programId: PublicKey,
-): Uint8Array;
+declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
 /**
  * Derive an address for a compressed account from a seed and an address Merkle
  * tree public key.
@@ -57,10 +29,7 @@ declare function deriveAddressSeed(
  *                                 defaultTestStateTreeAccounts().addressTree
  * @returns                        Derived address
  */
-declare function deriveAddress(
-    seed: Uint8Array,
-    addressMerkleTreePubkey?: PublicKey,
-): PublicKey;
+declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
 interface NewAddressParams {
     /**
      * Seed for the compressed account. Must be seed used to derive
@@ -108,30 +77,17 @@ interface NewAddressParamsPacked {
  * @param remainingAccounts     Remaining accounts
  * @returns                     Packed new address params
  */
-declare function packNewAddressParams(
-    newAddressParams: NewAddressParams[],
-    remainingAccounts: PublicKey[],
-): {
+declare function packNewAddressParams(newAddressParams: NewAddressParams[], remainingAccounts: PublicKey[]): {
     newAddressParamsPacked: NewAddressParamsPacked[];
     remainingAccounts: PublicKey[];
 };
 
-declare function airdropSol({
-    connection,
-    lamports,
-    recipientPublicKey,
-}: {
+declare function airdropSol({ connection, lamports, recipientPublicKey, }: {
     connection: Connection;
     lamports: number;
     recipientPublicKey: PublicKey;
 }): Promise<string>;
-declare function confirmTransaction(
-    connection: Connection,
-    signature: string,
-    confirmation?: Commitment,
-): Promise<
-    _solana_web3_js.RpcResponseAndContext<_solana_web3_js.SignatureResult>
->;
+declare function confirmTransaction(connection: Connection, signature: string, confirmation?: Commitment): Promise<_solana_web3_js.RpcResponseAndContext<_solana_web3_js.SignatureResult>>;
 
 declare function byteArrayToKeypair(byteArray: number[]): Keypair;
 /**
@@ -141,6 +97,9 @@ declare function byteArrayToKeypair(byteArray: number[]): Keypair;
 declare function toHex(bn: BN): string;
 declare const toArray: <T>(value: T | T[]) => T[];
 declare const bufToDecStr: (buf: Buffer$1) => string;
+declare function isSmallerThanBn254FieldSizeBe(bytes: Buffer$1): boolean;
+declare const toCamelCase: (object: any) => any;
+/**
 /**
  * Hash the provided `bytes` with Keccak256 and ensure the result fits in the
  * BN254 prime field by repeatedly hashing the inputs with various "bump seeds"
@@ -148,9 +107,7 @@ declare const bufToDecStr: (buf: Buffer$1) => string;
  *
  * @deprecated Use `hashvToBn254FieldSizeBe` instead.
  */
-declare function hashToBn254FieldSizeBe(
-    bytes: Buffer$1,
-): [Buffer$1, number] | null;
+declare function hashToBn254FieldSizeBe(bytes: Buffer$1): [Buffer$1, number] | null;
 /**
  * Hash the provided `bytes` with Keccak256 and ensure that the result fits in
  * the BN254 prime field by truncating the resulting hash to 31 bytes.
@@ -162,9 +119,6 @@ declare function hashToBn254FieldSizeBe(
 declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
 /** Mutates array in place */
 declare function pushUniqueItems<T>(items: T[], map: T[]): void;
-declare function toCamelCase(
-    obj: Array<any> | unknown | any,
-): Array<any> | unknown | any;
 
 interface GnarkProofJson {
     ar: string[];
@@ -186,10 +140,7 @@ declare function proofFromJsonStruct(json: GnarkProofJson): ProofABC;
 declare function negateAndCompressProof(proof: ProofABC): CompressedProof;
 
 /** pipe function */
-declare function pipe<T, R>(
-    initialFunction: (arg: T) => R,
-    ...functions: ((arg: R) => R)[]
-): (initialValue: T) => R;
+declare function pipe<T, R>(initialFunction: (arg: T) => R, ...functions: ((arg: R) => R)[]): (initialValue: T) => R;
 
 /**
  * Builds a versioned Transaction from instructions.
@@ -201,12 +152,7 @@ declare function pipe<T, R>(
  *
  * @return VersionedTransaction
  */
-declare function buildTx(
-    instructions: TransactionInstruction[],
-    payerPublicKey: PublicKey,
-    blockhash: string,
-    lookupTableAccounts?: AddressLookupTableAccount[],
-): VersionedTransaction;
+declare function buildTx(instructions: TransactionInstruction[], payerPublicKey: PublicKey, blockhash: string, lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;
 /**
  * Sends a versioned transaction and confirms it.
  *
@@ -217,15 +163,10 @@ declare function buildTx(
  *
  * @return TransactionSignature
  */
-declare function sendAndConfirmTx(
-    rpc: Rpc,
-    tx: VersionedTransaction,
-    confirmOptions?: ConfirmOptions,
-    blockHashCtx?: {
-        blockhash: string;
-        lastValidBlockHeight: number;
-    },
-): Promise<TransactionSignature>;
+declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+    blockhash: string;
+    lastValidBlockHeight: number;
+}): Promise<TransactionSignature>;
 /**
  * Confirms a transaction with a given txId.
  *
@@ -235,15 +176,10 @@ declare function sendAndConfirmTx(
  * @param blockHashCtx      blockhash context for confirmation
  * @return SignatureResult
  */
-declare function confirmTx(
-    rpc: Rpc,
-    txId: string,
-    confirmOptions?: ConfirmOptions,
-    blockHashCtx?: {
-        blockhash: string;
-        lastValidBlockHeight: number;
-    },
-): Promise<RpcResponseAndContext<SignatureResult>>;
+declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+    blockhash: string;
+    lastValidBlockHeight: number;
+}): Promise<RpcResponseAndContext<SignatureResult>>;
 /**
  * Builds a versioned Transaction from instructions and signs it.
  *
@@ -255,22 +191,16 @@ declare function confirmTx(
  * @param lookupTableAccounts   lookup table accounts to include in the
  *                              transaction
  */
-declare function buildAndSignTx(
-    instructions: TransactionInstruction[],
-    payer: Signer,
-    blockhash: string,
-    additionalSigners?: Signer[],
-    lookupTableAccounts?: AddressLookupTableAccount[],
-): VersionedTransaction;
+declare function buildAndSignTx(instructions: TransactionInstruction[], payer: Signer, blockhash: string, additionalSigners?: Signer[], lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;
 
 declare function sleep(ms: number): Promise<void>;
 
 declare const validateSufficientBalance: (balance: BN) => void;
-declare const validateSameOwner: (
-    compressedAccounts:
-        | CompressedAccount[]
-        | CompressedAccountWithMerkleContext[],
-) => 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
@@ -278,10 +208,7 @@ declare const validateSameOwner: (
  * @returns microLamports per compute unit (use in
  * `ComputeBudgetProgram.setComputeUnitPrice`)
  */
-declare function calculateComputeUnitPrice(
-    targetLamports: number,
-    computeUnits: number,
-): number;
+declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;
 
 /**
  * Create two lookup tables storing all public state tree and queue addresses
@@ -293,12 +220,7 @@ declare function calculateComputeUnitPrice(
  * @param authority - Keypair of the authority
  * @param recentSlot - Slot of the recent block
  */
-declare function createStateTreeLookupTable({
-    connection,
-    payer,
-    authority,
-    recentSlot,
-}: {
+declare function createStateTreeLookupTable({ connection, payer, authority, recentSlot, }: {
     connection: Connection;
     payer: Keypair;
     authority: Keypair;
@@ -318,15 +240,7 @@ declare function createStateTreeLookupTable({
  * @param payer - Keypair of the payer
  * @param authority - Keypair of the authority
  */
-declare function extendStateTreeLookupTable({
-    connection,
-    tableAddress,
-    newStateTreeAddresses,
-    newQueueAddresses,
-    newCpiContextAddresses,
-    payer,
-    authority,
-}: {
+declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, newCpiContextAddresses, payer, authority, }: {
     connection: Connection;
     tableAddress: PublicKey;
     newStateTreeAddresses: PublicKey[];
@@ -351,14 +265,7 @@ declare function extendStateTreeLookupTable({
  * @param payer - Keypair of the payer
  * @param authority - Keypair of the authority
  */
-declare function nullifyLookupTable({
-    connection,
-    fullStateTreeAddress,
-    nullifyTableAddress,
-    stateTreeLookupTableAddress,
-    payer,
-    authority,
-}: {
+declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
     connection: Connection;
     fullStateTreeAddress: PublicKey;
     nullifyTableAddress: PublicKey;
@@ -372,11 +279,7 @@ declare function nullifyLookupTable({
  *  Get most recent , active state tree data
  * we store in lookup table for each public state tree
  */
-declare function getLightStateTreeInfo({
-    connection,
-    stateTreeLookupTableAddress,
-    nullifyTableAddress,
-}: {
+declare function getLightStateTreeInfo({ connection, stateTreeLookupTableAddress, nullifyTableAddress, }: {
     connection: Connection;
     stateTreeLookupTableAddress: PublicKey;
     nullifyTableAddress: PublicKey;
@@ -398,7 +301,7 @@ declare enum TreeType {
     /**
      * v2 address merkle tree
      */
-    BatchedAddress = 3,
+    BatchedAddress = 3
 }
 type ActiveTreeBundle = {
     tree: PublicKey;
@@ -514,10 +417,9 @@ type TokenData$1 = {
     tlv: Buffer$1 | null;
 };
 
-type CompressedAccountWithMerkleContext = CompressedAccount &
-    MerkleContext & {
-        readOnly: boolean;
-    };
+type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
+    readOnly: boolean;
+};
 /**
  * Context for compressed account inserted into a state Merkle tree
  * */
@@ -539,25 +441,9 @@ type MerkleContextWithMerkleProof = MerkleContext & {
     /** 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 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;
 
 interface LatestNonVotingSignatures {
     context: {
@@ -701,15 +587,11 @@ type WithCursor<T> = {
 /**
  * @internal
  */
-declare function createRpcResult<T, U>(
-    result: Struct<T, U>,
-): Struct<RpcResult<T>, null>;
+declare function createRpcResult<T, U>(result: Struct<T, U>): Struct<RpcResult<T>, null>;
 /**
  * @internal
  */
-declare function jsonRpcResult<T, U>(
-    schema: Struct<T, U>,
-): Struct<RpcResult<T>, null>;
+declare function jsonRpcResult<T, U>(schema: Struct<T, U>): Struct<RpcResult<T>, null>;
 type WithRpcContext<T> = {
     context: {
         slot: number;
@@ -719,14 +601,68 @@ type WithRpcContext<T> = {
 /**
  * @internal
  */
-declare function jsonRpcResultAndContext<T, U>(
-    value: Struct<T, U>,
-): Struct<RpcResult<WithRpcContext<T>>, null>;
+declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Struct<RpcResult<WithRpcContext<T>>, null>;
+/**
+ * @internal
+ */
+declare const CompressedAccountResult: Struct<{
+    lamports: BN;
+    data: {
+        data: string;
+        dataHash: BN;
+        discriminator: BN;
+    } | null;
+    address: number[] | null;
+    hash: BN;
+    owner: PublicKey;
+    leafIndex: number;
+    tree: PublicKey;
+    seq: BN | null;
+    slotCreated: BN;
+}, {
+    address: Struct<number[] | null, null>;
+    hash: Struct<BN, null>;
+    data: Struct<{
+        data: string;
+        dataHash: BN;
+        discriminator: BN;
+    } | null, {
+        data: Struct<string, null>;
+        dataHash: Struct<BN, null>;
+        discriminator: Struct<BN, null>;
+    }>;
+    lamports: Struct<BN, null>;
+    owner: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    tree: Struct<PublicKey, null>;
+    seq: Struct<BN | null, null>;
+    slotCreated: Struct<BN, null>;
+}>;
+declare const TokenDataResult: 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>;
+}>;
 /**
  * @internal
  */
-declare const CompressedAccountResult: Struct<
-    {
+declare const CompressedTokenAccountResult: Struct<{
+    tokenData: {
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    };
+    account: {
         lamports: BN;
         data: {
             data: string;
@@ -740,51 +676,198 @@ declare const CompressedAccountResult: Struct<
         tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
-    },
-    {
-        address: Struct<number[] | null, null>;
-        hash: Struct<BN, null>;
-        data: Struct<
-            {
-                data: string;
-                dataHash: BN;
-                discriminator: BN;
-            } | null,
-            {
-                data: Struct<string, null>;
-                dataHash: Struct<BN, null>;
-                discriminator: Struct<BN, null>;
-            }
-        >;
-        lamports: Struct<BN, null>;
-        owner: Struct<PublicKey, null>;
-        leafIndex: Struct<number, null>;
-        tree: Struct<PublicKey, null>;
-        seq: Struct<BN | null, null>;
-        slotCreated: Struct<BN, null>;
-    }
->;
-declare const TokenDataResult: Struct<
-    {
+    };
+}, {
+    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<{
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>;
+}>;
+/**
+ * @internal
+ */
+declare const MultipleCompressedAccountsResult: Struct<{
+    items: {
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }[];
+}, {
+    items: Struct<{
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }[], Struct<{
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+declare const CompressedAccountsByOwnerResult: Struct<{
+    items: {
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }[], Struct<{
+        lamports: BN;
+        data: {
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null;
+        address: number[] | null;
+        hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
+        tree: PublicKey;
+        seq: BN | null;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            dataHash: BN;
+            discriminator: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
 /**
  * @internal
  */
-declare const CompressedTokenAccountResult: Struct<
-    {
+declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+    items: {
         tokenData: {
             owner: PublicKey;
             mint: PublicKey;
@@ -807,71 +890,18 @@ declare const CompressedTokenAccountResult: Struct<
             seq: BN | null;
             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<
-            {
-                lamports: BN;
-                data: {
-                    data: string;
-                    dataHash: BN;
-                    discriminator: BN;
-                } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
-                leafIndex: number;
-                tree: PublicKey;
-                seq: BN | null;
-                slotCreated: BN;
-            },
-            {
-                address: Struct<number[] | null, null>;
-                hash: Struct<BN, null>;
-                data: Struct<
-                    {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null,
-                    {
-                        data: Struct<string, null>;
-                        dataHash: Struct<BN, null>;
-                        discriminator: Struct<BN, null>;
-                    }
-                >;
-                lamports: Struct<BN, null>;
-                owner: Struct<PublicKey, null>;
-                leafIndex: Struct<number, null>;
-                tree: Struct<PublicKey, null>;
-                seq: Struct<BN | null, null>;
-                slotCreated: Struct<BN, null>;
-            }
-        >;
-    }
->;
-/**
- * @internal
- */
-declare const MultipleCompressedAccountsResult: Struct<
-    {
-        items: {
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
             lamports: BN;
             data: {
                 data: string;
@@ -885,73 +915,16 @@ declare const MultipleCompressedAccountsResult: Struct<
             tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
-        }[];
-    },
-    {
-        items: Struct<
-            {
-                lamports: BN;
-                data: {
-                    data: string;
-                    dataHash: BN;
-                    discriminator: BN;
-                } | null;
-                address: number[] | null;
-                hash: BN;
-                owner: PublicKey;
-                leafIndex: number;
-                tree: PublicKey;
-                seq: BN | null;
-                slotCreated: BN;
-            }[],
-            Struct<
-                {
-                    lamports: BN;
-                    data: {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null;
-                    address: number[] | null;
-                    hash: BN;
-                    owner: PublicKey;
-                    leafIndex: number;
-                    tree: PublicKey;
-                    seq: BN | null;
-                    slotCreated: BN;
-                },
-                {
-                    address: Struct<number[] | null, null>;
-                    hash: Struct<BN, null>;
-                    data: Struct<
-                        {
-                            data: string;
-                            dataHash: BN;
-                            discriminator: BN;
-                        } | null,
-                        {
-                            data: Struct<string, null>;
-                            dataHash: Struct<BN, null>;
-                            discriminator: Struct<BN, null>;
-                        }
-                    >;
-                    lamports: Struct<BN, null>;
-                    owner: Struct<PublicKey, null>;
-                    leafIndex: Struct<number, null>;
-                    tree: Struct<PublicKey, null>;
-                    seq: Struct<BN | null, null>;
-                    slotCreated: Struct<BN, null>;
-                }
-            >
-        >;
-    }
->;
-/**
- * @internal
- */
-declare const CompressedAccountsByOwnerResult: Struct<
-    {
-        items: {
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
             lamports: BN;
             data: {
                 data: string;
@@ -965,12 +938,542 @@ declare const CompressedAccountsByOwnerResult: Struct<
             tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
-        }[];
-        cursor: string | null;
-    },
-    {
-        items: Struct<
-            {
+        };
+    }, {
+        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<{
+            lamports: BN;
+            data: {
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null;
+            address: number[] | null;
+            hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
+            tree: PublicKey;
+            seq: BN | null;
+            slotCreated: BN;
+        }, {
+            address: Struct<number[] | null, null>;
+            hash: Struct<BN, null>;
+            data: Struct<{
+                data: string;
+                dataHash: BN;
+                discriminator: BN;
+            } | null, {
+                data: Struct<string, null>;
+                dataHash: Struct<BN, null>;
+                discriminator: Struct<BN, null>;
+            }>;
+            lamports: Struct<BN, null>;
+            owner: Struct<PublicKey, null>;
+            leafIndex: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            seq: Struct<BN | null, null>;
+            slotCreated: Struct<BN, null>;
+        }>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+declare const SlotResult: Struct<number, null>;
+/**
+ * @internal
+ */
+declare const HealthResult: Struct<string, null>;
+/**
+ * @internal
+ */
+declare const LatestNonVotingSignaturesResult: Struct<{
+    items: {
+        signature: string;
+        error: string | null;
+        slot: number;
+        blockTime: number;
+    }[];
+}, {
+    items: Struct<{
+        signature: string;
+        error: string | null;
+        slot: number;
+        blockTime: number;
+    }[], Struct<{
+        signature: string;
+        error: string | null;
+        slot: number;
+        blockTime: number;
+    }, {
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+        blockTime: Struct<number, null>;
+        error: Struct<string | null, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+declare const LatestNonVotingSignaturesResultPaginated: Struct<{
+    items: {
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[], Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }, {
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+        blockTime: Struct<number, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+declare const MerkeProofResult: Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+}>;
+/**
+ * @internal
+ */
+declare const NewAddressProofResult: Struct<{
+    root: BN;
+    address: BN;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+    nextIndex: number;
+    lowerRangeAddress: BN;
+    higherRangeAddress: BN;
+    lowElementLeafIndex: number;
+}, {
+    address: Struct<BN, null>;
+    nextIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+    lowerRangeAddress: Struct<BN, null>;
+    higherRangeAddress: Struct<BN, null>;
+    lowElementLeafIndex: Struct<number, null>;
+}>;
+/**
+ * @internal
+ */
+declare const ValidityProofResult: Struct<{
+    compressedProof: {
+        a: number[];
+        b: number[];
+        c: number[];
+    };
+    leafIndices: number[];
+    leaves: BN[];
+    rootIndices: number[];
+    roots: BN[];
+    merkleTrees: PublicKey[];
+}, {
+    compressedProof: Struct<{
+        a: number[];
+        b: number[];
+        c: number[];
+    }, {
+        a: Struct<number[], Struct<number, null>>;
+        b: Struct<number[], Struct<number, null>>;
+        c: Struct<number[], Struct<number, null>>;
+    }>;
+    leafIndices: Struct<number[], Struct<number, null>>;
+    leaves: Struct<BN[], Struct<BN, null>>;
+    rootIndices: Struct<number[], Struct<number, null>>;
+    roots: Struct<BN[], Struct<BN, null>>;
+    merkleTrees: Struct<PublicKey[], Struct<PublicKey, null>>;
+}>;
+/**
+ * @internal
+ */
+declare const MultipleMerkleProofsResult: Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+}[], Struct<{
+    root: BN;
+    hash: BN;
+    leafIndex: number;
+    merkleTree: PublicKey;
+    proof: BN[];
+    rootSeq: number;
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+}>>;
+/**
+ * @internal
+ */
+declare const BalanceResult: Struct<{
+    amount: BN;
+}, {
+    amount: Struct<BN, null>;
+}>;
+declare const NativeBalanceResult: Struct<BN, null>;
+declare const TokenBalanceResult: Struct<{
+    mint: PublicKey;
+    balance: BN;
+}, {
+    balance: Struct<BN, null>;
+    mint: Struct<PublicKey, null>;
+}>;
+declare const TokenBalanceListResult: Struct<{
+    cursor: string | null;
+    tokenBalances: {
+        mint: PublicKey;
+        balance: BN;
+    }[];
+}, {
+    tokenBalances: Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        mint: Struct<PublicKey, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+declare const TokenBalanceListResultV2: Struct<{
+    items: {
+        mint: PublicKey;
+        balance: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        mint: Struct<PublicKey, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+declare const CompressedMintTokenHoldersResult: Struct<{
+    items: {
+        owner: PublicKey;
+        balance: BN;
+    }[];
+    cursor: string | null;
+}, {
+    cursor: Struct<string | null, null>;
+    items: Struct<{
+        owner: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        owner: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+    }>>;
+}>;
+declare const AccountProofResult: Struct<{
+    root: number[];
+    hash: number[];
+    proof: number[][];
+}, {
+    hash: Struct<number[], Struct<number, null>>;
+    root: Struct<number[], Struct<number, null>>;
+    proof: Struct<number[][], Struct<number[], Struct<number, null>>>;
+}>;
+declare const toUnixTimestamp: (blockTime: string) => number;
+declare const SignatureListResult: Struct<{
+    items: {
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[];
+}, {
+    items: Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[], Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }, {
+        blockTime: Struct<number, null>;
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+    }>>;
+}>;
+declare const SignatureListWithCursorResult: Struct<{
+    items: {
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }[], Struct<{
+        signature: string;
+        slot: number;
+        blockTime: number;
+    }, {
+        blockTime: Struct<number, null>;
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+declare const CompressedTransactionResult: Struct<{
+    compressionInfo: {
+        closedAccounts: {
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    };
+    transaction?: any;
+}, {
+    compressionInfo: Struct<{
+        closedAccounts: {
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    }, {
+        closedAccounts: Struct<{
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+            }>;
+            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: {
                 lamports: BN;
                 data: {
                     data: string;
@@ -984,63 +1487,15 @@ declare const CompressedAccountsByOwnerResult: Struct<
                 tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
-            }[],
-            Struct<
-                {
-                    lamports: BN;
-                    data: {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null;
-                    address: number[] | null;
-                    hash: BN;
-                    owner: PublicKey;
-                    leafIndex: number;
-                    tree: PublicKey;
-                    seq: BN | null;
-                    slotCreated: BN;
-                },
-                {
-                    address: Struct<number[] | null, null>;
-                    hash: Struct<BN, null>;
-                    data: Struct<
-                        {
-                            data: string;
-                            dataHash: BN;
-                            discriminator: BN;
-                        } | null,
-                        {
-                            data: Struct<string, null>;
-                            dataHash: Struct<BN, null>;
-                            discriminator: Struct<BN, null>;
-                        }
-                    >;
-                    lamports: Struct<BN, null>;
-                    owner: Struct<PublicKey, null>;
-                    leafIndex: Struct<number, null>;
-                    tree: Struct<PublicKey, null>;
-                    seq: Struct<BN | null, null>;
-                    slotCreated: Struct<BN, null>;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-/**
- * @internal
- */
-declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<
-    {
-        items: {
-            tokenData: {
+            };
+            optionalTokenData: {
                 owner: PublicKey;
                 mint: PublicKey;
                 amount: BN;
                 delegate: PublicKey | null;
                 state: string;
-            };
+            } | null;
+        }[], Struct<{
             account: {
                 lamports: BN;
                 data: {
@@ -1056,909 +1511,90 @@ declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<
                 seq: BN | null;
                 slotCreated: BN;
             };
-        }[];
-        cursor: string | null;
-    },
-    {
-        items: Struct<
-            {
-                tokenData: {
-                    owner: PublicKey;
-                    mint: PublicKey;
-                    amount: BN;
-                    delegate: PublicKey | null;
-                    state: string;
-                };
-                account: {
-                    lamports: BN;
-                    data: {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null;
-                    address: number[] | null;
-                    hash: BN;
-                    owner: PublicKey;
-                    leafIndex: number;
-                    tree: PublicKey;
-                    seq: BN | null;
-                    slotCreated: BN;
-                };
-            }[],
-            Struct<
-                {
-                    tokenData: {
-                        owner: PublicKey;
-                        mint: PublicKey;
-                        amount: BN;
-                        delegate: PublicKey | null;
-                        state: string;
-                    };
-                    account: {
-                        lamports: BN;
-                        data: {
-                            data: string;
-                            dataHash: BN;
-                            discriminator: BN;
-                        } | null;
-                        address: number[] | null;
-                        hash: BN;
-                        owner: PublicKey;
-                        leafIndex: number;
-                        tree: PublicKey;
-                        seq: BN | null;
-                        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<
-                        {
-                            lamports: BN;
-                            data: {
-                                data: string;
-                                dataHash: BN;
-                                discriminator: BN;
-                            } | null;
-                            address: number[] | null;
-                            hash: BN;
-                            owner: PublicKey;
-                            leafIndex: number;
-                            tree: PublicKey;
-                            seq: BN | null;
-                            slotCreated: BN;
-                        },
-                        {
-                            address: Struct<number[] | null, null>;
-                            hash: Struct<BN, null>;
-                            data: Struct<
-                                {
-                                    data: string;
-                                    dataHash: BN;
-                                    discriminator: BN;
-                                } | null,
-                                {
-                                    data: Struct<string, null>;
-                                    dataHash: Struct<BN, null>;
-                                    discriminator: Struct<BN, null>;
-                                }
-                            >;
-                            lamports: Struct<BN, null>;
-                            owner: Struct<PublicKey, null>;
-                            leafIndex: Struct<number, null>;
-                            tree: Struct<PublicKey, null>;
-                            seq: Struct<BN | null, null>;
-                            slotCreated: Struct<BN, null>;
-                        }
-                    >;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-/**
- * @internal
- */
-declare const SlotResult: Struct<number, null>;
-/**
- * @internal
- */
-declare const HealthResult: Struct<string, null>;
-/**
- * @internal
- */
-declare const LatestNonVotingSignaturesResult: Struct<
-    {
-        items: {
-            signature: string;
-            error: string | null;
-            slot: number;
-            blockTime: number;
-        }[];
-    },
-    {
-        items: Struct<
-            {
-                signature: string;
-                error: string | null;
-                slot: number;
-                blockTime: number;
-            }[],
-            Struct<
-                {
-                    signature: string;
-                    error: string | null;
-                    slot: number;
-                    blockTime: number;
-                },
-                {
-                    signature: Struct<string, null>;
-                    slot: Struct<number, null>;
-                    blockTime: Struct<number, null>;
-                    error: Struct<string | null, null>;
-                }
-            >
-        >;
-    }
->;
-/**
- * @internal
- */
-declare const LatestNonVotingSignaturesResultPaginated: Struct<
-    {
-        items: {
-            signature: string;
-            slot: number;
-            blockTime: number;
-        }[];
-        cursor: string | null;
-    },
-    {
-        items: Struct<
-            {
-                signature: string;
-                slot: number;
-                blockTime: number;
-            }[],
-            Struct<
-                {
-                    signature: string;
-                    slot: number;
-                    blockTime: number;
-                },
-                {
-                    signature: Struct<string, null>;
-                    slot: Struct<number, null>;
-                    blockTime: Struct<number, null>;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-/**
- * @internal
- */
-declare const MerkeProofResult: Struct<
-    {
-        root: BN;
-        hash: BN;
-        leafIndex: number;
-        merkleTree: PublicKey;
-        proof: BN[];
-        rootSeq: number;
-    },
-    {
-        hash: Struct<BN, null>;
-        leafIndex: Struct<number, null>;
-        merkleTree: Struct<PublicKey, null>;
-        proof: Struct<BN[], Struct<BN, null>>;
-        rootSeq: Struct<number, null>;
-        root: Struct<BN, null>;
-    }
->;
-/**
- * @internal
- */
-declare const NewAddressProofResult: Struct<
-    {
-        root: BN;
-        address: BN;
-        merkleTree: PublicKey;
-        proof: BN[];
-        rootSeq: number;
-        nextIndex: number;
-        lowerRangeAddress: BN;
-        higherRangeAddress: BN;
-        lowElementLeafIndex: number;
-    },
-    {
-        address: Struct<BN, null>;
-        nextIndex: Struct<number, null>;
-        merkleTree: Struct<PublicKey, null>;
-        proof: Struct<BN[], Struct<BN, null>>;
-        rootSeq: Struct<number, null>;
-        root: Struct<BN, null>;
-        lowerRangeAddress: Struct<BN, null>;
-        higherRangeAddress: Struct<BN, null>;
-        lowElementLeafIndex: Struct<number, null>;
-    }
->;
-/**
- * @internal
- */
-declare const ValidityProofResult: Struct<
-    {
-        compressedProof: {
-            a: number[];
-            b: number[];
-            c: number[];
-        };
-        leafIndices: number[];
-        leaves: BN[];
-        rootIndices: number[];
-        roots: BN[];
-        merkleTrees: PublicKey[];
-    },
-    {
-        compressedProof: Struct<
-            {
-                a: number[];
-                b: number[];
-                c: number[];
-            },
-            {
-                a: Struct<number[], Struct<number, null>>;
-                b: Struct<number[], Struct<number, null>>;
-                c: Struct<number[], Struct<number, null>>;
-            }
-        >;
-        leafIndices: Struct<number[], Struct<number, null>>;
-        leaves: Struct<BN[], Struct<BN, null>>;
-        rootIndices: Struct<number[], Struct<number, null>>;
-        roots: Struct<BN[], Struct<BN, null>>;
-        merkleTrees: Struct<PublicKey[], Struct<PublicKey, null>>;
-    }
->;
-/**
- * @internal
- */
-declare const MultipleMerkleProofsResult: Struct<
-    {
-        root: BN;
-        hash: BN;
-        leafIndex: number;
-        merkleTree: PublicKey;
-        proof: BN[];
-        rootSeq: number;
-    }[],
-    Struct<
-        {
-            root: BN;
-            hash: BN;
-            leafIndex: number;
-            merkleTree: PublicKey;
-            proof: BN[];
-            rootSeq: number;
-        },
-        {
-            hash: Struct<BN, null>;
-            leafIndex: Struct<number, null>;
-            merkleTree: Struct<PublicKey, null>;
-            proof: Struct<BN[], Struct<BN, null>>;
-            rootSeq: Struct<number, null>;
-            root: Struct<BN, null>;
-        }
-    >
->;
-/**
- * @internal
- */
-declare const BalanceResult: Struct<
-    {
-        amount: BN;
-    },
-    {
-        amount: Struct<BN, null>;
-    }
->;
-declare const NativeBalanceResult: Struct<BN, null>;
-declare const TokenBalanceResult: Struct<
-    {
-        mint: PublicKey;
-        balance: BN;
-    },
-    {
-        balance: Struct<BN, null>;
-        mint: Struct<PublicKey, null>;
-    }
->;
-declare const TokenBalanceListResult: Struct<
-    {
-        cursor: string | null;
-        tokenBalances: {
-            mint: PublicKey;
-            balance: BN;
-        }[];
-    },
-    {
-        tokenBalances: Struct<
-            {
-                mint: PublicKey;
-                balance: BN;
-            }[],
-            Struct<
-                {
-                    mint: PublicKey;
-                    balance: BN;
-                },
-                {
-                    balance: Struct<BN, null>;
-                    mint: Struct<PublicKey, null>;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-declare const TokenBalanceListResultV2: Struct<
-    {
-        items: {
-            mint: PublicKey;
-            balance: BN;
-        }[];
-        cursor: string | null;
-    },
-    {
-        items: Struct<
-            {
-                mint: PublicKey;
-                balance: BN;
-            }[],
-            Struct<
-                {
-                    mint: PublicKey;
-                    balance: BN;
-                },
-                {
-                    balance: Struct<BN, null>;
-                    mint: Struct<PublicKey, null>;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-declare const CompressedMintTokenHoldersResult: Struct<
-    {
-        items: {
-            owner: PublicKey;
-            balance: BN;
-        }[];
-        cursor: string | null;
-    },
-    {
-        cursor: Struct<string | null, null>;
-        items: Struct<
-            {
+            optionalTokenData: {
                 owner: PublicKey;
-                balance: BN;
-            }[],
-            Struct<
-                {
-                    owner: PublicKey;
-                    balance: BN;
-                },
-                {
-                    balance: Struct<BN, null>;
-                    owner: Struct<PublicKey, null>;
-                }
-            >
-        >;
-    }
->;
-declare const AccountProofResult: Struct<
-    {
-        root: number[];
-        hash: number[];
-        proof: number[][];
-    },
-    {
-        hash: Struct<number[], Struct<number, null>>;
-        root: Struct<number[], Struct<number, null>>;
-        proof: Struct<number[][], Struct<number[], Struct<number, null>>>;
-    }
->;
-declare const toUnixTimestamp: (blockTime: string) => number;
-declare const SignatureListResult: Struct<
-    {
-        items: {
-            signature: string;
-            slot: number;
-            blockTime: number;
-        }[];
-    },
-    {
-        items: Struct<
-            {
-                signature: string;
-                slot: number;
-                blockTime: number;
-            }[],
-            Struct<
-                {
-                    signature: string;
-                    slot: number;
-                    blockTime: number;
-                },
-                {
-                    blockTime: Struct<number, null>;
-                    signature: Struct<string, null>;
-                    slot: Struct<number, null>;
-                }
-            >
-        >;
-    }
->;
-declare const SignatureListWithCursorResult: Struct<
-    {
-        items: {
-            signature: string;
-            slot: number;
-            blockTime: number;
-        }[];
-        cursor: string | null;
-    },
-    {
-        items: Struct<
-            {
-                signature: string;
-                slot: number;
-                blockTime: number;
-            }[],
-            Struct<
-                {
-                    signature: string;
-                    slot: number;
-                    blockTime: number;
-                },
-                {
-                    blockTime: Struct<number, null>;
-                    signature: Struct<string, null>;
-                    slot: Struct<number, null>;
-                }
-            >
-        >;
-        cursor: Struct<string | null, null>;
-    }
->;
-declare const CompressedTransactionResult: Struct<
-    {
-        compressionInfo: {
-            closedAccounts: {
-                account: {
-                    lamports: BN;
-                    data: {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null;
-                    address: number[] | null;
-                    hash: BN;
-                    owner: PublicKey;
-                    leafIndex: number;
-                    tree: PublicKey;
-                    seq: BN | null;
-                    slotCreated: BN;
-                };
-                optionalTokenData: {
-                    owner: PublicKey;
-                    mint: PublicKey;
-                    amount: BN;
-                    delegate: PublicKey | null;
-                    state: string;
-                } | null;
-            }[];
-            openedAccounts: {
-                account: {
-                    lamports: BN;
-                    data: {
-                        data: string;
-                        dataHash: BN;
-                        discriminator: BN;
-                    } | null;
-                    address: number[] | null;
-                    hash: BN;
-                    owner: PublicKey;
-                    leafIndex: number;
-                    tree: PublicKey;
-                    seq: BN | null;
-                    slotCreated: BN;
-                };
-                optionalTokenData: {
-                    owner: PublicKey;
-                    mint: PublicKey;
-                    amount: BN;
-                    delegate: PublicKey | null;
-                    state: string;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                lamports: BN;
+                data: {
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
                 } | null;
-            }[];
-        };
-        transaction?: any;
-    },
-    {
-        compressionInfo: Struct<
-            {
-                closedAccounts: {
-                    account: {
-                        lamports: BN;
-                        data: {
-                            data: string;
-                            dataHash: BN;
-                            discriminator: BN;
-                        } | null;
-                        address: number[] | null;
-                        hash: BN;
-                        owner: PublicKey;
-                        leafIndex: number;
-                        tree: PublicKey;
-                        seq: BN | null;
-                        slotCreated: BN;
-                    };
-                    optionalTokenData: {
-                        owner: PublicKey;
-                        mint: PublicKey;
-                        amount: BN;
-                        delegate: PublicKey | null;
-                        state: string;
-                    } | null;
-                }[];
-                openedAccounts: {
-                    account: {
-                        lamports: BN;
-                        data: {
-                            data: string;
-                            dataHash: BN;
-                            discriminator: BN;
-                        } | null;
-                        address: number[] | null;
-                        hash: BN;
-                        owner: PublicKey;
-                        leafIndex: number;
-                        tree: PublicKey;
-                        seq: BN | null;
-                        slotCreated: BN;
-                    };
-                    optionalTokenData: {
-                        owner: PublicKey;
-                        mint: PublicKey;
-                        amount: BN;
-                        delegate: PublicKey | null;
-                        state: string;
-                    } | null;
-                }[];
-            },
-            {
-                closedAccounts: Struct<
-                    {
-                        account: {
-                            lamports: BN;
-                            data: {
-                                data: string;
-                                dataHash: BN;
-                                discriminator: BN;
-                            } | null;
-                            address: number[] | null;
-                            hash: BN;
-                            owner: PublicKey;
-                            leafIndex: number;
-                            tree: PublicKey;
-                            seq: BN | null;
-                            slotCreated: BN;
-                        };
-                        optionalTokenData: {
-                            owner: PublicKey;
-                            mint: PublicKey;
-                            amount: BN;
-                            delegate: PublicKey | null;
-                            state: string;
-                        } | null;
-                    }[],
-                    Struct<
-                        {
-                            account: {
-                                lamports: BN;
-                                data: {
-                                    data: string;
-                                    dataHash: BN;
-                                    discriminator: BN;
-                                } | null;
-                                address: number[] | null;
-                                hash: BN;
-                                owner: PublicKey;
-                                leafIndex: number;
-                                tree: PublicKey;
-                                seq: BN | null;
-                                slotCreated: BN;
-                            };
-                            optionalTokenData: {
-                                owner: PublicKey;
-                                mint: PublicKey;
-                                amount: BN;
-                                delegate: PublicKey | null;
-                                state: string;
-                            } | null;
-                        },
-                        {
-                            account: Struct<
-                                {
-                                    lamports: BN;
-                                    data: {
-                                        data: string;
-                                        dataHash: BN;
-                                        discriminator: BN;
-                                    } | null;
-                                    address: number[] | null;
-                                    hash: BN;
-                                    owner: PublicKey;
-                                    leafIndex: number;
-                                    tree: PublicKey;
-                                    seq: BN | null;
-                                    slotCreated: BN;
-                                },
-                                {
-                                    address: Struct<number[] | null, null>;
-                                    hash: Struct<BN, null>;
-                                    data: Struct<
-                                        {
-                                            data: string;
-                                            dataHash: BN;
-                                            discriminator: BN;
-                                        } | null,
-                                        {
-                                            data: Struct<string, null>;
-                                            dataHash: Struct<BN, null>;
-                                            discriminator: Struct<BN, null>;
-                                        }
-                                    >;
-                                    lamports: Struct<BN, null>;
-                                    owner: Struct<PublicKey, null>;
-                                    leafIndex: Struct<number, null>;
-                                    tree: Struct<PublicKey, null>;
-                                    seq: Struct<BN | null, null>;
-                                    slotCreated: Struct<BN, null>;
-                                }
-                            >;
-                            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: {
-                            lamports: BN;
-                            data: {
-                                data: string;
-                                dataHash: BN;
-                                discriminator: BN;
-                            } | null;
-                            address: number[] | null;
-                            hash: BN;
-                            owner: PublicKey;
-                            leafIndex: number;
-                            tree: PublicKey;
-                            seq: BN | null;
-                            slotCreated: BN;
-                        };
-                        optionalTokenData: {
-                            owner: PublicKey;
-                            mint: PublicKey;
-                            amount: BN;
-                            delegate: PublicKey | null;
-                            state: string;
-                        } | null;
-                    }[],
-                    Struct<
-                        {
-                            account: {
-                                lamports: BN;
-                                data: {
-                                    data: string;
-                                    dataHash: BN;
-                                    discriminator: BN;
-                                } | null;
-                                address: number[] | null;
-                                hash: BN;
-                                owner: PublicKey;
-                                leafIndex: number;
-                                tree: PublicKey;
-                                seq: BN | null;
-                                slotCreated: BN;
-                            };
-                            optionalTokenData: {
-                                owner: PublicKey;
-                                mint: PublicKey;
-                                amount: BN;
-                                delegate: PublicKey | null;
-                                state: string;
-                            } | null;
-                        },
-                        {
-                            account: Struct<
-                                {
-                                    lamports: BN;
-                                    data: {
-                                        data: string;
-                                        dataHash: BN;
-                                        discriminator: BN;
-                                    } | null;
-                                    address: number[] | null;
-                                    hash: BN;
-                                    owner: PublicKey;
-                                    leafIndex: number;
-                                    tree: PublicKey;
-                                    seq: BN | null;
-                                    slotCreated: BN;
-                                },
-                                {
-                                    address: Struct<number[] | null, null>;
-                                    hash: Struct<BN, null>;
-                                    data: Struct<
-                                        {
-                                            data: string;
-                                            dataHash: BN;
-                                            discriminator: BN;
-                                        } | null,
-                                        {
-                                            data: Struct<string, null>;
-                                            dataHash: Struct<BN, null>;
-                                            discriminator: Struct<BN, null>;
-                                        }
-                                    >;
-                                    lamports: Struct<BN, null>;
-                                    owner: Struct<PublicKey, null>;
-                                    leafIndex: Struct<number, null>;
-                                    tree: Struct<PublicKey, null>;
-                                    seq: Struct<BN | null, null>;
-                                    slotCreated: Struct<BN, null>;
-                                }
-                            >;
-                            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>;
-    }
->;
+                address: number[] | null;
+                hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
+                tree: PublicKey;
+                seq: BN | null;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    dataHash: BN;
+                    discriminator: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+            }>;
+            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>;
+}>;
 interface CompressionApiInterface {
-    getCompressedAccount(
-        address?: BN254,
-        hash?: BN254,
-    ): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
     getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN | null>;
     getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>;
-    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>>;
-    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[]>>;
-    getCompressedTokenAccountsByDelegate(
-        delegate: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<ParsedTokenAccount[]>>;
+    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>>;
+    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[]>>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     getCompressedTokenAccountBalance(hash: BN254): Promise<{
         amount: BN;
     }>;
-    getCompressedTokenBalancesByOwner(
-        publicKey: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<TokenBalance[]>>;
-    getCompressedTokenBalancesByOwnerV2(
-        publicKey: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithContext<WithCursor<TokenBalance[]>>>;
-    getTransactionWithCompressionInfo(
-        signature: string,
-    ): Promise<CompressedTransaction | null>;
-    getCompressionSignaturesForAccount(
-        hash: BN254,
-    ): Promise<SignatureWithMetadata[]>;
-    getCompressionSignaturesForAddress(
-        address: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
-    getCompressionSignaturesForOwner(
-        owner: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
-    getCompressionSignaturesForTokenOwner(
-        owner: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
-    getLatestNonVotingSignatures(
-        limit?: number,
-        cursor?: string,
-    ): Promise<LatestNonVotingSignatures>;
-    getLatestCompressionSignatures(
-        cursor?: string,
-        limit?: number,
-    ): Promise<LatestNonVotingSignaturesPaginated>;
+    getCompressedTokenBalancesByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<TokenBalance[]>>;
+    getCompressedTokenBalancesByOwnerV2(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    getTransactionWithCompressionInfo(signature: string): Promise<CompressedTransaction | null>;
+    getCompressionSignaturesForAccount(hash: BN254): Promise<SignatureWithMetadata[]>;
+    getCompressionSignaturesForAddress(address: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForTokenOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
+    getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
     getIndexerHealth(): Promise<string>;
     getIndexerSlot(): Promise<number>;
 }
@@ -2028,16 +1664,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, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, 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.
@@ -2070,14 +1697,7 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * @param connectionConfig          Optional connection config
      * @param testRpcConfig             Config for the mock rpc
      */
-    constructor(
-        endpoint: string,
-        hasher: LightWasm,
-        compressionApiEndpoint: string,
-        proverEndpoint: string,
-        connectionConfig?: ConnectionConfig,
-        testRpcConfig?: TestRpcConfig,
-    );
+    constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
     /**
      * Manually set state tree addresses
      */
@@ -2093,10 +1713,7 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
     /**
      * Fetch the compressed account for the specified account hash
      */
-    getCompressedAccount(
-        address?: BN254,
-        hash?: BN254,
-    ): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
     /**
      * Fetch the compressed balance for the specified account hash
      */
@@ -2109,16 +1726,12 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * Fetch the latest merkle proof for the specified account hash from the
      * cluster
      */
-    getCompressedAccountProof(
-        hash: BN254,
-    ): Promise<MerkleContextWithMerkleProof>;
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
     /**
      * Fetch all the account info for multiple compressed accounts specified by
      * an array of account hashes
      */
-    getMultipleCompressedAccounts(
-        hashes: BN254[],
-    ): Promise<CompressedAccountWithMerkleContext[]>;
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     /**
      * Ensure that the Compression Indexer has already indexed the transaction
      */
@@ -2127,47 +1740,31 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * Fetch the latest merkle proofs for multiple compressed accounts specified
      * by an array account hashes
      */
-    getMultipleCompressedAccountProofs(
-        hashes: BN254[],
-    ): Promise<MerkleContextWithMerkleProof[]>;
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
     /**
      * Fetch all the compressed accounts owned by the specified public key.
      * Owner can be a program or user account
      */
-    getCompressedAccountsByOwner(
-        owner: PublicKey,
-        _config?: GetCompressedAccountsByOwnerConfig,
-    ): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    getCompressedAccountsByOwner(owner: PublicKey, _config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     /**
      * Fetch the latest compression signatures on the cluster. Results are
      * paginated.
      */
-    getLatestCompressionSignatures(
-        _cursor?: string,
-        _limit?: number,
-    ): Promise<LatestNonVotingSignaturesPaginated>;
+    getLatestCompressionSignatures(_cursor?: string, _limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
     /**
      * Fetch the latest non-voting signatures on the cluster. Results are
      * not paginated.
      */
-    getLatestNonVotingSignatures(
-        _limit?: number,
-    ): Promise<LatestNonVotingSignatures>;
+    getLatestNonVotingSignatures(_limit?: number): Promise<LatestNonVotingSignatures>;
     /**
      * Fetch all the compressed token accounts owned by the specified public
      * key. Owner can be a program or user account
      */
-    getCompressedTokenAccountsByOwner(
-        owner: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountsByOwner(owner: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     /**
      * Fetch all the compressed accounts delegated to the specified public key.
      */
-    getCompressedTokenAccountsByDelegate(
-        delegate: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     /**
      * Fetch the compressed token balance for the specified account hash
      */
@@ -2179,25 +1776,15 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * Fetch all the compressed token balances owned by the specified public
      * key. Can filter by mint.
      */
-    getCompressedTokenBalancesByOwner(
-        publicKey: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<
-        WithCursor<
-            {
-                balance: BN;
-                mint: PublicKey;
-            }[]
-        >
-    >;
+    getCompressedTokenBalancesByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<{
+        balance: BN;
+        mint: PublicKey;
+    }[]>>;
     /**
      * Fetch all the compressed token balances owned by the specified public
      * key. Can filter by mint. Uses context.
      */
-    getCompressedTokenBalancesByOwnerV2(
-        publicKey: PublicKey,
-        options: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    getCompressedTokenBalancesByOwnerV2(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
     /**
      * Returns confirmed signatures for transactions involving the specified
      * account hash forward in time from genesis to the most recent confirmed
@@ -2205,16 +1792,12 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      *
      * @param hash queried account hash
      */
-    getCompressionSignaturesForAccount(
-        _hash: BN254,
-    ): Promise<SignatureWithMetadata[]>;
+    getCompressionSignaturesForAccount(_hash: BN254): Promise<SignatureWithMetadata[]>;
     /**
      * Fetch a confirmed or finalized transaction from the cluster. Return with
      * CompressionInfo
      */
-    getTransactionWithCompressionInfo(
-        _signature: string,
-    ): Promise<CompressedTransaction | null>;
+    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction | null>;
     /**
      * Returns confirmed signatures for transactions involving the specified
      * address forward in time from genesis to the most recent confirmed
@@ -2222,10 +1805,7 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      *
      * @param address queried compressed account address
      */
-    getCompressionSignaturesForAddress(
-        _address: PublicKey,
-        _options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForAddress(_address: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Returns confirmed signatures for compression transactions involving the
      * specified account owner forward in time from genesis to the
@@ -2233,19 +1813,13 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      *
      * @param owner queried owner public key
      */
-    getCompressionSignaturesForOwner(
-        _owner: PublicKey,
-        _options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Returns confirmed signatures for compression transactions involving the
      * specified token account owner forward in time from genesis to the most
      * recent confirmed block
      */
-    getCompressionSignaturesForTokenOwner(
-        _owner: PublicKey,
-        _options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForTokenOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Fetch the current indexer health status
      */
@@ -2262,13 +1836,8 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      * @param addresses Array of BN254 new addresses
      * @returns Array of validity proofs for new addresses
      */
-    getMultipleNewAddressProofs(
-        addresses: BN254[],
-    ): Promise<MerkleContextWithNewAddressProof[]>;
-    getCompressedMintTokenHolders(
-        _mint: PublicKey,
-        _options?: PaginatedOptions,
-    ): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    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
@@ -2278,18 +1847,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<CompressedProofWithContext>;
     /**
      * @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<CompressedProofWithContext>>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -2304,14 +1867,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<CompressedProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
 }
 
 declare class IndexedElement {
@@ -2327,11 +1884,7 @@ declare class IndexedElementBundle {
     newLowElement: IndexedElement;
     newElement: IndexedElement;
     newElementNextValue: BN;
-    constructor(
-        newLowElement: IndexedElement,
-        newElement: IndexedElement,
-        newElementNextValue: BN,
-    );
+    constructor(newLowElement: IndexedElement, newElement: IndexedElement, newElementNextValue: BN);
 }
 /**
  * This indexed array implementation mirrors the rust implementation of the
@@ -2341,11 +1894,7 @@ declare class IndexedArray {
     elements: Array<IndexedElement>;
     currentNodeIndex: number;
     highestElementIndex: number;
-    constructor(
-        elements: Array<IndexedElement>,
-        currentNodeIndex: number,
-        highestElementIndex: number,
-    );
+    constructor(elements: Array<IndexedElement>, currentNodeIndex: number, highestElementIndex: number);
     static default(): IndexedArray;
     get(index: number): IndexedElement | undefined;
     length(): number;
@@ -2385,10 +1934,7 @@ declare class IndexedArray {
      * @param value The value of the new element to append.
      * @returns The new element and its updated low element.
      */
-    appendWithLowElementIndex(
-        lowElementIndex: number,
-        value: BN,
-    ): IndexedElementBundle;
+    appendWithLowElementIndex(lowElementIndex: number, value: BN): IndexedElementBundle;
     /**
      * Finds the lowest element in the array.
      * @returns The lowest element or undefined if the array is empty.
@@ -2400,10 +1946,7 @@ declare class IndexedArray {
      * @param value The value for the new element.
      * @returns A bundle containing the new element, the updated low element, and the value of the next element.
      */
-    newElementWithLowElementIndex(
-        lowElementIndex: number,
-        value: BN,
-    ): IndexedElementBundle;
+    newElementWithLowElementIndex(lowElementIndex: number, value: BN): IndexedElementBundle;
     /**
      * Creates a new element with the specified value by first finding the appropriate low element index.
      * @param value The value for the new element.
@@ -2412,7 +1955,7 @@ declare class IndexedArray {
     newElement(value: BN): IndexedElementBundle;
 }
 
-declare const DEFAULT_ZERO = '0';
+declare const DEFAULT_ZERO = "0";
 /**
  * @callback hashFunction
  * @param left Left leaf
@@ -2436,16 +1979,9 @@ declare class MerkleTree {
     _zeros: string[];
     _layers: string[][];
     _lightWasm: LightWasm;
-    constructor(
-        levels: number,
-        lightWasm: LightWasm,
-        elements?: string[],
-        {
-            zeroElement,
-        }?: {
-            zeroElement?: string | undefined;
-        },
-    );
+    constructor(levels: number, lightWasm: LightWasm, elements?: string[], { zeroElement }?: {
+        zeroElement?: string | undefined;
+    });
     _rebuild(): void;
     /**
      * Get tree root
@@ -2483,10 +2019,7 @@ declare class MerkleTree {
      * @param comparator A function that checks leaf value equality
      * @returns {number} Index if element is found, otherwise -1
      */
-    indexOf(
-        element: string,
-        comparator?: ((element: string, el: string) => boolean) | null,
-    ): number;
+    indexOf(element: string, comparator?: ((element: string, el: string) => boolean) | null): number;
     /**
      * Returns a copy of non-zero tree elements
      * @returns {Object[]}
@@ -2511,10 +2044,7 @@ declare class MerkleTree {
      * @param hashFunction
      * @returns {MerkleTree}
      */
-    static deserialize(
-        data: any,
-        hashFunction: (left: string, right: string) => string,
-    ): any;
+    static deserialize(data: any, hashFunction: (left: string, right: string) => string): any;
 }
 
 type Deserializer<T> = (data: Buffer$1, tx: ParsedTransactionWithMeta) => T;
@@ -2524,17 +2054,9 @@ type Deserializer<T> = (data: Buffer$1, tx: ParsedTransactionWithMeta) => T;
  *
  * */
 declare function getParsedEvents(rpc: Rpc): Promise<PublicTransactionEvent[]>;
-declare const parseEvents: <T>(
-    indexerEventsTransactions: (ParsedTransactionWithMeta | null)[],
-    deserializeFn: Deserializer<T>,
-) => NonNullable<T>[];
-declare const parsePublicTransactionEventWithIdl: (
-    data: Buffer$1,
-) => PublicTransactionEvent | null;
-declare function parseLightTransaction(
-    dataVec: Uint8Array[],
-    accountKeys: PublicKey[][],
-): PublicTransactionEvent | null | undefined;
+declare const parseEvents: <T>(indexerEventsTransactions: (ParsedTransactionWithMeta | null)[], deserializeFn: Deserializer<T>) => NonNullable<T>[];
+declare const parsePublicTransactionEventWithIdl: (data: Buffer$1) => PublicTransactionEvent | null;
+declare function parseLightTransaction(dataVec: Uint8Array[], accountKeys: PublicKey[][]): PublicTransactionEvent | null | undefined;
 
 type TokenData = {
     mint: PublicKey;
@@ -2554,10 +2076,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: CompressedAccount, programId?: PublicKey): TokenData | null;
 /**
  * Retrieves all compressed token accounts for a given mint and owner.
  *
@@ -2567,24 +2086,11 @@ declare function parseTokenLayoutWithIdl(
  * @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[]): 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[]>>;
-declare function getCompressedTokenAccountByHashTest(
-    rpc: Rpc,
-    hash: BN,
-): Promise<ParsedTokenAccount>;
+declare function getCompressedTokenAccountsByOwnerTest(rpc: Rpc, owner: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
+declare function getCompressedTokenAccountsByDelegateTest(rpc: Rpc, delegate: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
+declare function getCompressedTokenAccountByHashTest(rpc: Rpc, hash: BN): Promise<ParsedTokenAccount>;
 
 declare const ALICE: Keypair;
 declare const BOB: Keypair;
@@ -2606,11 +2112,7 @@ declare function deepEqual(ref: any, val: any): boolean;
  * @param counter   counter to use for generating the keypair.
  *                  If undefined or >255, generates random keypair.
  */
-declare function newAccountWithLamports(
-    rpc: Rpc,
-    lamports?: number,
-    counter?: number | undefined,
-): Promise<Signer>;
+declare function newAccountWithLamports(rpc: Rpc, lamports?: number, counter?: number | undefined): Promise<Signer>;
 declare function getConnection(): Connection;
 /**
  * For use in tests.
@@ -2621,11 +2123,7 @@ declare function getConnection(): Connection;
 declare function getTestKeypair(counter?: number | undefined): Keypair;
 
 /** @internal */
-declare function parseAccountData({
-    discriminator,
-    data,
-    dataHash,
-}: {
+declare function parseAccountData({ discriminator, data, dataHash, }: {
     discriminator: BN;
     data: string;
     dataHash: BN;
@@ -2644,12 +2142,7 @@ declare function parseAccountData({
  *                                      to endpoint
  * @param connectionConfig              Optional connection config
  */
-declare function createRpc(
-    endpointOrWeb3JsConnection?: string | Connection,
-    compressionApiEndpoint?: string,
-    proverEndpoint?: string,
-    config?: ConnectionConfig,
-): Rpc;
+declare function createRpc(endpointOrWeb3JsConnection?: string | Connection, compressionApiEndpoint?: string, proverEndpoint?: string, config?: ConnectionConfig): Rpc;
 /**
  * Helper function to preprocess the response to wrap numbers as strings
  * @param {string} text - The JSON string to preprocess
@@ -2657,21 +2150,9 @@ declare function createRpc(
  */
 declare function wrapBigNumbersAsStrings(text: string): string;
 /** @internal */
-declare const rpcRequest: (
-    rpcEndpoint: string,
-    method: string,
-    params?: any,
-    convertToCamelCase?: boolean,
-    debug?: boolean,
-) => Promise<any>;
+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<CompressedProof>;
 type NonInclusionMerkleProofInputs = {
     root: BN;
     value: BN;
@@ -2702,18 +2183,9 @@ type NonInclusionJsonStruct = {
     leafHigherRangeValue: string;
     nextIndex: number;
 };
-declare function convertMerkleProofsWithContextToHex(
-    merkleProofsWithContext: MerkleContextWithMerkleProof[],
-): HexInputsForProver[];
-declare function convertNonInclusionMerkleProofInputsToHex(
-    nonInclusionMerkleProofInputs: MerkleContextWithNewAddressProof[],
-): NonInclusionJsonStruct[];
-declare function getPublicInputHash(
-    accountProofs: MerkleContextWithMerkleProof[],
-    accountHashes: BN254[],
-    newAddressProofs: MerkleContextWithNewAddressProof[],
-    lightWasm: LightWasm,
-): BN;
+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
  *
@@ -2721,10 +2193,7 @@ declare function getPublicInputHash(
  * @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;
+declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKey): PublicKey;
 /**
  * Get the tree for a given queue
  *
@@ -2732,10 +2201,7 @@ declare function getQueueForTree(
  * @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;
+declare function getTreeForQueue(info: ActiveTreeBundle[], queue: PublicKey): PublicKey;
 /**
  * Get a random tree and queue from the active state tree addresses.
  *
@@ -2755,12 +2221,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
     activeStateTreeInfo: ActiveTreeBundle[] | null;
-    constructor(
-        endpoint: string,
-        compressionApiEndpoint: string,
-        proverEndpoint: string,
-        config?: ConnectionConfig,
-    );
+    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
      * Manually set state tree addresses
      */
@@ -2777,10 +2238,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
     /**
      * Fetch the compressed account for the specified account address or hash
      */
-    getCompressedAccount(
-        address?: BN254,
-        hash?: BN254,
-    ): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
     /**
      * Fetch the compressed balance for the specified account address or hash
      */
@@ -2793,46 +2251,31 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * Fetch the latest merkle proof for the specified account hash from the
      * cluster
      */
-    getCompressedAccountProof(
-        hash: BN254,
-    ): Promise<MerkleContextWithMerkleProof>;
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
     /**
      * Fetch all the account info for multiple compressed accounts specified by
      * an array of account hashes
      */
-    getMultipleCompressedAccounts(
-        hashes: BN254[],
-    ): Promise<CompressedAccountWithMerkleContext[]>;
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     /**
      * Fetch the latest merkle proofs for multiple compressed accounts specified
      * by an array account hashes
      */
-    getMultipleCompressedAccountProofs(
-        hashes: BN254[],
-    ): Promise<MerkleContextWithMerkleProof[]>;
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
     /**
      * Fetch all the compressed accounts owned by the specified public key.
      * Owner can be a program or user account
      */
-    getCompressedAccountsByOwner(
-        owner: PublicKey,
-        config?: GetCompressedAccountsByOwnerConfig | undefined,
-    ): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig | undefined): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     /**
      * Fetch all the compressed token accounts owned by the specified public
      * key. Owner can be a program or user account
      */
-    getCompressedTokenAccountsByOwner(
-        owner: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountsByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     /**
      * Fetch all the compressed accounts delegated to the specified public key.
      */
-    getCompressedTokenAccountsByDelegate(
-        delegate: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     /**
      * Fetch the compressed token balance for the specified account hash
      */
@@ -2845,18 +2288,12 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * Fetch all the compressed token balances owned by the specified public
      * key. Can filter by mint. Returns without context.
      */
-    getCompressedTokenBalancesByOwner(
-        owner: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<TokenBalance[]>>;
+    getCompressedTokenBalancesByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<TokenBalance[]>>;
     /**
      * Fetch the compressed token balances owned by the specified public
      * key. Paginated. Can filter by mint. Returns with context.
      */
-    getCompressedTokenBalancesByOwnerV2(
-        owner: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    getCompressedTokenBalancesByOwnerV2(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
     /**
      * Returns confirmed compression signatures for transactions involving the specified
      * account hash forward in time from genesis to the most recent confirmed
@@ -2864,26 +2301,19 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      *
      * @param hash queried account hash
      */
-    getCompressionSignaturesForAccount(
-        hash: BN254,
-    ): Promise<SignatureWithMetadata[]>;
+    getCompressionSignaturesForAccount(hash: BN254): Promise<SignatureWithMetadata[]>;
     /**
      * Fetch a confirmed or finalized transaction from the cluster. Return with
      * CompressionInfo
      */
-    getTransactionWithCompressionInfo(
-        signature: string,
-    ): Promise<CompressedTransaction | null>;
+    getTransactionWithCompressionInfo(signature: string): Promise<CompressedTransaction | null>;
     /**
      * Returns confirmed signatures for transactions involving the specified
      * address forward in time from genesis to the most recent confirmed block
      *
      * @param address queried compressed account address
      */
-    getCompressionSignaturesForAddress(
-        address: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForAddress(address: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Returns confirmed signatures for compression transactions involving the
      * specified account owner forward in time from genesis to the
@@ -2891,19 +2321,13 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      *
      * @param owner queried owner public key
      */
-    getCompressionSignaturesForOwner(
-        owner: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Returns confirmed signatures for compression transactions involving the
      * specified token account owner forward in time from genesis to the most
      * recent confirmed block
      */
-    getCompressionSignaturesForTokenOwner(
-        owner: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForTokenOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Fetch the current indexer health status
      */
@@ -2919,25 +2343,16 @@ declare class Rpc extends Connection implements CompressionApiInterface {
     /**
      * Fetch all the compressed token holders for a given mint. Paginated.
      */
-    getCompressedMintTokenHolders(
-        mint: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     /**
      * Fetch the latest compression signatures on the cluster. Results are
      * paginated.
      */
-    getLatestCompressionSignatures(
-        cursor?: string,
-        limit?: number,
-    ): Promise<LatestNonVotingSignaturesPaginated>;
+    getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
     /**
      * Fetch all non-voting signatures
      */
-    getLatestNonVotingSignatures(
-        limit?: number,
-        cursor?: string,
-    ): Promise<LatestNonVotingSignatures>;
+    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
     /**
      * Fetch the latest address proofs for new unique addresses specified by an
      * array of addresses.
@@ -2947,9 +2362,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @param addresses Array of BN254 new addresses
      * @returns Array of validity proofs for new addresses
      */
-    getMultipleNewAddressProofs(
-        addresses: BN254[],
-    ): Promise<MerkleContextWithNewAddressProof[]>;
+    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
@@ -2969,10 +2382,7 @@ 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<CompressedProofWithContext>;
     /**
      * @deprecated use {@link getValidityProofV0} instead.
      *
@@ -2991,10 +2401,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<CompressedProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -3009,10 +2416,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<CompressedProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -3029,10 +2433,7 @@ 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<CompressedProofWithContext>>;
 }
 
 /**
@@ -3047,14 +2448,7 @@ declare class Rpc extends Connection implements CompressionApiInterface {
  *
  * @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, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create compressed account with address
@@ -3073,16 +2467,7 @@ declare function compress(
  *
  * @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, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Create compressed account with address and lamports
  *
@@ -3102,17 +2487,7 @@ declare function createAccount(
  *
  * @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, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Decompress lamports into a solana account
@@ -3126,14 +2501,7 @@ declare function createAccountWithLamports(
  *
  * @return Transaction signature
  */
-declare function decompress(
-    rpc: Rpc,
-    payer: Signer,
-    lamports: number | BN,
-    recipient: PublicKey,
-    outputStateTree?: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+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[];
@@ -3154,24 +2522,13 @@ declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];
  *
  * @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, merkleTree?: 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;
+declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): number;
 /**
  * @internal
  * Pads output state trees with the 0th state tree of the input state.
@@ -3188,11 +2545,7 @@ declare function getIndexOrAdd(
  *
  * @returns Padded output state trees.
  */
-declare function padOutputStateMerkleTrees(
-    outputStateMerkleTrees: PublicKey[] | PublicKey | undefined,
-    numberOfOutputCompressedAccounts: number,
-    inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[],
-): PublicKey[];
+declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey[] | PublicKey | undefined, numberOfOutputCompressedAccounts: number, inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[]): PublicKey[];
 declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
 /**
  * Packs Compressed Accounts.
@@ -3214,21 +2567,13 @@ declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
  * @param remainingAccounts                 Optional existing array of accounts
  *                                          to append to.
  **/
-declare function packCompressedAccounts(
-    inputCompressedAccounts: CompressedAccountWithMerkleContext[],
-    inputStateRootIndices: number[],
-    outputCompressedAccounts: CompressedAccount[],
-    outputStateMerkleTrees?: PublicKey[] | PublicKey,
-    remainingAccounts?: PublicKey[],
-): {
+declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccount[], outputStateMerkleTrees?: PublicKey[] | PublicKey, remainingAccounts?: PublicKey[]): {
     packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
     packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     remainingAccounts: PublicKey[];
 };
 
-declare const sumUpLamports: (
-    accounts: CompressedAccountWithMerkleContext[],
-) => BN;
+declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
 /**
  * Create compressed account system transaction params
  */
@@ -3385,76 +2730,34 @@ declare class LightSystemProgram$1 {
      *
      */
     static deriveCompressedSolPda(): PublicKey;
-    static createTransferOutputState(
-        inputCompressedAccounts: CompressedAccountWithMerkleContext[],
-        toAddress: PublicKey,
-        lamports: number | BN,
-    ): CompressedAccount[];
-    static createDecompressOutputState(
-        inputCompressedAccounts: CompressedAccountWithMerkleContext[],
-        lamports: number | BN,
-    ): CompressedAccount[];
+    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[];
+    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,
-        outputStateTree,
-        inputCompressedAccounts,
-        inputStateRootIndices,
-        lamports,
-    }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
+    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTree, 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, outputStateTrees, }: 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, outputStateTree, }: 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, outputStateTree, }: DecompressParams): Promise<TransactionInstruction>;
 }
 /**
  * Selects the minimal number of compressed SOL accounts for a transfer.
@@ -3463,25 +2766,16 @@ declare class LightSystemProgram$1 {
  * 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 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 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;
+declare function decodeInstructionDataInvoke(buffer: Buffer$1): InstructionDataInvoke;
+declare function decodeInstructionDataInvokeCpi(buffer: Buffer$1): InstructionDataInvokeCpi;
 type invokeAccountsLayoutParams = {
     feePayer: PublicKey;
     authority: PublicKey;
@@ -3493,24 +2787,16 @@ type invokeAccountsLayoutParams = {
     decompressionRecipient: PublicKey | null;
     systemProgram: PublicKey;
 };
-declare const invokeAccountsLayout: (
-    accounts: invokeAccountsLayoutParams,
-) => AccountMeta[];
+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 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,
-): {
+declare function deserializeAppendNullifyCreateAddressInputsIndexer(buffer: Buffer$1): {
     meta: unknown;
     leaves: unknown[];
     nullifiers: unknown[];
@@ -3518,11 +2804,7 @@ declare function deserializeAppendNullifyCreateAddressInputsIndexer(
     sequence_numbers: unknown[];
     output_leaf_indices: number[];
 };
-declare function convertToPublicTransactionEvent(
-    decoded: any,
-    remainingAccounts: PublicKey[],
-    invokeData: InstructionDataInvoke,
-): PublicTransactionEvent;
+declare function convertToPublicTransactionEvent(decoded: any, remainingAccounts: PublicKey[], invokeData: InstructionDataInvoke): PublicTransactionEvent;
 
 declare const FIELD_SIZE: BN;
 declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
@@ -3530,10 +2812,9 @@ 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 noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
+declare const lightProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
+declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
 declare const getRegisteredProgramPda: () => PublicKey;
 declare const getAccountCompressionAuthority: () => PublicKey;
 declare const defaultStaticAccounts: () => PublicKey[];
@@ -3581,24 +2862,18 @@ 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 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;
@@ -3636,53 +2911,53 @@ declare const STATE_MERKLE_TREE_NETWORK_FEE: BN;
 declare const ADDRESS_TREE_NETWORK_FEE: BN;
 
 declare enum UtxoErrorCode {
-    NEGATIVE_LAMPORTS = 'NEGATIVE_LAMPORTS',
-    NOT_U64 = 'NOT_U64',
-    BLINDING_EXCEEDS_FIELD_SIZE = 'BLINDING_EXCEEDS_FIELD_SIZE',
+    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',
+    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',
+    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',
+    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',
+    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',
+    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',
+    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',
+    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',
+    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;
@@ -3690,15 +2965,24 @@ declare class MetaError extends Error {
     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 {}
+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 = {
     version: '1.2.0';
@@ -3708,7 +2992,7 @@ type LightSystemProgram = {
             name: 'SOL_POOL_PDA_SEED';
             type: 'bytes';
             value: '[115, 111, 108, 95, 112, 111, 111, 108, 95, 112, 100, 97]';
-        },
+        }
     ];
     instructions: [
         {
@@ -3728,7 +3012,7 @@ type LightSystemProgram = {
                     name: 'associatedMerkleTree';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [];
         },
@@ -3740,7 +3024,7 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: true;
                     docs: [
-                        'Fee payer needs to be mutable to pay rollover and protocol fees.',
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
                     ];
                 },
                 {
@@ -3763,7 +3047,7 @@ type LightSystemProgram = {
                     isMut: false;
                     isSigner: false;
                     docs: [
-                        'This pda is used to invoke the account compression program.',
+                        'This pda is used to invoke the account compression program.'
                     ];
                 },
                 {
@@ -3779,7 +3063,7 @@ type LightSystemProgram = {
                     isOptional: true;
                     docs: [
                         'Sol pool pda is used to store the native sol that has been compressed.',
-                        "It's only required when compressing or decompressing sol.",
+                        "It's only required when compressing or decompressing sol."
                     ];
                 },
                 {
@@ -3790,20 +3074,20 @@ type LightSystemProgram = {
                     docs: [
                         'Only needs to be provided for decompression as a recipient for the',
                         'decompressed sol.',
-                        'Compressed sol originate from authority.',
+                        'Compressed sol originate from authority.'
                     ];
                 },
                 {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -3814,7 +3098,7 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: true;
                     docs: [
-                        'Fee payer needs to be mutable to pay rollover and protocol fees.',
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
                     ];
                 },
                 {
@@ -3869,13 +3153,13 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -3886,7 +3170,7 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: true;
                     docs: [
-                        'Fee payer needs to be mutable to pay rollover and protocol fees.',
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
                     ];
                 },
                 {
@@ -3941,13 +3225,13 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -3955,7 +3239,7 @@ type LightSystemProgram = {
             docs: [
                 'This function is a stub to allow Anchor to include the input types in',
                 'the IDL. It should not be included in production builds nor be called in',
-                'practice.',
+                'practice.'
             ];
             accounts: [
                 {
@@ -3963,7 +3247,7 @@ type LightSystemProgram = {
                     isMut: true;
                     isSigner: true;
                     docs: [
-                        'Fee payer needs to be mutable to pay rollover and protocol fees.',
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
                     ];
                 },
                 {
@@ -3986,7 +3270,7 @@ type LightSystemProgram = {
                     isMut: false;
                     isSigner: false;
                     docs: [
-                        'This pda is used to invoke the account compression program.',
+                        'This pda is used to invoke the account compression program.'
                     ];
                 },
                 {
@@ -4002,7 +3286,7 @@ type LightSystemProgram = {
                     isOptional: true;
                     docs: [
                         'Sol pool pda is used to store the native sol that has been compressed.',
-                        "It's only required when compressing or decompressing sol.",
+                        "It's only required when compressing or decompressing sol."
                     ];
                 },
                 {
@@ -4013,14 +3297,14 @@ type LightSystemProgram = {
                     docs: [
                         'Only needs to be provided for decompression as a recipient for the',
                         'decompressed sol.',
-                        'Compressed sol originate from authority.',
+                        'Compressed sol originate from authority.'
                     ];
                 },
                 {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -4040,9 +3324,9 @@ type LightSystemProgram = {
                     type: {
                         defined: 'PublicTransactionEvent';
                     };
-                },
+                }
             ];
-        },
+        }
     ];
     accounts: [
         {
@@ -4053,7 +3337,7 @@ type LightSystemProgram = {
                 'Collected instruction data is combined with the instruction data of the executing cpi,',
                 'and executed as a single transaction.',
                 'This enables to use input compressed accounts that are owned by multiple programs,',
-                'with one zero-knowledge proof.',
+                'with one zero-knowledge proof.'
             ];
             type: {
                 kind: 'struct';
@@ -4073,10 +3357,10 @@ type LightSystemProgram = {
                                 defined: 'InstructionDataInvokeCpi';
                             };
                         };
-                    },
+                    }
                 ];
             };
-        },
+        }
     ];
     types: [
         {
@@ -4131,7 +3415,7 @@ type LightSystemProgram = {
                     {
                         name: 'isCompress';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4157,7 +3441,7 @@ type LightSystemProgram = {
                     {
                         name: 'addressMerkleTreeRootIndex';
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -4175,7 +3459,7 @@ type LightSystemProgram = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4201,7 +3485,7 @@ type LightSystemProgram = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4265,7 +3549,7 @@ type LightSystemProgram = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4278,7 +3562,7 @@ type LightSystemProgram = {
                         name: 'setContext';
                         docs: [
                             'Is set by the program that is invoking the CPI to signal that is should',
-                            'set the cpi context.',
+                            'set the cpi context.'
                         ];
                         type: 'bool';
                     },
@@ -4286,17 +3570,17 @@ type LightSystemProgram = {
                         name: 'firstSetContext';
                         docs: [
                             'Is set to wipe the cpi context since someone could have set it before',
-                            'with unrelated data.',
+                            'with unrelated data.'
                         ];
                         type: 'bool';
                     },
                     {
                         name: 'cpiContextAccountIndex';
                         docs: [
-                            'Index of cpi context account in remaining accounts.',
+                            'Index of cpi context account in remaining accounts.'
                         ];
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4328,7 +3612,7 @@ type LightSystemProgram = {
                                 defined: 'CompressedAccountData';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4352,7 +3636,7 @@ type LightSystemProgram = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4376,17 +3660,17 @@ type LightSystemProgram = {
                     {
                         name: 'rootIndex';
                         docs: [
-                            'Index of root used in inclusion validity proof.',
+                            'Index of root used in inclusion validity proof.'
                         ];
                         type: 'u16';
                     },
                     {
                         name: 'readOnly';
                         docs: [
-                            'Placeholder to mark accounts read-only unimplemented set to false.',
+                            'Placeholder to mark accounts read-only unimplemented set to false.'
                         ];
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4414,7 +3698,7 @@ type LightSystemProgram = {
                                 defined: 'QueueIndex';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4432,7 +3716,7 @@ type LightSystemProgram = {
                         name: 'index';
                         docs: ['Index of compressed account hash in queue.'];
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -4448,7 +3732,7 @@ type LightSystemProgram = {
                     {
                         name: 'seq';
                         type: 'u64';
-                    },
+                    }
                 ];
             };
         },
@@ -4522,10 +3806,10 @@ type LightSystemProgram = {
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
-        },
+        }
     ];
     errors: [
         {
@@ -4715,259 +3999,9 @@ type LightSystemProgram = {
         {
             code: 6038;
             name: 'InvalidStateTreeHeight';
-        },
+        }
     ];
 };
 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,
-    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,
-    validateSameOwner,
-    validateSufficientBalance,
-    wrapBigNumbersAsStrings,
-};
+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 };