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

package/README.md

@@ -32,18 +32,18 @@ For a more detailed documentation on usage, please check [the respective section
 
 For example implementations, including web and Node, refer to the respective repositories:
 
--   [Web application example implementation](https://github.com/Lightprotocol/example-web-client)
+- [Web application example implementation](https://github.com/Lightprotocol/example-web-client)
 
--   [Node server example implementation](https://github.com/Lightprotocol/example-nodejs-client)
+- [Node server example implementation](https://github.com/Lightprotocol/example-nodejs-client)
 
 ## Troubleshooting
 
 Have a question or a problem?
 Feel free to ask in the [Light](https://discord.gg/CYvjBgzRFP) and [Helius](https://discord.gg/Uzzf6a7zKr) developer Discord servers. Please, include the following information:
 
--   A detailed description or context of the issue or what you are trying to achieve.
--   A code example that we can use to test and debug (if possible). Use [CodeSandbox](https://codesandbox.io/p/sandbox/vanilla-ts) or any other live environment provider.
--   A description or context of any errors you are encountering with stacktraces if available.
+- A detailed description or context of the issue or what you are trying to achieve.
+- A code example that we can use to test and debug (if possible). Use [CodeSandbox](https://codesandbox.io/p/sandbox/vanilla-ts) or any other live environment provider.
+- A description or context of any errors you are encountering with stacktraces if available.
 
 ### Source Maps
 
@@ -57,14 +57,14 @@ We provide `index.js.map` for debugging. Exclude in production:
 
 Light and ZK Compression are open source protocols and very much welcome contributions. If you have a contribution, do not hesitate to send a PR to the respective repository or discuss in the linked developer Discord servers.
 
--   🐞 For bugs or feature requests, please open an
-    [issue](https://github.com/lightprotocol/light-protocol/issues/new).
--   🔒 For security vulnerabilities, please follow the [security policy](https://github.com/Lightprotocol/light-protocol/blob/main/SECURITY.md).
+- 🐞 For bugs or feature requests, please open an
+  [issue](https://github.com/lightprotocol/light-protocol/issues/new).
+- 🔒 For security vulnerabilities, please follow the [security policy](https://github.com/Lightprotocol/light-protocol/blob/main/SECURITY.md).
 
 ## Additional Resources
 
--   [Light Protocol Repository](https://github.com/Lightprotocol/light-protocol)
--   [ZK Compression Official Documentation](https://www.zkcompression.com/)
+- [Light Protocol Repository](https://github.com/Lightprotocol/light-protocol)
+- [ZK Compression Official Documentation](https://www.zkcompression.com/)
 
 ## Disclaimer
 

package/dist/cjs/browser/actions/compress.d.ts

@@ -1,7 +1,7 @@
 import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
 import { Rpc } from '../rpc';
 import BN from 'bn.js';
-import { StateTreeInfo } from '../state';
+import { TreeInfo } from '../state';
 /**
  * Compress lamports to a solana address
  *
@@ -15,4 +15,4 @@ import { StateTreeInfo } from '../state';
  *
  * @return Transaction signature
  */
-export declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+export declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

package/dist/cjs/browser/actions/create-account.d.ts

@@ -1,6 +1,6 @@
 import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
 import { Rpc } from '../rpc';
-import { AddressTreeInfo, StateTreeInfo } from '../state';
+import { AddressTreeInfo, TreeInfo } from '../state';
 import BN from 'bn.js';
 /**
  * Create compressed account with address
@@ -17,7 +17,7 @@ import BN from 'bn.js';
  *
  * @return Transaction signature
  */
-export declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+export declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Create compressed account with address and lamports
  *
@@ -35,4 +35,4 @@ export declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array
  *
  * @return Transaction signature
  */
-export declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+export declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

package/dist/cjs/browser/actions/transfer.d.ts

@@ -1,7 +1,6 @@
 import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Rpc } from '../rpc';
-import { StateTreeInfo } from '../state';
 /**
  * Transfer compressed lamports from one owner to another
  *
@@ -14,4 +13,4 @@ import { StateTreeInfo } from '../state';
  *
  * @return Signature of the confirmed transaction
  */
-export declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, outputStateTreeInfo?: StateTreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+export declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

package/dist/cjs/browser/compressible/action.d.ts

@@ -0,0 +1,77 @@
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature, AccountMeta } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+import { ValidityProof } from '../state/types';
+import { CompressedAccountMeta } from '../state/compressed-account';
+import { CompressedAccountData } from './types';
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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>;

package/dist/cjs/browser/compressible/index.d.ts

@@ -0,0 +1,13 @@
+export { COMPRESSIBLE_DISCRIMINATORS, DecompressMultipleAccountsIdempotentData, UpdateCompressionConfigData, GenericCompressAccountInstruction, } from './types';
+export { UpdateCompressionConfigSchema, ValidityProofSchema, PackedStateTreeInfoSchema, CompressedAccountMetaSchema, GenericCompressAccountInstructionSchema, createCompressedAccountDataSchema, createDecompressMultipleAccountsIdempotentDataSchema, serializeInstructionData, } from './layout';
+export { createInitializeCompressionConfigInstruction, createUpdateCompressionConfigInstruction, createCompressAccountInstruction, createDecompressAccountsIdempotentInstruction, CompressibleInstruction, } from './instruction';
+export { initializeCompressionConfig, updateCompressionConfig, compressAccount, decompressAccountsIdempotent, } from './action';
+export { deriveCompressionConfigAddress, getProgramDataAccount, checkProgramUpdateAuthority, } from './utils';
+export { serializeInitializeCompressionConfigData } from './layout';
+import { CompressedAccount } from '../state/compressed-account';
+import { CompressedAccountData } from './types';
+/**
+ * Convert a compressed account to the format expected by instruction builders
+ */
+export declare function createCompressedAccountData<T>(compressedAccount: CompressedAccount, data: T, seeds: Uint8Array[], outputStateTreeIndex: number): CompressedAccountData<T>;
+export { CompressibleInstruction as compressibleInstruction } from './instruction';

package/dist/cjs/browser/compressible/instruction.d.ts

@@ -0,0 +1,177 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from '@solana/web3.js';
+import { CompressedAccountData } from './types';
+import { CompressedAccount } from '../state/compressed-account';
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function createCompressAccountInstruction(programId: PublicKey, discriminator: Uint8Array | number[], payer: PublicKey, pdaToCompress: PublicKey, rentRecipient: PublicKey, compressedAccountMeta: import('../state/compressed-account').CompressedAccountMeta, validityProof: import('../state/types').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
+ */
+export declare function createDecompressAccountsIdempotentInstruction<T = any>(programId: PublicKey, discriminator: Uint8Array | number[], feePayer: PublicKey, rentPayer: PublicKey, solanaAccounts: PublicKey[], compressedAccountsData: import('./types').CompressedAccountData<T>[], bumps: number[], validityProof: import('../state/types').ValidityProof, systemAccounts: AccountMeta[] | undefined, coder: (data: any) => Buffer): TransactionInstruction;
+/**
+ * Instruction builders for compressible accounts, following Solana SDK patterns.
+ */
+export 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: import('../state/compressed-account').CompressedAccountMeta, validityProof: import('../state/types').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: import('./types').CompressedAccountData<T>[], bumps: number[], validityProof: import('../state/types').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: import('@solana/web3.js').Connection): Promise<{
+        programDataAddress: PublicKey;
+        programDataAccountInfo: import('@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: import('@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>;
+}

package/dist/cjs/browser/compressible/layout.d.ts

@@ -0,0 +1,47 @@
+import * as borsh from '@coral-xyz/borsh';
+import { ValidityProof } from '../state/types';
+import { PackedStateTreeInfo, CompressedAccountMeta } from '../state/compressed-account';
+import { CompressionConfigIxData, UpdateCompressionConfigData, GenericCompressAccountInstruction, CompressedAccountData, DecompressMultipleAccountsIdempotentData } from './types';
+/**
+ * Borsh schema for initializeCompressionConfig instruction data
+ * Note: This is also available from '@lightprotocol/stateless.js' main exports
+ */
+export declare const InitializeCompressionConfigSchema: borsh.Layout<CompressionConfigIxData>;
+/**
+ * Borsh schema for updateCompressionConfig instruction data
+ */
+export declare const UpdateCompressionConfigSchema: borsh.Layout<UpdateCompressionConfigData>;
+/**
+ * Borsh schema for ValidityProof
+ */
+export declare const ValidityProofSchema: borsh.Layout<ValidityProof>;
+/**
+ * Borsh schema for PackedStateTreeInfo
+ */
+export declare const PackedStateTreeInfoSchema: borsh.Layout<PackedStateTreeInfo>;
+/**
+ * Borsh schema for CompressedAccountMeta
+ */
+export declare const CompressedAccountMetaSchema: borsh.Layout<CompressedAccountMeta>;
+/**
+ * Borsh schema for GenericCompressAccountInstruction
+ */
+export declare const GenericCompressAccountInstructionSchema: borsh.Layout<GenericCompressAccountInstruction>;
+/**
+ * Helper function to create borsh schema for CompressedAccountData
+ * This is generic to work with any data type T
+ */
+export 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
+ */
+export declare function createDecompressMultipleAccountsIdempotentDataSchema<T>(dataSchema: borsh.Layout<T>): borsh.Layout<DecompressMultipleAccountsIdempotentData<T>>;
+/**
+ * Serialize instruction data with custom discriminator
+ */
+export declare function serializeInstructionData<T>(schema: borsh.Layout<T>, data: T, discriminator: Uint8Array | number[]): Buffer;
+/**
+ * Serialize instruction data for initializeCompressionConfig using Borsh
+ */
+export declare function serializeInitializeCompressionConfigData(compressionDelay: number, rentRecipient: import('@solana/web3.js').PublicKey, addressSpace: import('@solana/web3.js').PublicKey[], configBump: number | null): Buffer;

package/dist/cjs/browser/compressible/types.d.ts

@@ -0,0 +1,112 @@
+import { PublicKey, AccountMeta } from '@solana/web3.js';
+import { ValidityProof } from '../state/types';
+import { CompressedAccountMeta } from '../state/compressed-account';
+/**
+ * Standard instruction discriminators for compressible instructions
+ * These match the Rust implementation discriminators
+ */
+export 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
+ */
+export 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
+ */
+export type DecompressMultipleAccountsIdempotentData<T = any> = {
+    proof: ValidityProof;
+    compressedAccounts: CompressedAccountData<T>[];
+    bumps: number[];
+    systemAccountsOffset: number;
+};
+/**
+ * Instruction data for update compression config
+ */
+export 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
+ */
+export type GenericCompressAccountInstruction = {
+    proof: ValidityProof;
+    compressedAccountMeta: CompressedAccountMeta;
+};
+/**
+ * Existing CompressionConfigIxData type (re-exported for compatibility)
+ */
+export type CompressionConfigIxData = {
+    compressionDelay: number;
+    rentRecipient: PublicKey;
+    addressSpace: PublicKey[];
+    configBump: number | null;
+};
+/**
+ * Common instruction builder parameters
+ */
+export type InstructionBuilderParams = {
+    programId: PublicKey;
+    discriminator: Uint8Array | number[];
+};
+/**
+ * Initialize compression config instruction parameters
+ */
+export type InitializeCompressionConfigParams = InstructionBuilderParams & {
+    payer: PublicKey;
+    authority: PublicKey;
+    compressionDelay: number;
+    rentRecipient: PublicKey;
+    addressSpace: PublicKey[];
+    configBump?: number | null;
+};
+/**
+ * Update compression config instruction parameters
+ */
+export type UpdateCompressionConfigParams = InstructionBuilderParams & {
+    authority: PublicKey;
+    newCompressionDelay?: number | null;
+    newRentRecipient?: PublicKey | null;
+    newAddressSpace?: PublicKey[] | null;
+    newUpdateAuthority?: PublicKey | null;
+};
+/**
+ * Compress account instruction parameters
+ */
+export type CompressAccountParams = InstructionBuilderParams & {
+    payer: PublicKey;
+    pdaToCompress: PublicKey;
+    rentRecipient: PublicKey;
+    compressedAccountMeta: CompressedAccountMeta;
+    validityProof: ValidityProof;
+    systemAccounts?: AccountMeta[];
+};
+/**
+ * Decompress accounts idempotent instruction parameters
+ */
+export type DecompressAccountsIdempotentParams<T = any> = InstructionBuilderParams & {
+    feePayer: PublicKey;
+    rentPayer: PublicKey;
+    solanaAccounts: PublicKey[];
+    compressedAccountsData: CompressedAccountData<T>[];
+    bumps: number[];
+    validityProof: ValidityProof;
+    systemAccounts?: AccountMeta[];
+    dataSchema?: any;
+};

package/dist/cjs/browser/compressible/utils.d.ts

@@ -0,0 +1,16 @@
+import { Connection, PublicKey, AccountInfo } from '@solana/web3.js';
+/**
+ * Derive the compression config PDA address
+ */
+export declare function deriveCompressionConfigAddress(programId: PublicKey, configIndex?: number): [PublicKey, number];
+/**
+ * Get the program data account address and its raw data for a given program.
+ */
+export declare function getProgramDataAccount(programId: PublicKey, connection: Connection): Promise<{
+    programDataAddress: PublicKey;
+    programDataAccountInfo: AccountInfo<Buffer>;
+}>;
+/**
+ * Check that the provided authority matches the program's upgrade authority.
+ */
+export declare function checkProgramUpdateAuthority(programDataAccountInfo: AccountInfo<Buffer>, providedAuthority: PublicKey): void;

package/dist/cjs/browser/constants.d.ts

@@ -1,15 +1,36 @@
 import BN from 'bn.js';
 import { Buffer } from 'buffer';
 import { ConfirmOptions, PublicKey } from '@solana/web3.js';
-import { StateTreeInfo, TreeType } from './state/types';
+import { TreeInfo, TreeType } from './state/types';
+export declare enum VERSION {
+    V1 = "V1",
+    V2 = "V2"
+}
+/**
+/**
+ * @internal
+ * Feature flags. Only use if you know what you are doing.
+ */
+export declare const featureFlags: {
+    version: VERSION;
+    isV2: () => boolean;
+};
+/**
+ * Returns the correct endpoint name for the current API version. E.g.
+ * versionedEndpoint('getCompressedAccount') -> 'getCompressedAccount' (V1)
+ * or 'getCompressedAccountV2' (V2)
+ */
+export declare const versionedEndpoint: (base: string) => string;
 export declare const FIELD_SIZE: BN;
 export declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
 export declare const COMPUTE_BUDGET_PATTERN: number[];
-export declare const INVOKE_DISCRIMINATOR: Buffer;
-export declare const INVOKE_CPI_DISCRIMINATOR: Buffer;
-export declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer;
+export declare const INVOKE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer<ArrayBuffer>;
 export declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
-export declare const lightProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
+export declare const lightSystemProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
 export declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
 export declare const getRegisteredProgramPda: () => PublicKey;
 export declare const getAccountCompressionAuthority: () => PublicKey;
@@ -39,7 +60,7 @@ export declare const isLocalTest: (url: string) => boolean;
 /**
  * @internal
  */
-export declare const localTestActiveStateTreeInfo: () => StateTreeInfo[];
+export declare const localTestActiveStateTreeInfos: () => TreeInfo[];
 export declare const getDefaultAddressTreeInfo: () => {
     tree: PublicKey;
     queue: PublicKey;
@@ -77,9 +98,13 @@ export declare const cpiContextPubkey = "cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fon
 export declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
 export declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
 export declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
+export declare const addressTreeV2: PublicKey;
 export declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
 export declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
 export declare const cpiContext2Pubkey = "cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK";
+export declare const batchMerkleTree = "HLKs5NJ8FXkJg8BrzJt56adFYYuwg5etzDtBbQYTsixu";
+export declare const batchQueue = "6L7SzhYB3anwEQ9cphpJ1U7Scwj57bx2xueReg7R9cKU";
+export declare const batchCpiContext = "7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj";
 export declare const confirmConfig: ConfirmOptions;
 export declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
 export declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;