@lightprotocol/stateless.js 0.22.1-alpha.0 → 0.22.1-alpha.2

package/dist/types/index.d.ts

@@ -1,10 +1,9 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, Connection, Commitment, Keypair, Signer, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, AccountMeta, DataSlice, MemcmpFilter, ConnectionConfig, AccountInfo, ParsedTransactionWithMeta } from '@solana/web3.js';
+import { PublicKey, Connection, Commitment, Keypair, Signer, AccountMeta, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, DataSlice, MemcmpFilter, GetAccountInfoConfig, AccountInfo, SignaturesForAddressOptions, ConfirmedSignatureInfo, TokenAmount, ConnectionConfig, ParsedTransactionWithMeta } from '@solana/web3.js';
 import { Buffer as Buffer$1 } from 'buffer';
 import { Struct } from 'superstruct';
 import BN from 'bn.js';
 import * as buffer_layout from 'buffer-layout';
-import * as borsh from '@coral-xyz/borsh';
 import { Layout } from '@coral-xyz/borsh';
 
 /**
@@ -21,30 +20,18 @@ declare function encodeBN254toBase58(bigintNumber: BN): string;
 
 declare const bn: (number: string | number | BN | Buffer$1 | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => BN;
 
-/**
- * Derive an address for a compressed account from a seed and an address Merkle
- * tree public key.
- *
- * @param seed                     32 bytes seed to derive the address from
- * @param addressMerkleTreePubkey  Address Merkle tree public key as bytes.
- * @param programIdBytes           Program ID bytes.
- * @returns                        Derived address as bytes
- */
-declare function deriveAddressV2(seed: Uint8Array, addressMerkleTreePubkey: Uint8Array, programIdBytes: Uint8Array): Uint8Array;
-declare function hashVWithBumpSeed(bytes: Uint8Array[]): Uint8Array;
 declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
+declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
+declare function deriveAddressSeedV2(seeds: Uint8Array[]): Uint8Array;
 /**
- * @deprecated Use {@link deriveAddressV2} instead, unless you're using v1.
+ * Derives an address from a seed using the v2 method (matching Rust's derive_address_from_seed)
  *
- * Derive an address for a compressed account from a seed and an address Merkle
- * tree public key.
- *
- * @param seed                     Seed to derive the address from
- * @param addressMerkleTreePubkey  Merkle tree public key. Defaults to
- *                                 defaultTestStateTreeAccounts().addressTree
+ * @param addressSeed              The address seed (32 bytes)
+ * @param addressMerkleTreePubkey  Merkle tree public key
+ * @param programId                Program ID
  * @returns                        Derived address
  */
-declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
+declare function deriveAddressV2(addressSeed: Uint8Array, addressMerkleTreePubkey: PublicKey, programId: PublicKey): PublicKey;
 interface NewAddressParams {
     /**
      * Seed for the compressed account. Must be seed used to derive
@@ -131,8 +118,8 @@ declare const toCamelCase: (object: any) => any;
  * @deprecated Use `hashvToBn254FieldSizeBe` instead.
  */
 declare function hashToBn254FieldSizeBe(bytes: Buffer$1): [Buffer$1, number] | null;
+declare function hashvToBn254FieldSizeBeU8Array(bytes: Uint8Array[]): Uint8Array;
 /**
- * TODO: make consistent with latest rust. (use u8::max bumpseed)
  * 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.
  *
@@ -148,6 +135,41 @@ declare function convertInvokeCpiWithReadOnlyToInvoke(data: any): InstructionDat
 /** @internal remove signer from signers if part of signers */
 declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];
 
+declare class PackedAccounts {
+    private preAccounts;
+    private systemAccounts;
+    private nextIndex;
+    private map;
+    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccounts;
+    static newWithSystemAccountsV2(config: SystemAccountMetaConfig): PackedAccounts;
+    addPreAccountsSigner(pubkey: PublicKey): void;
+    addPreAccountsSignerMut(pubkey: PublicKey): void;
+    addPreAccountsMeta(accountMeta: AccountMeta): void;
+    addSystemAccounts(config: SystemAccountMetaConfig): void;
+    addSystemAccountsV2(config: SystemAccountMetaConfig): void;
+    insertOrGet(pubkey: PublicKey): number;
+    insertOrGetReadOnly(pubkey: PublicKey): number;
+    insertOrGetConfig(pubkey: PublicKey, isSigner: boolean, isWritable: boolean): number;
+    private hashSetAccountsToMetas;
+    private getOffsets;
+    toAccountMetas(): {
+        remainingAccounts: AccountMeta[];
+        systemStart: number;
+        packedStart: number;
+    };
+}
+declare class SystemAccountMetaConfig {
+    selfProgram: PublicKey;
+    cpiContext?: PublicKey;
+    solCompressionRecipient?: PublicKey;
+    solPoolPda?: PublicKey;
+    private constructor();
+    static new(selfProgram: PublicKey): SystemAccountMetaConfig;
+    static newWithCpiContext(selfProgram: PublicKey, cpiContext: PublicKey): SystemAccountMetaConfig;
+}
+declare function getLightSystemAccountMetas(config: SystemAccountMetaConfig): AccountMeta[];
+declare function getLightSystemAccountMetasV2(config: SystemAccountMetaConfig): AccountMeta[];
+
 interface GnarkProofJson {
     ar: string[];
     bs: string[][];
@@ -357,10 +379,24 @@ declare const isLocalTest: (url: string) => boolean;
  * @internal
  */
 declare const localTestActiveStateTreeInfos: () => TreeInfo[];
+declare const getDefaultAddressSpace: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: undefined;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
 declare const getDefaultAddressTreeInfo: () => {
     tree: PublicKey;
     queue: PublicKey;
-    cpiContext: null;
+    cpiContext: undefined;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
+declare const getBatchAddressTreeInfo: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: undefined;
     treeType: TreeType;
     nextTreeInfo: null;
 };
@@ -385,6 +421,7 @@ declare const defaultTestStateTreeAccounts2: () => {
     merkleTree2: PublicKey;
 };
 declare const COMPRESSED_TOKEN_PROGRAM_ID: PublicKey;
+declare const CTOKEN_PROGRAM_ID: PublicKey;
 declare const stateTreeLookupTableMainnet = "7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st";
 declare const nullifiedStateTreeLookupTableMainnet = "H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT";
 declare const stateTreeLookupTableDevnet = "Dk9mNkbiZXJZ4By8DfSP6HEE4ojZzRvucwpawLeuwq8q";
@@ -394,13 +431,28 @@ declare const cpiContextPubkey = "cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fonubE4";
 declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
 declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
 declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
-declare const addressTreeV2: PublicKey;
 declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
 declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
 declare const cpiContext2Pubkey = "cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK";
-declare const batchMerkleTree = "HLKs5NJ8FXkJg8BrzJt56adFYYuwg5etzDtBbQYTsixu";
-declare const batchQueue = "6L7SzhYB3anwEQ9cphpJ1U7Scwj57bx2xueReg7R9cKU";
-declare const batchCpiContext = "7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj";
+declare const batchMerkleTree1 = "bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU";
+declare const batchQueue1 = "oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto";
+declare const batchCpiContext1 = "cpi15BoVPKgEPw5o8wc2T816GE7b378nMXnhH3Xbq4y";
+declare const batchMerkleTree2 = "bmt2UxoBxB9xWev4BkLvkGdapsz6sZGkzViPNph7VFi";
+declare const batchQueue2 = "oq2UkeMsJLfXt2QHzim242SUi3nvjJs8Pn7Eac9H9vg";
+declare const batchCpiContext2 = "cpi2yGapXUR3As5SjnHBAVvmApNiLsbeZpF3euWnW6B";
+declare const batchMerkleTree3 = "bmt3ccLd4bqSVZVeCJnH1F6C8jNygAhaDfxDwePyyGb";
+declare const batchQueue3 = "oq3AxjekBWgo64gpauB6QtuZNesuv19xrhaC1ZM1THQ";
+declare const batchCpiContext3 = "cpi3mbwMpSX8FAGMZVP85AwxqCaQMfEk9Em1v8QK9Rf";
+declare const batchMerkleTree4 = "bmt4d3p1a4YQgk9PeZv5s4DBUmbF5NxqYpk9HGjQsd8";
+declare const batchQueue4 = "oq4ypwvVGzCUMoiKKHWh4S1SgZJ9vCvKpcz6RT6A8dq";
+declare const batchCpiContext4 = "cpi4yyPDc4bCgHAnsenunGA8Y77j3XEDyjgfyCKgcoc";
+declare const batchMerkleTree5 = "bmt5yU97jC88YXTuSukYHa8Z5Bi2ZDUtmzfkDTA2mG2";
+declare const batchQueue5 = "oq5oh5ZR3yGomuQgFduNDzjtGvVWfDRGLuDVjv9a96P";
+declare const batchCpiContext5 = "cpi5ZTjdgYpZ1Xr7B1cMLLUE81oTtJbNNAyKary2nV6";
+declare const batchAddressTree = "amt2kaJA14v3urZbZvnc5v2np8jqvc4Z8zDep5wbtzx";
+declare const testBatchAddressTree = "EzKE84aVTkCUhDHLELqyJaq1Y7UVVmqxXqZjVHwHY3rK";
+declare const batchMerkleTree = "bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU";
+declare const batchQueue = "oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto";
 declare const confirmConfig: ConfirmOptions;
 declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
 declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;
@@ -433,10 +485,28 @@ declare const ADDRESS_QUEUE_ROLLOVER_FEE: BN;
  */
 declare const STATE_MERKLE_TREE_NETWORK_FEE: BN;
 /**
- * Is charged if the transaction creates at least one address.
+ * Is charged per address the transaction creates.
+ */
+declare const ADDRESS_TREE_NETWORK_FEE_V1: BN;
+/**
+ * Is charged per address the transaction creates.
  */
-declare const ADDRESS_TREE_NETWORK_FEE: BN;
+declare const ADDRESS_TREE_NETWORK_FEE_V2: BN;
 
+/**
+ * Get the currently active output queue from a merkle context.
+ *
+ * @param merkleContext The merkle context to get the output queue from
+ * @returns The output queue public key
+ */
+declare function getOutputQueue(merkleContext: MerkleContext): PublicKey;
+/**
+ * Get the currently active output tree info from a merkle context.
+ *
+ * @param merkleContext The merkle context to get the output tree info from
+ * @returns The output tree info
+ */
+declare function getOutputTreeInfo(merkleContext: MerkleContext): TreeInfo;
 /**
  * @deprecated use {@link getTreeInfoByPubkey} instead
  */
@@ -483,166 +553,34 @@ declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
     stateTreeLUTPairs: StateTreeLUTPair[];
 }): Promise<TreeInfo[]>;
 
-/**
- * This file provides two variants of packed accounts for Light Protocol:
- *
- * 1. PackedAccounts - Matches CpiAccounts (11 system accounts)
- *    - Includes: LightSystemProgram, Authority, RegisteredProgramPda, NoopProgram,
- *      AccountCompressionAuthority, AccountCompressionProgram, InvokingProgram,
- *      [Optional: SolPoolPda, DecompressionRecipient], SystemProgram, [Optional: CpiContext]
- *
- * 2. PackedAccountsSmall - Matches CpiAccountsSmall (9 system accounts max)
- *    - Includes: LightSystemProgram, Authority, RegisteredProgramPda,
- *      AccountCompressionAuthority, AccountCompressionProgram, SystemProgram,
- *      [Optional: SolPoolPda, DecompressionRecipient, CpiContext]
- *    - Excludes: NoopProgram and InvokingProgram for a more compact structure
- */
-/**
- * Create a PackedAccounts instance to pack the light protocol system accounts
- * for your custom program instruction. Typically, you will append them to the
- * end of your instruction's accounts / remainingAccounts.
- *
- * This matches the full CpiAccounts structure with 11 system accounts including
- * NoopProgram and InvokingProgram. For a more compact version, use PackedAccountsSmall.
- *
- * @example
- * ```ts
- * const packedAccounts = PackedAccounts.newWithSystemAccounts(config);
- *
- * const instruction = new TransactionInstruction({
- *     keys: [...yourInstructionAccounts, ...packedAccounts.toAccountMetas()],
- *     programId: selfProgram,
- *     data: data,
- * });
- * ```
- */
-declare class PackedAccounts {
-    private preAccounts;
-    private systemAccounts;
-    private nextIndex;
-    private map;
-    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccounts;
-    addPreAccountsSigner(pubkey: PublicKey): void;
-    addPreAccountsSignerMut(pubkey: PublicKey): void;
-    addPreAccountsMeta(accountMeta: AccountMeta): void;
-    addSystemAccounts(config: SystemAccountMetaConfig): void;
-    insertOrGet(pubkey: PublicKey): number;
-    insertOrGetReadOnly(pubkey: PublicKey): number;
-    insertOrGetConfig(pubkey: PublicKey, isSigner: boolean, isWritable: boolean): number;
-    private hashSetAccountsToMetas;
-    private getOffsets;
-    toAccountMetas(): {
-        remainingAccounts: AccountMeta[];
-        systemStart: number;
-        packedStart: number;
-    };
-}
-/**
- * Creates a PackedAccounts instance with system accounts for the specified
- * program. This is a convenience wrapper around SystemAccountMetaConfig.new()
- * and PackedAccounts.newWithSystemAccounts().
- *
- * @param programId - The program ID that will be using these system accounts
- * @returns A new PackedAccounts instance with system accounts configured
- *
- * @example
- * ```ts
- * const packedAccounts = createPackedAccounts(myProgram.programId);
- *
- * const instruction = new TransactionInstruction({
- *     keys: [...yourInstructionAccounts, ...packedAccounts.toAccountMetas().remainingAccounts],
- *     programId: myProgram.programId,
- *     data: instructionData,
- * });
- * ```
- */
-declare function createPackedAccounts(programId: PublicKey): PackedAccounts;
-/**
- * Creates a PackedAccounts instance with system accounts and CPI context for the specified program.
- * This is a convenience wrapper that includes CPI context configuration.
- *
- * @param programId - The program ID that will be using these system accounts
- * @param cpiContext - The CPI context account public key
- * @returns A new PackedAccounts instance with system accounts and CPI context configured
- *
- * @example
- * ```ts
- * const packedAccounts = createPackedAccountsWithCpiContext(
- *     myProgram.programId,
- *     cpiContextAccount
- * );
- * ```
- */
-declare function createPackedAccountsWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccounts;
-declare class SystemAccountMetaConfig {
-    selfProgram: PublicKey;
-    cpiContext?: PublicKey;
-    solCompressionRecipient?: PublicKey;
-    solPoolPda?: PublicKey;
-    private constructor();
-    static new(selfProgram: PublicKey): SystemAccountMetaConfig;
-    static newWithCpiContext(selfProgram: PublicKey, cpiContext: PublicKey): SystemAccountMetaConfig;
+interface AccountDataWithTreeInfo {
+    key: string;
+    data: any;
+    treeInfo: TreeInfo;
 }
-/**
- * Get the light protocol system accounts for your custom program instruction.
- * Use via `link PackedAccounts.addSystemAccounts(config)`.
- */
-declare function getLightSystemAccountMetas(config: SystemAccountMetaConfig): AccountMeta[];
-/**
- * PackedAccountsSmall matches the CpiAccountsSmall structure with simplified account ordering.
- * This is a more compact version that excludes NoopProgram and InvokingProgram.
- */
-declare class PackedAccountsSmall {
-    private preAccounts;
-    private systemAccounts;
-    private nextIndex;
-    private map;
-    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccountsSmall;
-    /**
-     * Returns the internal map of pubkey to [index, AccountMeta].
-     * For debugging purposes only.
-     */
-    getNamedMetas(): Map<string, [number, AccountMeta]>;
-    addPreAccountsSigner(pubkey: PublicKey): void;
-    addPreAccountsSignerMut(pubkey: PublicKey): void;
-    addPreAccountsMeta(accountMeta: AccountMeta): void;
-    addSystemAccounts(config: SystemAccountMetaConfig): void;
-    insertOrGet(pubkey: PublicKey): number;
-    insertOrGetReadOnly(pubkey: PublicKey): number;
-    insertOrGetConfig(pubkey: PublicKey, isSigner: boolean, isWritable: boolean): number;
-    private hashSetAccountsToMetas;
-    private getOffsets;
-    toAccountMetas(): {
-        remainingAccounts: AccountMeta[];
-        systemStart: number;
-        packedStart: number;
+interface PackedDecompressResult {
+    proofOption: {
+        0: ValidityProof | null;
     };
+    compressedAccounts: any[];
+    systemAccountsOffset: number;
+    remainingAccounts: AccountMeta[];
 }
 /**
- * Get the light protocol system accounts for the small variant.
- * This matches CpiAccountsSmall ordering: removes NoopProgram and InvokingProgram.
- */
-declare function getLightSystemAccountMetasSmall(config: SystemAccountMetaConfig): AccountMeta[];
-/**
- * Creates a PackedAccountsSmall instance with system accounts for the specified program.
- * This uses the simplified account ordering that matches CpiAccountsSmall.
- */
-declare function createPackedAccountsSmall(programId: PublicKey): PackedAccountsSmall;
-/**
- * Creates a PackedAccountsSmall instance with system accounts and CPI context.
+ * Pack accounts and proof for decompressAccountsIdempotent instruction.
+ * This function prepares compressed account data, validity proof, and remaining accounts
+ * for idempotent decompression operations.
+ *
+ * @param programId - The program ID
+ * @param proof - The validity proof with context
+ * @param accountsData - Array of account data with tree info
+ * @param addresses - Array of account addresses
+ * @returns Packed instruction parameters
  */
-declare function createPackedAccountsSmallWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccountsSmall;
-declare class SystemAccountPubkeys {
-    lightSystemProgram: PublicKey;
-    systemProgram: PublicKey;
-    accountCompressionProgram: PublicKey;
-    accountCompressionAuthority: PublicKey;
-    registeredProgramPda: PublicKey;
-    noopProgram: PublicKey;
-    solPoolPda: PublicKey;
-    private constructor();
-    static default(): SystemAccountPubkeys;
-}
+declare function packDecompressAccountsIdempotent(programId: PublicKey, proof: {
+    compressedProof: ValidityProof | null;
+    treeInfos: TreeInfo[];
+}, accountsData: AccountDataWithTreeInfo[], addresses: PublicKey[]): Promise<PackedDecompressResult>;
 
 declare enum TreeType {
     /**
@@ -790,7 +728,7 @@ interface CompressedAccountLegacy {
     /**
      * Optional data attached to the account.
      */
-    data: CompressedAccountData$1 | null;
+    data: CompressedAccountData | null;
 }
 /**
  * @deprecated Use {@link CompressedAccountMeta} instead.
@@ -824,7 +762,7 @@ type NewAddressProofInput = {
 /**
  * Describes compressed account data.
  */
-interface CompressedAccountData$1 {
+interface CompressedAccountData {
     /**
      * 8 bytes.
      */
@@ -1119,7 +1057,7 @@ type CompressedAccount = {
     /**
      * Optional data attached to the account.
      */
-    data: CompressedAccountData$1 | null;
+    data: CompressedAccountData | null;
 } & MerkleContext & {
     /**
      * Read only.
@@ -1281,11 +1219,11 @@ interface PackedCompressedAccountWithMerkleContext {
 /**
  * @deprecated use {@link createCompressedAccountMeta} instead.
  */
-declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData$1, address?: number[]) => CompressedAccountLegacy;
+declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountLegacy;
 /**
  * @deprecated.
  */
-declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData$1, address?: number[]) => CompressedAccountWithMerkleContext;
+declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
 /**
  * @deprecated use {@link createCompressedAccountMeta} instead.
  */
@@ -1372,6 +1310,14 @@ interface AddressWithTreeInfo {
     address: BN254;
     treeInfo: AddressTreeInfo;
 }
+interface AddressWithTreeInfoV2 {
+    address: Uint8Array;
+    treeInfo: TreeInfo;
+}
+declare enum DerivationMode {
+    compressible = "compressible",
+    standard = "standard"
+}
 interface CompressedTransaction {
     compressionInfo: {
         closedAccounts: {
@@ -2584,21 +2530,21 @@ declare const HealthResult: Struct<string, null>;
  */
 declare const LatestNonVotingSignaturesResult: Struct<{
     items: {
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }[];
 }, {
     items: Struct<{
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }[], Struct<{
+        signature: string;
         error: string | null;
         slot: number;
-        signature: string;
         blockTime: number;
     }, {
         signature: Struct<string, null>;
@@ -2612,19 +2558,19 @@ declare const LatestNonVotingSignaturesResult: Struct<{
  */
 declare const LatestNonVotingSignaturesResultPaginated: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         signature: Struct<string, null>;
@@ -2639,10 +2585,10 @@ declare const LatestNonVotingSignaturesResultPaginated: Struct<{
 declare const MerkleProofResult: Struct<{
     proof: BN[];
     leafIndex: number;
+    root: BN;
     hash: BN;
     merkleTree: PublicKey;
     rootSeq: number;
-    root: BN;
 }, {
     hash: Struct<BN, null>;
     leafIndex: Struct<number, null>;
@@ -2658,9 +2604,9 @@ declare const MerkleProofResultV2: Struct<{
     proof: BN[];
     leafIndex: number;
     proveByIndex: boolean;
+    root: BN;
     hash: BN;
     rootSeq: number;
-    root: BN;
     treeContext: {
         cpiContext: PublicKey | null;
         tree: PublicKey;
@@ -2715,9 +2661,9 @@ declare const MerkleProofResultV2: Struct<{
 declare const NewAddressProofResult: Struct<{
     proof: BN[];
     address: BN;
+    root: BN;
     merkleTree: PublicKey;
     rootSeq: number;
-    root: BN;
     nextIndex: number;
     lowerRangeAddress: BN;
     higherRangeAddress: BN;
@@ -2797,8 +2743,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        hash: BN;
         root: BN;
+        hash: BN;
     }[];
     addresses: {
         address: BN;
@@ -2845,8 +2791,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        hash: BN;
         root: BN;
+        hash: BN;
     }[], Struct<{
         merkleContext: {
             cpiContext: PublicKey | null;
@@ -2865,8 +2811,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        hash: BN;
         root: BN;
+        hash: BN;
     }, {
         hash: Struct<BN, null>;
         root: Struct<BN, null>;
@@ -2979,17 +2925,17 @@ declare const ValidityProofResultV2: Struct<{
 declare const MultipleMerkleProofsResult: Struct<{
     proof: BN[];
     leafIndex: number;
+    root: BN;
     hash: BN;
     merkleTree: PublicKey;
     rootSeq: number;
-    root: BN;
 }[], Struct<{
     proof: BN[];
     leafIndex: number;
+    root: BN;
     hash: BN;
     merkleTree: PublicKey;
     rootSeq: number;
-    root: BN;
 }, {
     hash: Struct<BN, null>;
     leafIndex: Struct<number, null>;
@@ -3005,9 +2951,9 @@ declare const MultipleMerkleProofsResultV2: Struct<{
     proof: BN[];
     leafIndex: number;
     proveByIndex: boolean;
+    root: BN;
     hash: BN;
     rootSeq: number;
-    root: BN;
     treeContext: {
         cpiContext: PublicKey | null;
         tree: PublicKey;
@@ -3024,9 +2970,9 @@ declare const MultipleMerkleProofsResultV2: Struct<{
     proof: BN[];
     leafIndex: number;
     proveByIndex: boolean;
+    root: BN;
     hash: BN;
     rootSeq: number;
-    root: BN;
     treeContext: {
         cpiContext: PublicKey | null;
         tree: PublicKey;
@@ -3150,8 +3096,8 @@ declare const CompressedMintTokenHoldersResult: Struct<{
 }>;
 declare const AccountProofResult: Struct<{
     proof: number[][];
-    hash: number[];
     root: number[];
+    hash: number[];
 }, {
     hash: Struct<number[], Struct<number, null>>;
     root: Struct<number[], Struct<number, null>>;
@@ -3160,18 +3106,18 @@ declare const AccountProofResult: Struct<{
 declare const toUnixTimestamp: (blockTime: string) => number;
 declare const SignatureListResult: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -3181,19 +3127,19 @@ declare const SignatureListResult: Struct<{
 }>;
 declare const SignatureListWithCursorResult: Struct<{
     items: {
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }[], Struct<{
-        slot: number;
         signature: string;
+        slot: number;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -4050,6 +3996,15 @@ interface CompressionApiInterface {
     getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
     getIndexerHealth(): Promise<string>;
     getIndexerSlot(): Promise<number>;
+    getAccountInfoInterface(address: PublicKey, programId: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig, addressSpace?: TreeInfo): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        isCold: boolean;
+        loadContext?: MerkleContext;
+    } | null>;
+    getSignaturesForAddressInterface(address: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    getSignaturesForOwnerInterface(owner: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    getTokenAccountBalanceInterface(address: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment): Promise<UnifiedTokenBalance>;
+    getBalanceInterface(address: PublicKey, commitment?: Commitment): Promise<UnifiedBalance>;
 }
 type RpcResultSuccess<T> = {
     jsonrpc: '2.0';
@@ -4066,6 +4021,83 @@ type RpcResultError = {
     };
 };
 type RpcResult<T> = RpcResultSuccess<T> | RpcResultError;
+/**
+ * Source type for signature data.
+ */
+declare const SignatureSource: {
+    /** From standard Solana RPC (getSignaturesForAddress) */
+    readonly Solana: "solana";
+    /** From compression indexer (getCompressionSignaturesFor*) */
+    readonly Compressed: "compressed";
+};
+type SignatureSourceType = (typeof SignatureSource)[keyof typeof SignatureSource];
+/**
+ * Unified signature info combining data from both Solana RPC and compression indexer.
+ *
+ * Design rationale:
+ * - `sources` array indicates where this signature was found (can be both!)
+ * - Primary data comes from Solana RPC when available (richer: err, memo, confirmationStatus)
+ * - Compression-only signatures still included for complete transaction history
+ */
+interface UnifiedSignatureInfo {
+    /** Transaction signature (base58) */
+    signature: string;
+    /** Slot when the transaction was processed */
+    slot: number;
+    /** Block time (unix timestamp), null if not available */
+    blockTime: number | null;
+    /** Transaction error, null if successful. Only from Solana RPC. */
+    err: any | null;
+    /** Memo data. Only from Solana RPC. */
+    memo: string | null;
+    /** Confirmation status. Only from Solana RPC. */
+    confirmationStatus?: string;
+    /**
+     * Sources where this signature was found.
+     * - ['solana'] = only in Solana RPC
+     * - ['compressed'] = only in compression indexer
+     * - ['solana', 'compressed'] = found in both (compression tx indexed by both)
+     */
+    sources: SignatureSourceType[];
+}
+/**
+ * Result of getSignaturesForAddressInterface / getSignaturesForOwnerInterface.
+ *
+ * Design rationale:
+ * - `signatures`: Unified view, merged and deduplicated, sorted by slot desc
+ * - `solana` / `compressed`: Raw responses preserved for clients that need source-specific data
+ * - Allows callers to use the unified view OR drill into specific sources
+ */
+interface SignaturesForAddressInterfaceResult {
+    /** Merged signatures from all sources, sorted by slot (descending) */
+    signatures: UnifiedSignatureInfo[];
+    /** Raw signatures from Solana RPC */
+    solana: ConfirmedSignatureInfo[];
+    /** Raw signatures from compression indexer */
+    compressed: SignatureWithMetadata[];
+}
+/**
+ * Unified token balance combining hot and cold token balances.
+ */
+interface UnifiedTokenBalance {
+    /** Total balance (hot + cold) */
+    amount: BN;
+    /** True if any cold balance exists - call load() before usage */
+    hasColdBalance: boolean;
+    /** Token decimals (from on-chain mint or 0 if unknown) */
+    decimals: number;
+    /** Raw Solana RPC TokenAmount response, null if no on-chain account */
+    solana: TokenAmount | null;
+}
+/**
+ * Unified SOL balance combining hot and cold SOL balances.
+ */
+interface UnifiedBalance {
+    /** Total balance (hot + cold) in lamports */
+    total: BN;
+    /** True if any cold balance exists - call load() before usage */
+    hasColdBalance: boolean;
+}
 
 interface TestRpcConfig {
     /**
@@ -4145,6 +4177,10 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      */
     getStateTreeInfos(): Promise<TreeInfo[]>;
     doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -4294,10 +4330,12 @@ declare class TestRpc extends Connection implements CompressionApiInterface {
      */
     getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
-    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: TestRpc): Promise<{
-        accountInfo: AccountInfo<Buffer>;
-        merkleContext?: MerkleContext;
-    } | null>;
+    getValidityProofV2(accountMerkleContexts?: any[], newAddresses?: any[], derivationMode?: any): Promise<ValidityProofWithContext>;
+    getAccountInfoInterface(_address: PublicKey, _programId: PublicKey, _addressSpaceInfo: any): Promise<any>;
+    getSignaturesForAddressInterface(_address: PublicKey, _options?: any, _compressedOptions?: PaginatedOptions): Promise<any>;
+    getSignaturesForOwnerInterface(_owner: PublicKey, _options?: any, _compressedOptions?: PaginatedOptions): Promise<any>;
+    getTokenAccountBalanceInterface(_address: PublicKey, _owner: PublicKey, _mint: PublicKey, _commitment?: any): Promise<any>;
+    getBalanceInterface(_address: PublicKey, _commitment?: any): Promise<any>;
 }
 
 declare class IndexedElement {
@@ -4495,7 +4533,6 @@ type TokenData = {
     state: number;
     tlv: Buffer | null;
 };
-declare const TokenDataLayout: Layout<TokenData>;
 type EventWithParsedTokenTlvData = {
     inputCompressedAccountHashes: number[][];
     outputCompressedAccounts: ParsedTokenAccount[];
@@ -4618,6 +4655,12 @@ interface NullifierMetadata {
     nullifier: BN254;
     txHash: BN254;
 }
+/**
+ * Merge signatures from Solana RPC and compression indexer.
+ * Deduplicates by signature, tracking sources in the `sources` array.
+ * When a signature exists in both, uses Solana data (richer) but marks both sources.
+ */
+declare function mergeSignatures(solanaSignatures: ConfirmedSignatureInfo[], compressedSignatures: SignatureWithMetadata[]): UnifiedSignatureInfo[];
 /**
  *
  */
@@ -4646,6 +4689,10 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @internal
      */
     doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -4806,6 +4853,17 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns             validity proof with context
      */
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    /**
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account Merkle contexts, and (2) new unique addresses specified by
+     * an array of address objects with tree info.
+     *
+     * Validity proofs prove the presence of compressed accounts in state trees
+     * and the non-existence of addresses in address trees, respectively. They
+     * enable verification without recomputing the merkle proof path, thus
+     * lowering verification and data costs.
+     */
+    getValidityProofV2(accountMerkleContexts?: (MerkleContext | undefined)[], newAddresses?: AddressWithTreeInfoV2[], derivationMode?: DerivationMode): Promise<ValidityProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -4824,19 +4882,64 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      */
     getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     /**
-     * Get account info from either compressed or onchain storage.
-     * @param address         The account address to fetch.
-     * @param programId       The owner program ID.
-     * @param addressTreeInfo The address tree info used to store the account.
-     * @param rpc             The RPC client to use.
+     * Fetch the account info for the specified public key. Returns metadata
+     * to load in case the account is cold.
+     * @param address               The account address to fetch.
+     * @param programId             The owner program ID.
+     * @param commitmentOrConfig    Optional. The commitment or config to use
+     *                              for the onchain account fetch.
+     * @param addressSpace          Optional. The address space info that was
+     *                              used at init.
      *
-     * @returns               Account info with compression info, or null if account
-     *                        doesn't exist.
-     */
-    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: Rpc): Promise<{
+     * @returns                     Account info with load info, or null if
+     *                              account doesn't exist. LoadContext is always
+     *                              some if the account is compressible. isCold
+     *                              indicates the current state of the account,
+     *                              if true the account must referenced in a
+     *                              load instruction before use.
+     */
+    getAccountInfoInterface(address: PublicKey, programId: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig, addressSpace?: TreeInfo): Promise<{
         accountInfo: AccountInfo<Buffer$1>;
-        merkleContext?: MerkleContext;
+        isCold: boolean;
+        loadContext?: MerkleContext;
     } | null>;
+    /**
+     * Get signatures for an address from both Solana and compression indexer.
+     *
+     * @param address               Address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForAddress call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForAddressInterface(address: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get signatures for an owner from both Solana and compression indexer.
+     *
+     * @param owner                 Owner address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForOwner call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForOwnerInterface(owner: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get token account balance for an address, regardless of whether the token
+     * account is hot or cold.
+     *
+     * @param address       Token account address.
+     * @param owner         Owner public key.
+     * @param mint          Mint public key.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified token balance from both sources.
+     */
+    getTokenAccountBalanceInterface(address: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment): Promise<UnifiedTokenBalance>;
+    /**
+     * Get SOL balance for an address, regardless of whether the account is hot or cold.
+     *
+     * @param address       Address to fetch balance for.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified SOL balance.
+     */
+    getBalanceInterface(address: PublicKey, commitment?: Commitment): Promise<UnifiedBalance>;
 }
 
 /**
@@ -6011,8 +6114,15 @@ declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): numb
  */
 declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
 declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
+interface PackedStateTreeInfos {
+    packedTreeInfos: PackedStateTreeInfo[];
+    outputTreeIndex: number;
+}
+interface PackedTreeInfos {
+    stateTrees?: PackedStateTreeInfos;
+    addressTrees: PackedAddressTreeInfo[];
+}
 /**
- * @deprecated Use {@link packTreeInfos} instead.
  * Packs TreeInfos. Replaces PublicKey with index pointer to remaining accounts.
  *
  * Only use for MUT, CLOSE, NEW_ADDRESSES. For INIT, pass
@@ -6028,7 +6138,7 @@ declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
  * @returns Remaining accounts, packed state and address tree infos, state tree
  * output index and address tree infos.
  */
-declare function packTreeInfosWithPubkeys(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
+declare function packTreeInfos(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
 /**
  * Packs Compressed Accounts.
  *
@@ -6052,80 +6162,6 @@ declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccou
     packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     remainingAccounts: PublicKey[];
 };
-/**
- * Root index for state tree proofs.
- */
-type RootIndex = {
-    proofByIndex: boolean;
-    rootIndex: number;
-};
-/**
- * Creates a RootIndex for proving by merkle proof.
- */
-declare function createRootIndex(rootIndex: number): RootIndex;
-/**
- * Creates a RootIndex for proving by leaf index.
- */
-declare function createRootIndexByIndex(): RootIndex;
-/**
- * Account proof inputs for state tree accounts.
- */
-type AccountProofInputs = {
-    hash: Uint8Array;
-    root: Uint8Array;
-    rootIndex: RootIndex;
-    leafIndex: number;
-    treeInfo: TreeInfo;
-};
-/**
- * Address proof inputs for address tree accounts.
- */
-type AddressProofInputs = {
-    address: Uint8Array;
-    root: Uint8Array;
-    rootIndex: number;
-    treeInfo: TreeInfo;
-};
-/**
- * Validity proof with context structure that matches Rust implementation.
- */
-type ValidityProofWithContextV2 = {
-    proof: ValidityProof | null;
-    accounts: AccountProofInputs[];
-    addresses: AddressProofInputs[];
-};
-/**
- * Packed state tree infos.
- */
-type PackedStateTreeInfos = {
-    packedTreeInfos: PackedStateTreeInfo[];
-    outputTreeIndex: number;
-};
-/**
- * Packed tree infos containing both state and address trees.
- */
-type PackedTreeInfos = {
-    stateTrees: PackedStateTreeInfos | null;
-    addressTrees: PackedAddressTreeInfo[];
-};
-/**
- * Packs tree infos from ValidityProofWithContext into packed format. This is a
- * TypeScript equivalent of the Rust pack_tree_infos method.
- *
- * @param validityProof - The validity proof with context (flat format)
- * @param packedAccounts - The packed accounts manager (supports both PackedAccounts and PackedAccountsSmall)
- * @returns Packed tree infos
- */
-declare function packTreeInfos(validityProof: ValidityProofWithContext, packedAccounts: PackedAccounts | PackedAccountsSmall): PackedTreeInfos;
-/**
- * Packs tree infos from ValidityProofWithContextV2 into packed format. This is
- * a TypeScript equivalent of the Rust pack_tree_infos method.
- *
- * @param validityProof - The validity proof with context (structured format)
- * @param packedAccounts - The packed accounts manager (supports both PackedAccounts and PackedAccountsSmall)
- * @returns Packed tree infos
- */
-declare function packTreeInfos(validityProof: ValidityProofWithContextV2, packedAccounts: PackedAccounts | PackedAccountsSmall): PackedTreeInfos;
 
 declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
 /**
@@ -6381,361 +6417,4 @@ declare class MerkleTreeError extends MetaError {
 declare class UtilsError extends MetaError {
 }
 
-/**
- * Standard instruction discriminators for compressible instructions
- * These match the Rust implementation discriminators
- */
-declare const COMPRESSIBLE_DISCRIMINATORS: {
-    readonly INITIALIZE_COMPRESSION_CONFIG: readonly [133, 228, 12, 169, 56, 76, 222, 61];
-    readonly UPDATE_COMPRESSION_CONFIG: readonly [135, 215, 243, 81, 163, 146, 33, 70];
-    readonly DECOMPRESS_ACCOUNTS_IDEMPOTENT: readonly [114, 67, 61, 123, 234, 31, 1, 112];
-};
-/**
- * Generic compressed account data structure for decompress operations
- * This is generic over the account variant type, allowing programs to use their specific enums
- */
-type CompressedAccountData<T = any> = {
-    /** The compressed account metadata containing tree info, address, and output index */
-    meta: CompressedAccountMeta;
-    /** Program-specific account variant enum */
-    data: T;
-    /** PDA seeds (without bump) used to derive the PDA address */
-    seeds: Uint8Array[];
-};
-/**
- * Instruction data structure for decompress_accounts_idempotent
- * This matches the exact format expected by Anchor programs
- */
-type DecompressMultipleAccountsIdempotentData<T = any> = {
-    proof: ValidityProof;
-    compressedAccounts: CompressedAccountData<T>[];
-    bumps: number[];
-    systemAccountsOffset: number;
-};
-/**
- * Instruction data for update compression config
- */
-type UpdateCompressionConfigData = {
-    newCompressionDelay: number | null;
-    newRentRecipient: PublicKey | null;
-    newAddressSpace: PublicKey[] | null;
-    newUpdateAuthority: PublicKey | null;
-};
-/**
- * Generic instruction data for compress account
- * This matches the expected format for compress account instructions
- */
-type GenericCompressAccountInstruction = {
-    proof: ValidityProof;
-    compressedAccountMeta: CompressedAccountMeta;
-};
-
-/**
- * Borsh schema for updateCompressionConfig instruction data
- */
-declare const UpdateCompressionConfigSchema: borsh.Layout<UpdateCompressionConfigData>;
-/**
- * Borsh schema for ValidityProof
- */
-declare const ValidityProofSchema: borsh.Layout<ValidityProof>;
-/**
- * Borsh schema for PackedStateTreeInfo
- */
-declare const PackedStateTreeInfoSchema: borsh.Layout<PackedStateTreeInfo>;
-/**
- * Borsh schema for CompressedAccountMeta
- */
-declare const CompressedAccountMetaSchema: borsh.Layout<CompressedAccountMeta>;
-/**
- * Borsh schema for GenericCompressAccountInstruction
- */
-declare const GenericCompressAccountInstructionSchema: borsh.Layout<GenericCompressAccountInstruction>;
-/**
- * Helper function to create borsh schema for CompressedAccountData
- * This is generic to work with any data type T
- */
-declare function createCompressedAccountDataSchema<T>(dataSchema: borsh.Layout<T>): borsh.Layout<CompressedAccountData<T>>;
-/**
- * Helper function to create borsh schema for DecompressMultipleAccountsIdempotentData
- * This is generic to work with any data type T
- */
-declare function createDecompressMultipleAccountsIdempotentDataSchema<T>(dataSchema: borsh.Layout<T>): borsh.Layout<DecompressMultipleAccountsIdempotentData<T>>;
-/**
- * Serialize instruction data with custom discriminator
- */
-declare function serializeInstructionData<T>(schema: borsh.Layout<T>, data: T, discriminator: Uint8Array | number[]): Buffer;
-/**
- * Serialize instruction data for initializeCompressionConfig using Borsh
- */
-declare function serializeInitializeCompressionConfigData(compressionDelay: number, rentRecipient: _solana_web3_js.PublicKey, addressSpace: _solana_web3_js.PublicKey[], configBump: number | null): Buffer;
-
-/**
- * Create an instruction to initialize a compression config.
- *
- * @param programId         Program ID for the compressible program
- * @param discriminator     Instruction discriminator (8 bytes)
- * @param payer             Fee payer
- * @param authority         Program upgrade authority
- * @param compressionDelay  Compression delay (in slots)
- * @param rentRecipient     Rent recipient public key
- * @param addressSpace      Array of address space public keys
- * @param configBump        Optional config bump (defaults to 0)
- * @returns                 TransactionInstruction
- */
-declare function createInitializeCompressionConfigInstruction(programId: PublicKey, discriminator: Uint8Array | number[], payer: PublicKey, authority: PublicKey, compressionDelay: number, rentRecipient: PublicKey, addressSpace: PublicKey[], configBump?: number | null): TransactionInstruction;
-/**
- * Create an instruction to update a compression config.
- *
- * @param programId             Program ID for the compressible program
- * @param discriminator         Instruction discriminator (8 bytes)
- * @param authority             Current config authority
- * @param newCompressionDelay   Optional new compression delay
- * @param newRentRecipient      Optional new rent recipient
- * @param newAddressSpace       Optional new address space array
- * @param newUpdateAuthority    Optional new update authority
- * @returns                     TransactionInstruction
- */
-declare function createUpdateCompressionConfigInstruction(programId: PublicKey, discriminator: Uint8Array | number[], authority: PublicKey, newCompressionDelay?: number | null, newRentRecipient?: PublicKey | null, newAddressSpace?: PublicKey[] | null, newUpdateAuthority?: PublicKey | null): TransactionInstruction;
-/**
- * Create an instruction to compress a generic compressible account.
- *
- * @param programId             Program ID for the compressible program
- * @param discriminator         Instruction discriminator (8 bytes)
- * @param payer                 Fee payer
- * @param pdaToCompress         PDA to compress
- * @param rentRecipient         Rent recipient public key
- * @param compressedAccountMeta Compressed account metadata
- * @param validityProof         Validity proof for compression
- * @param systemAccounts        Additional system accounts (optional)
- * @returns                     TransactionInstruction
- */
-declare function createCompressAccountInstruction(programId: PublicKey, discriminator: Uint8Array | number[], payer: PublicKey, pdaToCompress: PublicKey, rentRecipient: PublicKey, compressedAccountMeta: CompressedAccountMeta, validityProof: ValidityProof, systemAccounts?: AccountMeta[]): TransactionInstruction;
-/**
- * Create an instruction to decompress one or more compressed accounts idempotently.
- *
- * @param programId                 Program ID for the compressible program
- * @param discriminator             Instruction discriminator (8 bytes)
- * @param feePayer                  Fee payer
- * @param rentPayer                 Rent payer
- * @param solanaAccounts            Array of PDA accounts to decompress
- * @param compressedAccountsData    Array of compressed account data
- * @param bumps                     Array of PDA bumps
- * @param validityProof             Validity proof for decompression
- * @param systemAccounts            Additional system accounts (optional)
- * @param coder                Borsh schema for account data
- * @returns                         TransactionInstruction
- */
-declare function createDecompressAccountsIdempotentInstruction<T = any>(programId: PublicKey, discriminator: Uint8Array | number[], feePayer: PublicKey, rentPayer: PublicKey, solanaAccounts: PublicKey[], compressedAccountsData: CompressedAccountData<T>[], bumps: number[], validityProof: ValidityProof, systemAccounts: AccountMeta[] | undefined, coder: (data: any) => Buffer): TransactionInstruction;
-/**
- * Instruction builders for compressible accounts, following Solana SDK patterns.
- */
-declare class CompressibleInstruction {
-    /**
-     * Create an instruction to initialize a compression config.
-     *
-     * @param programId         Program ID for the compressible program
-     * @param discriminator     Instruction discriminator (8 bytes)
-     * @param payer             Fee payer
-     * @param authority         Program upgrade authority
-     * @param compressionDelay  Compression delay (in slots)
-     * @param rentRecipient     Rent recipient public key
-     * @param addressSpace      Array of address space public keys
-     * @param configBump        Optional config bump (defaults to 0)
-     * @returns                 TransactionInstruction
-     */
-    static initializeCompressionConfig(programId: PublicKey, discriminator: Uint8Array | number[], payer: PublicKey, authority: PublicKey, compressionDelay: number, rentRecipient: PublicKey, addressSpace: PublicKey[], configBump?: number | null): TransactionInstruction;
-    /**
-     * Create an instruction to update a compression config.
-     *
-     * @param programId             Program ID for the compressible program
-     * @param discriminator         Instruction discriminator (8 bytes)
-     * @param authority             Current config authority
-     * @param newCompressionDelay   Optional new compression delay
-     * @param newRentRecipient      Optional new rent recipient
-     * @param newAddressSpace       Optional new address space array
-     * @param newUpdateAuthority    Optional new update authority
-     * @returns                     TransactionInstruction
-     */
-    static updateCompressionConfig(programId: PublicKey, discriminator: Uint8Array | number[], authority: PublicKey, newCompressionDelay?: number | null, newRentRecipient?: PublicKey | null, newAddressSpace?: PublicKey[] | null, newUpdateAuthority?: PublicKey | null): TransactionInstruction;
-    /**
-     * Create an instruction to compress a generic compressible account.
-     *
-     * @param programId             Program ID for the compressible program
-     * @param discriminator         Instruction discriminator (8 bytes)
-     * @param payer                 Fee payer
-     * @param pdaToCompress         PDA to compress
-     * @param rentRecipient         Rent recipient public key
-     * @param compressedAccountMeta Compressed account metadata
-     * @param validityProof         Validity proof for compression
-     * @param systemAccounts        Additional system accounts (optional)
-     * @returns                     TransactionInstruction
-     */
-    static compressAccount(programId: PublicKey, discriminator: Uint8Array | number[], payer: PublicKey, pdaToCompress: PublicKey, rentRecipient: PublicKey, compressedAccountMeta: CompressedAccountMeta, validityProof: ValidityProof, systemAccounts?: AccountMeta[]): TransactionInstruction;
-    /**
-     * Create an instruction to decompress one or more compressed accounts idempotently.
-     *
-     * @param programId                 Program ID for the compressible program
-     * @param discriminator             Instruction discriminator (8 bytes)
-     * @param feePayer                  Fee payer
-     * @param rentPayer                 Rent payer
-     * @param solanaAccounts            Array of PDA accounts to decompress
-     * @param compressedAccountsData    Array of compressed account data
-     * @param bumps                     Array of PDA bumps
-     * @param validityProof             Validity proof for decompression
-     * @param systemAccounts            Additional system accounts (optional)
-     * @param dataSchema                Borsh schema for account data
-     * @returns                         TransactionInstruction
-     */
-    static decompressAccountsIdempotent<T = any>(programId: PublicKey, discriminator: Uint8Array | number[], feePayer: PublicKey, rentPayer: PublicKey, solanaAccounts: PublicKey[], compressedAccountsData: CompressedAccountData<T>[], bumps: number[], validityProof: ValidityProof, systemAccounts?: AccountMeta[], dataSchema?: any): TransactionInstruction;
-    /**
-     * Standard instruction discriminators for compressible instructions
-     */
-    static readonly DISCRIMINATORS: {
-        readonly INITIALIZE_COMPRESSION_CONFIG: readonly [133, 228, 12, 169, 56, 76, 222, 61];
-        readonly UPDATE_COMPRESSION_CONFIG: readonly [135, 215, 243, 81, 163, 146, 33, 70];
-        readonly DECOMPRESS_ACCOUNTS_IDEMPOTENT: readonly [114, 67, 61, 123, 234, 31, 1, 112];
-    };
-    /**
-     * Derive the compression config PDA address
-     *
-     * @param programId     Program ID for the compressible program
-     * @param configIndex   Config index (defaults to 0)
-     * @returns             [PDA address, bump seed]
-     */
-    static deriveCompressionConfigAddress(programId: PublicKey, configIndex?: number): [PublicKey, number];
-    /**
-     * Get the program data account address and its raw data for a given program
-     *
-     * @param programId     Program ID
-     * @param connection    Solana connection
-     * @returns             Program data address and account info
-     */
-    static getProgramDataAccount(programId: PublicKey, connection: _solana_web3_js.Connection): Promise<{
-        programDataAddress: PublicKey;
-        programDataAccountInfo: _solana_web3_js.AccountInfo<Buffer>;
-    }>;
-    /**
-     * Check that the provided authority matches the program's upgrade authority
-     *
-     * @param programDataAccountInfo    Program data account info
-     * @param providedAuthority         Authority to validate
-     * @throws                          Error if authority doesn't match
-     */
-    static checkProgramUpdateAuthority(programDataAccountInfo: _solana_web3_js.AccountInfo<Buffer>, providedAuthority: PublicKey): void;
-    /**
-     * Serialize instruction data for initializeCompressionConfig using Borsh
-     *
-     * @param compressionDelay  Compression delay (in slots)
-     * @param rentRecipient     Rent recipient public key
-     * @param addressSpace      Array of address space public keys
-     * @param configBump        Optional config bump
-     * @returns                 Serialized instruction data with discriminator
-     */
-    static serializeInitializeCompressionConfigData(compressionDelay: number, rentRecipient: PublicKey, addressSpace: PublicKey[], configBump: number | null): Buffer;
-    /**
-     * Convert a compressed account to the format expected by instruction builders
-     *
-     * @param compressedAccount     Compressed account from state
-     * @param data                  Program-specific account data
-     * @param seeds                 PDA seeds (without bump)
-     * @param outputStateTreeIndex  Output state tree index
-     * @returns                     Compressed account data for instructions
-     */
-    static createCompressedAccountData<T>(compressedAccount: CompressedAccount, data: T, seeds: Uint8Array[], outputStateTreeIndex: number): CompressedAccountData<T>;
-}
-
-/**
- * Initialize a compression config for a compressible program
- *
- * @param rpc                   RPC connection to use
- * @param payer                 Fee payer
- * @param programId             Program ID for the compressible program
- * @param authority             Program upgrade authority
- * @param compressionDelay      Compression delay (in slots)
- * @param rentRecipient         Rent recipient public key
- * @param addressSpace          Array of address space public keys
- * @param configBump            Optional config bump (defaults to 0)
- * @param discriminator         Optional custom discriminator (defaults to standard)
- * @param confirmOptions        Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-declare function initializeCompressionConfig(rpc: Rpc, payer: Signer, programId: PublicKey, authority: Signer, compressionDelay: number, rentRecipient: PublicKey, addressSpace: PublicKey[], configBump?: number | null, discriminator?: Uint8Array | number[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-/**
- * Update a compression config for a compressible program
- *
- * @param rpc                   RPC connection to use
- * @param payer                 Fee payer
- * @param programId             Program ID for the compressible program
- * @param authority             Current config authority
- * @param newCompressionDelay   Optional new compression delay
- * @param newRentRecipient      Optional new rent recipient
- * @param newAddressSpace       Optional new address space array
- * @param newUpdateAuthority    Optional new update authority
- * @param discriminator         Optional custom discriminator (defaults to standard)
- * @param confirmOptions        Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-declare function updateCompressionConfig(rpc: Rpc, payer: Signer, programId: PublicKey, authority: Signer, newCompressionDelay?: number | null, newRentRecipient?: PublicKey | null, newAddressSpace?: PublicKey[] | null, newUpdateAuthority?: PublicKey | null, discriminator?: Uint8Array | number[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-/**
- * Compress a generic compressible account
- *
- * @param rpc                   RPC connection to use
- * @param payer                 Fee payer and signer
- * @param programId             Program ID for the compressible program
- * @param pdaToCompress         PDA to compress
- * @param rentRecipient         Rent recipient public key
- * @param compressedAccountMeta Compressed account metadata
- * @param validityProof         Validity proof for compression
- * @param systemAccounts        Additional system accounts (trees, queues, etc.)
- * @param discriminator         Custom instruction discriminator (8 bytes)
- * @param confirmOptions        Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-declare function compressAccount(rpc: Rpc, payer: Signer, programId: PublicKey, pdaToCompress: PublicKey, rentRecipient: PublicKey, compressedAccountMeta: CompressedAccountMeta, validityProof: ValidityProof, systemAccounts: AccountMeta[], discriminator: Uint8Array | number[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-/**
- * Decompress one or more compressed accounts idempotently
- *
- * @param rpc                       RPC connection to use
- * @param payer                     Fee payer
- * @param programId                 Program ID for the compressible program
- * @param feePayer                  Fee payer (can be same as payer)
- * @param rentPayer                 Rent payer
- * @param solanaAccounts            Array of PDA accounts to decompress
- * @param compressedAccountsData    Array of compressed account data
- * @param bumps                     Array of PDA bumps
- * @param validityProof             Validity proof for decompression
- * @param systemAccounts            Additional system accounts (trees, queues, etc.)
- * @param dataSchema                Borsh schema for account data serialization
- * @param discriminator             Optional custom discriminator (defaults to standard)
- * @param confirmOptions            Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-declare function decompressAccountsIdempotent<T = any>(rpc: Rpc, payer: Signer, programId: PublicKey, feePayer: Signer, rentPayer: Signer, solanaAccounts: PublicKey[], compressedAccountsData: CompressedAccountData<T>[], bumps: number[], validityProof: ValidityProof, systemAccounts: AccountMeta[], dataSchema: any, // borsh.Layout<T>
-discriminator?: Uint8Array | number[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
-/**
- * Derive the compression config PDA address
- */
-declare function deriveCompressionConfigAddress(programId: PublicKey, configIndex?: number): [PublicKey, number];
-/**
- * Get the program data account address and its raw data for a given program.
- */
-declare function getProgramDataAccount(programId: PublicKey, connection: Connection): Promise<{
-    programDataAddress: PublicKey;
-    programDataAccountInfo: AccountInfo<Buffer>;
-}>;
-/**
- * Check that the provided authority matches the program's upgrade authority.
- */
-declare function checkProgramUpdateAuthority(programDataAccountInfo: AccountInfo<Buffer>, providedAuthority: PublicKey): void;
-
-/**
- * Convert a compressed account to the format expected by instruction builders
- */
-declare function createCompressedAccountData<T>(compressedAccount: CompressedAccount, data: T, seeds: Uint8Array[], outputStateTreeIndex: number): CompressedAccountData<T>;
-
-export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, type AccountProofInput, type AccountProofInputs, AccountProofResult, type ActiveTreeBundle, type AddressProofInputs, type AddressTreeInfo, type AddressWithTree, type AddressWithTreeInfo, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, COMPRESSED_TOKEN_PROGRAM_ID, COMPRESSIBLE_DISCRIMINATORS, COMPUTE_BUDGET_PATTERN, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData$1 as CompressedAccountData, CompressedAccountLayout, type CompressedAccountLegacy, type CompressedAccountMeta, CompressedAccountMetaSchema, CompressedAccountResult, CompressedAccountResultV2, type CompressedAccountWithMerkleContext, type CompressedAccountWithMerkleContextLegacy, CompressedAccountsByOwnerResult, CompressedAccountsByOwnerResultV2, type CompressedCpiContext, CompressedCpiContextLayout, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, CompressedProofLayout, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountResultV2, CompressedTokenAccountsByOwnerOrDelegateResult, CompressedTokenAccountsByOwnerOrDelegateResultV2, type CompressedTransaction, CompressedTransactionResult, CompressedTransactionResultV2, CompressibleInstruction, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type DecompressMultipleAccountsIdempotentData, type EventWithParsedTokenTlvData, FIELD_SIZE, type GenericCompressAccountInstruction, GenericCompressAccountInstructionSchema, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, type HashWithTreeInfo, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INSERT_INTO_QUEUES_DISCRIMINATOR, INVOKE_CPI_DISCRIMINATOR, INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR, INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR, INVOKE_DISCRIMINATOR, InAccountLayout, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, InsertAddressInputLayout, InsertNullifierInputLayout, type InstructionDataInvoke, type InstructionDataInvokeCpi, InstructionDataInvokeCpiLayout, InstructionDataInvokeCpiWithReadOnlyLayout, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram, type LightSystemProgram$1 as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, type MerkleContext, MerkleContextLayout, type MerkleContextLegacy, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleProofResult, MerkleProofResultV2, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MerkleTreeSequenceNumberLayout, MultipleCompressedAccountsResult, MultipleCompressedAccountsResultV2, MultipleMerkleProofsResult, MultipleMerkleProofsResultV2, NativeBalanceResult, type NewAddressParams, NewAddressParamsAssignedPackedLayout, NewAddressParamsLayout, type NewAddressParamsPacked, type NewAddressProofInput, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type NullifierMetadata, type OutputCompressedAccountWithPackedContext, PackedAccounts, PackedAccountsSmall, type PackedAddressTreeInfo, type PackedCompressedAccountWithMerkleContext, PackedMerkleContextLayout, type PackedMerkleContextLegacy, PackedReadOnlyAddressLayout, PackedReadOnlyCompressedAccountLayout, type PackedStateTreeInfo, PackedStateTreeInfoSchema, type PackedStateTreeInfos, type PackedTreeInfos, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, type RootIndex, RootIndexResultV2, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, type StateTreeInfo, type StateTreeLUTPair, SystemAccountMetaConfig, SystemAccountPubkeys, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, type TreeInfo, TreeType, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, type UpdateCompressionConfigData, UpdateCompressionConfigSchema, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, VERSION, type ValidityProof, ValidityProofResult, ValidityProofResultV2, ValidityProofSchema, type ValidityProofWithContext, type ValidityProofWithContextV2, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, addressTreeV2, airdropSol, batchCpiContext, batchMerkleTree, batchQueue, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkProgramUpdateAuthority, checkValidityProofShape, compress, compressAccount, CompressibleInstruction as compressibleInstruction, confirmConfig, confirmTransaction, confirmTx, convertInvokeCpiWithReadOnlyToInvoke, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, convertToPublicTransactionEvent, cpiContext2Pubkey, cpiContextPubkey, createAccount, createAccountWithLamports, createBN254, createCompressAccountInstruction, createCompressedAccountData, createCompressedAccountDataSchema, createCompressedAccountLegacy, createCompressedAccountMeta, createCompressedAccountWithMerkleContextLegacy, createDecompressAccountsIdempotentInstruction, createDecompressMultipleAccountsIdempotentDataSchema, createInitializeCompressionConfigInstruction, createMerkleContextLegacy, createPackedAccounts, createPackedAccountsSmall, createPackedAccountsSmallWithCpiContext, createPackedAccountsWithCpiContext, createRootIndex, createRootIndexByIndex, createRpc, createRpcResult, createStateTreeLookupTable, createUpdateCompressionConfigInstruction, decodeInstructionDataInvoke, decodeInstructionDataInvokeCpi, decodeInstructionDataInvokeCpiWithReadOnly, decodePublicTransactionEvent, decompress, decompressAccountsIdempotent, dedupeSigner, deepEqual, defaultStateTreeLookupTables, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, defaultTestStateTreeAccounts2, deriveAddress, deriveAddressSeed, deriveAddressV2, deriveCompressionConfigAddress, deserializeAppendNullifyCreateAddressInputsIndexer, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, extendStateTreeLookupTable, featureFlags, getAccountCompressionAuthority, getAllStateTreeInfos, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getDefaultAddressTreeInfo, getIndexOrAdd, getLightSystemAccountMetas, getLightSystemAccountMetasSmall, getParsedEvents, getProgramDataAccount, getPublicInputHash, getRegisteredProgramPda, getStateTreeInfoByPubkey, getTestKeypair, getTestRpc, getTreeInfoByPubkey, hashToBn254FieldSizeBe, hashVWithBumpSeed, hashvToBn254FieldSizeBe, initializeCompressionConfig, invokeAccountsLayout, type invokeAccountsLayoutParams, isLocalTest, isSmallerThanBn254FieldSizeBe, jsonRpcResult, jsonRpcResultAndContext, lightSystemProgram, localTestActiveStateTreeInfos, merkleTree2Pubkey, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifiedStateTreeLookupTableDevnet, nullifiedStateTreeLookupTableMainnet, nullifierQueue2Pubkey, nullifierQueuePubkey, nullifyLookupTable, packCompressedAccounts, packNewAddressParams, packTreeInfos, packTreeInfosWithPubkeys, padOutputStateMerkleTrees, parseAccountData, parseEvents, parseLightTransaction, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pickRandomTreeAndQueue, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, selectStateTreeInfo, sendAndConfirmTx, serializeInitializeCompressionConfigData, serializeInstructionData, sleep, stateTreeLookupTableDevnet, stateTreeLookupTableMainnet, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, updateCompressionConfig, validateNumbers, validateNumbersForInclusionProof, validateNumbersForNonInclusionProof, validateNumbersForProof, validateSameOwner, validateSufficientBalance, versionedEndpoint, wrapBigNumbersAsStrings };
+export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE_V1, ADDRESS_TREE_NETWORK_FEE_V2, ALICE, type AccountDataWithTreeInfo, type AccountProofInput, AccountProofResult, type ActiveTreeBundle, type AddressTreeInfo, type AddressWithTree, type AddressWithTreeInfo, type AddressWithTreeInfoV2, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, COMPRESSED_TOKEN_PROGRAM_ID, COMPUTE_BUDGET_PATTERN, CTOKEN_PROGRAM_ID, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, type CompressedAccountLegacy, type CompressedAccountMeta, CompressedAccountResult, CompressedAccountResultV2, type CompressedAccountWithMerkleContext, type CompressedAccountWithMerkleContextLegacy, CompressedAccountsByOwnerResult, CompressedAccountsByOwnerResultV2, type CompressedCpiContext, CompressedCpiContextLayout, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, CompressedProofLayout, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountResultV2, CompressedTokenAccountsByOwnerOrDelegateResult, CompressedTokenAccountsByOwnerOrDelegateResultV2, type CompressedTransaction, CompressedTransactionResult, CompressedTransactionResultV2, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, DerivationMode, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, type HashWithTreeInfo, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INSERT_INTO_QUEUES_DISCRIMINATOR, INVOKE_CPI_DISCRIMINATOR, INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR, INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR, INVOKE_DISCRIMINATOR, InAccountLayout, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, InsertAddressInputLayout, InsertNullifierInputLayout, type InstructionDataInvoke, type InstructionDataInvokeCpi, InstructionDataInvokeCpiLayout, InstructionDataInvokeCpiWithReadOnlyLayout, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram, type LightSystemProgram$1 as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, type MerkleContext, MerkleContextLayout, type MerkleContextLegacy, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleProofResult, MerkleProofResultV2, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MerkleTreeSequenceNumberLayout, MultipleCompressedAccountsResult, MultipleCompressedAccountsResultV2, MultipleMerkleProofsResult, MultipleMerkleProofsResultV2, NativeBalanceResult, type NewAddressParams, NewAddressParamsAssignedPackedLayout, NewAddressParamsLayout, type NewAddressParamsPacked, type NewAddressProofInput, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type NullifierMetadata, type OutputCompressedAccountWithPackedContext, PackedAccounts, type PackedAddressTreeInfo, type PackedCompressedAccountWithMerkleContext, type PackedDecompressResult, PackedMerkleContextLayout, type PackedMerkleContextLegacy, PackedReadOnlyAddressLayout, PackedReadOnlyCompressedAccountLayout, type PackedStateTreeInfo, type PackedStateTreeInfos, type PackedTreeInfos, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, RootIndexResultV2, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, SignatureSource, type SignatureSourceType, type SignatureWithMetadata, type SignaturesForAddressInterfaceResult, SlotResult, type StateTreeInfo, type StateTreeLUTPair, SystemAccountMetaConfig, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataResult, type TreeInfo, TreeType, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, type UnifiedBalance, type UnifiedSignatureInfo, type UnifiedTokenBalance, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, VERSION, type ValidityProof, ValidityProofResult, ValidityProofResultV2, type ValidityProofWithContext, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, batchAddressTree, batchCpiContext1, batchCpiContext2, batchCpiContext3, batchCpiContext4, batchCpiContext5, batchMerkleTree, batchMerkleTree1, batchMerkleTree2, batchMerkleTree3, batchMerkleTree4, batchMerkleTree5, batchQueue, batchQueue1, batchQueue2, batchQueue3, batchQueue4, batchQueue5, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertInvokeCpiWithReadOnlyToInvoke, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, convertToPublicTransactionEvent, cpiContext2Pubkey, cpiContextPubkey, createAccount, createAccountWithLamports, createBN254, createCompressedAccountLegacy, createCompressedAccountMeta, createCompressedAccountWithMerkleContextLegacy, createMerkleContextLegacy, createRpc, createRpcResult, createStateTreeLookupTable, decodeInstructionDataInvoke, decodeInstructionDataInvokeCpi, decodeInstructionDataInvokeCpiWithReadOnly, decodePublicTransactionEvent, decompress, dedupeSigner, deepEqual, defaultStateTreeLookupTables, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, defaultTestStateTreeAccounts2, deriveAddress, deriveAddressSeed, deriveAddressSeedV2, deriveAddressV2, deserializeAppendNullifyCreateAddressInputsIndexer, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, extendStateTreeLookupTable, featureFlags, getAccountCompressionAuthority, getAllStateTreeInfos, getBatchAddressTreeInfo, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getDefaultAddressSpace, getDefaultAddressTreeInfo, getIndexOrAdd, getLightSystemAccountMetas, getLightSystemAccountMetasV2, getOutputQueue, getOutputTreeInfo, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getStateTreeInfoByPubkey, getTestKeypair, getTestRpc, getTreeInfoByPubkey, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, hashvToBn254FieldSizeBeU8Array, invokeAccountsLayout, type invokeAccountsLayoutParams, isLocalTest, isSmallerThanBn254FieldSizeBe, jsonRpcResult, jsonRpcResultAndContext, lightSystemProgram, localTestActiveStateTreeInfos, mergeSignatures, merkleTree2Pubkey, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifiedStateTreeLookupTableDevnet, nullifiedStateTreeLookupTableMainnet, nullifierQueue2Pubkey, nullifierQueuePubkey, nullifyLookupTable, packCompressedAccounts, packDecompressAccountsIdempotent, packNewAddressParams, packTreeInfos, padOutputStateMerkleTrees, parseAccountData, parseEvents, parseLightTransaction, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pickRandomTreeAndQueue, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, selectStateTreeInfo, sendAndConfirmTx, sleep, stateTreeLookupTableDevnet, stateTreeLookupTableMainnet, sumUpLamports, testBatchAddressTree, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateNumbers, validateNumbersForInclusionProof, validateNumbersForNonInclusionProof, validateNumbersForProof, validateSameOwner, validateSufficientBalance, versionedEndpoint, wrapBigNumbersAsStrings };