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

package/dist/types/index.d.ts

@@ -1,9 +1,10 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, Connection, Commitment, Keypair, Signer, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, DataSlice, MemcmpFilter, ConnectionConfig, ParsedTransactionWithMeta, AccountMeta } from '@solana/web3.js';
+import { PublicKey, Connection, Commitment, Keypair, Signer, TransactionInstruction, AddressLookupTableAccount, VersionedTransaction, ConfirmOptions, TransactionSignature, RpcResponseAndContext, SignatureResult, AccountMeta, DataSlice, MemcmpFilter, ConnectionConfig, AccountInfo, 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';
 
 /**
@@ -20,8 +21,21 @@ 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;
 /**
+ * @deprecated Use {@link deriveAddressV2} instead, unless you're using v1.
+ *
  * Derive an address for a compressed account from a seed and an address Merkle
  * tree public key.
  *
@@ -118,6 +132,7 @@ declare const toCamelCase: (object: any) => any;
  */
 declare function hashToBn254FieldSizeBe(bytes: Buffer$1): [Buffer$1, number] | null;
 /**
+ * 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.
  *
@@ -305,11 +320,11 @@ declare const versionedEndpoint: (base: string) => string;
 declare const FIELD_SIZE: BN;
 declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
 declare const COMPUTE_BUDGET_PATTERN: number[];
-declare const INVOKE_DISCRIMINATOR: Buffer$1;
-declare const INVOKE_CPI_DISCRIMINATOR: Buffer$1;
-declare const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR: Buffer$1;
-declare const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR: Buffer$1;
-declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer$1;
+declare const INVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const INVOKE_CPI_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
 declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
 declare const lightSystemProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
 declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
@@ -379,11 +394,13 @@ 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 confirmConfig: ConfirmOptions;
 declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
 declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;
@@ -466,6 +483,167 @@ 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;
+}
+/**
+ * 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;
+    };
+}
+/**
+ * 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.
+ */
+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 enum TreeType {
     /**
      * v1 state merkle tree
@@ -612,7 +790,7 @@ interface CompressedAccountLegacy {
     /**
      * Optional data attached to the account.
      */
-    data: CompressedAccountData | null;
+    data: CompressedAccountData$1 | null;
 }
 /**
  * @deprecated Use {@link CompressedAccountMeta} instead.
@@ -646,7 +824,7 @@ type NewAddressProofInput = {
 /**
  * Describes compressed account data.
  */
-interface CompressedAccountData {
+interface CompressedAccountData$1 {
     /**
      * 8 bytes.
      */
@@ -941,7 +1119,7 @@ type CompressedAccount = {
     /**
      * Optional data attached to the account.
      */
-    data: CompressedAccountData | null;
+    data: CompressedAccountData$1 | null;
 } & MerkleContext & {
     /**
      * Read only.
@@ -1103,11 +1281,11 @@ interface PackedCompressedAccountWithMerkleContext {
 /**
  * @deprecated use {@link createCompressedAccountMeta} instead.
  */
-declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountLegacy;
+declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData$1, address?: number[]) => CompressedAccountLegacy;
 /**
  * @deprecated.
  */
-declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
+declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData$1, address?: number[]) => CompressedAccountWithMerkleContext;
 /**
  * @deprecated use {@link createCompressedAccountMeta} instead.
  */
@@ -2406,21 +2584,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>;
@@ -2434,19 +2612,19 @@ declare const LatestNonVotingSignaturesResult: Struct<{
  */
 declare const LatestNonVotingSignaturesResultPaginated: Struct<{
     items: {
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[], Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }, {
         signature: Struct<string, null>;
@@ -2461,10 +2639,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>;
@@ -2480,9 +2658,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;
@@ -2537,9 +2715,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;
@@ -2619,8 +2797,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        root: BN;
         hash: BN;
+        root: BN;
     }[];
     addresses: {
         address: BN;
@@ -2667,8 +2845,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        root: BN;
         hash: BN;
+        root: BN;
     }[], Struct<{
         merkleContext: {
             cpiContext: PublicKey | null;
@@ -2687,8 +2865,8 @@ declare const ValidityProofResultV2: Struct<{
             proveByIndex: boolean;
         };
         leafIndex: number;
-        root: BN;
         hash: BN;
+        root: BN;
     }, {
         hash: Struct<BN, null>;
         root: Struct<BN, null>;
@@ -2801,17 +2979,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>;
@@ -2827,9 +3005,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;
@@ -2846,9 +3024,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;
@@ -2972,8 +3150,8 @@ declare const CompressedMintTokenHoldersResult: Struct<{
 }>;
 declare const AccountProofResult: Struct<{
     proof: number[][];
-    root: number[];
     hash: number[];
+    root: number[];
 }, {
     hash: Struct<number[], Struct<number, null>>;
     root: Struct<number[], Struct<number, null>>;
@@ -2982,18 +3160,18 @@ declare const AccountProofResult: Struct<{
 declare const toUnixTimestamp: (blockTime: string) => number;
 declare const SignatureListResult: Struct<{
     items: {
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[];
 }, {
     items: Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[], Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -3003,19 +3181,19 @@ declare const SignatureListResult: Struct<{
 }>;
 declare const SignatureListWithCursorResult: Struct<{
     items: {
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[];
     cursor: string | null;
 }, {
     items: Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }[], Struct<{
-        signature: string;
         slot: number;
+        signature: string;
         blockTime: number;
     }, {
         blockTime: Struct<number, null>;
@@ -4116,6 +4294,10 @@ 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>;
 }
 
 declare class IndexedElement {
@@ -4376,7 +4558,7 @@ declare function parseAccountData({ discriminator, data, dataHash, }: {
     dataHash: BN;
 }): {
     discriminator: number[];
-    data: Buffer$1;
+    data: Buffer$1<ArrayBuffer>;
     dataHash: number[];
 };
 /**
@@ -4641,6 +4823,20 @@ declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns             validity proof with context
      */
     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.
+     *
+     * @returns               Account info with compression info, or null if account
+     *                        doesn't exist.
+     */
+    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: Rpc): Promise<{
+        accountInfo: AccountInfo<Buffer$1>;
+        merkleContext?: MerkleContext;
+    } | null>;
 }
 
 /**
@@ -5815,15 +6011,8 @@ 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
@@ -5839,7 +6028,7 @@ interface PackedTreeInfos {
  * @returns Remaining accounts, packed state and address tree infos, state tree
  * output index and address tree infos.
  */
-declare function packTreeInfos(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
+declare function packTreeInfosWithPubkeys(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
 /**
  * Packs Compressed Accounts.
  *
@@ -5863,6 +6052,80 @@ 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;
 /**
@@ -6118,4 +6381,361 @@ declare class MerkleTreeError extends MetaError {
 declare class UtilsError extends MetaError {
 }
 
-export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, type AccountProofInput, AccountProofResult, type ActiveTreeBundle, type AddressTreeInfo, type AddressWithTree, type AddressWithTreeInfo, AppendLeavesInputLayout, AppendNullifyCreateAddressInputsMetaLayout, type BN254, BOB, BalanceResult, CHARLIE, COMPRESSED_TOKEN_PROGRAM_ID, COMPUTE_BUDGET_PATTERN, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, type CompressedAccountLegacy, type CompressedAccountMeta, CompressedAccountResult, CompressedAccountResultV2, type CompressedAccountWithMerkleContext, type CompressedAccountWithMerkleContextLegacy, CompressedAccountsByOwnerResult, CompressedAccountsByOwnerResultV2, type CompressedCpiContext, CompressedCpiContextLayout, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, CompressedProofLayout, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountResultV2, CompressedTokenAccountsByOwnerOrDelegateResult, CompressedTokenAccountsByOwnerOrDelegateResultV2, type CompressedTransaction, CompressedTransactionResult, CompressedTransactionResultV2, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, type HashWithTreeInfo, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INSERT_INTO_QUEUES_DISCRIMINATOR, INVOKE_CPI_DISCRIMINATOR, INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR, INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR, INVOKE_DISCRIMINATOR, InAccountLayout, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, InsertAddressInputLayout, InsertNullifierInputLayout, type InstructionDataInvoke, type InstructionDataInvokeCpi, InstructionDataInvokeCpiLayout, InstructionDataInvokeCpiWithReadOnlyLayout, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram, type LightSystemProgram$1 as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, type MerkleContext, MerkleContextLayout, type MerkleContextLegacy, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleProofResult, MerkleProofResultV2, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MerkleTreeSequenceNumberLayout, MultipleCompressedAccountsResult, MultipleCompressedAccountsResultV2, MultipleMerkleProofsResult, MultipleMerkleProofsResultV2, NativeBalanceResult, type NewAddressParams, NewAddressParamsAssignedPackedLayout, NewAddressParamsLayout, type NewAddressParamsPacked, type NewAddressProofInput, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type NullifierMetadata, type OutputCompressedAccountWithPackedContext, type PackedAddressTreeInfo, type PackedCompressedAccountWithMerkleContext, PackedMerkleContextLayout, type PackedMerkleContextLegacy, PackedReadOnlyAddressLayout, PackedReadOnlyCompressedAccountLayout, type PackedStateTreeInfo, type PackedStateTreeInfos, type PackedTreeInfos, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, RootIndexResultV2, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, type StateTreeInfo, type StateTreeLUTPair, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, type TreeInfo, TreeType, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, VERSION, type ValidityProof, ValidityProofResult, ValidityProofResultV2, type ValidityProofWithContext, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, batchMerkleTree, batchQueue, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertInvokeCpiWithReadOnlyToInvoke, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, convertToPublicTransactionEvent, cpiContext2Pubkey, cpiContextPubkey, createAccount, createAccountWithLamports, createBN254, createCompressedAccountLegacy, createCompressedAccountMeta, createCompressedAccountWithMerkleContextLegacy, createMerkleContextLegacy, createRpc, createRpcResult, createStateTreeLookupTable, decodeInstructionDataInvoke, decodeInstructionDataInvokeCpi, decodeInstructionDataInvokeCpiWithReadOnly, decodePublicTransactionEvent, decompress, dedupeSigner, deepEqual, defaultStateTreeLookupTables, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, defaultTestStateTreeAccounts2, deriveAddress, deriveAddressSeed, deserializeAppendNullifyCreateAddressInputsIndexer, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, extendStateTreeLookupTable, featureFlags, getAccountCompressionAuthority, getAllStateTreeInfos, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getDefaultAddressTreeInfo, getIndexOrAdd, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getStateTreeInfoByPubkey, getTestKeypair, getTestRpc, getTreeInfoByPubkey, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, invokeAccountsLayout, type invokeAccountsLayoutParams, isLocalTest, isSmallerThanBn254FieldSizeBe, jsonRpcResult, jsonRpcResultAndContext, lightSystemProgram, localTestActiveStateTreeInfos, merkleTree2Pubkey, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifiedStateTreeLookupTableDevnet, nullifiedStateTreeLookupTableMainnet, nullifierQueue2Pubkey, nullifierQueuePubkey, nullifyLookupTable, packCompressedAccounts, packNewAddressParams, packTreeInfos, padOutputStateMerkleTrees, parseAccountData, parseEvents, parseLightTransaction, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pickRandomTreeAndQueue, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, selectStateTreeInfo, sendAndConfirmTx, sleep, stateTreeLookupTableDevnet, stateTreeLookupTableMainnet, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateNumbers, validateNumbersForInclusionProof, validateNumbersForNonInclusionProof, validateNumbersForProof, validateSameOwner, validateSufficientBalance, versionedEndpoint, wrapBigNumbersAsStrings };
+/**
+ * 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 };