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

package/dist/cjs/browser/utils/get-state-tree-infos.d.ts

@@ -1,6 +1,11 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { StateTreeInfo, TreeType } from '../state/types';
+import { TreeInfo, TreeType } from '../state/types';
 import { StateTreeLUTPair } from '../constants';
+/**
+ * @deprecated use {@link getTreeInfoByPubkey} instead
+ */
+export declare function getStateTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+export declare function getTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
 /**
  * @deprecated use {@link selectStateTreeInfo} instead.
  *
@@ -9,24 +14,26 @@ import { StateTreeLUTPair } from '../constants';
  * @param infos Set of state tree infos
  * @returns A random tree and queue
  */
-export declare function pickRandomTreeAndQueue(infos: StateTreeInfo[]): {
+export declare function pickRandomTreeAndQueue(infos: TreeInfo[]): {
     tree: PublicKey;
     queue: PublicKey;
 };
 /**
- * Get a pseudo-random active state tree info from the set of provided state
+ * Select a pseudo-random active state tree info from the set of provided state
  * tree infos.
  *
- * Using this mitigates write lock contention on state trees.
+ * Using this reduces write-lock contention on state trees.
  *
  * @param infos                 Set of state tree infos
- * @param treeType              The type of tree. Defaults to `TreeType.StateV1`
- * @param useMaxConcurrency     If true, return all infos. If false, return at
- *                              most {@link MAX_HOTSPOTS}. Defaults to `false`.
+ *
+ * @param treeType              Optional: Only use if you know what you are
+ *                              doing. The type of tree.
+ * @param useMaxConcurrency     Optional: Only use if you know what you are
+ *                              doing. If true, select from all infos.
  *
  * @returns A pseudo-randomly selected tree info
  */
-export declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): StateTreeInfo;
+export declare function selectStateTreeInfo(infos: TreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): TreeInfo;
 /**
  * Get active state tree infos from LUTs.
  *
@@ -38,4 +45,4 @@ export declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: T
 export declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
     connection: Connection;
     stateTreeLUTPairs: StateTreeLUTPair[];
-}): Promise<StateTreeInfo[]>;
+}): Promise<TreeInfo[]>;

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

@@ -3,11 +3,11 @@ export * from './airdrop';
 export * from './calculate-compute-unit-price';
 export * from './conversion';
 export * from './dedupe-signer';
-export * from './get-state-tree-infos';
 export * from './parse-validity-proof';
 export * from './pipe';
 export * from './send-and-confirm';
 export * from './sleep';
-export * from './state-tree-lookup-table';
 export * from './validation';
+export * from './state-tree-lookup-table';
 export * from './get-state-tree-infos';
+export * from './packed-accounts';

package/dist/cjs/browser/utils/packed-accounts.d.ts

@@ -0,0 +1,161 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+/**
+ * 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,
+ * });
+ * ```
+ */
+export 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,
+ * });
+ * ```
+ */
+export 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
+ * );
+ * ```
+ */
+export declare function createPackedAccountsWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccounts;
+export 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)`.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export declare function createPackedAccountsSmall(programId: PublicKey): PackedAccountsSmall;
+/**
+ * Creates a PackedAccountsSmall instance with system accounts and CPI context.
+ */
+export declare function createPackedAccountsSmallWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccountsSmall;
+export declare class SystemAccountPubkeys {
+    lightSystemProgram: PublicKey;
+    systemProgram: PublicKey;
+    accountCompressionProgram: PublicKey;
+    accountCompressionAuthority: PublicKey;
+    registeredProgramPda: PublicKey;
+    noopProgram: PublicKey;
+    solPoolPda: PublicKey;
+    private constructor();
+    static default(): SystemAccountPubkeys;
+}

package/dist/cjs/browser/utils/send-and-confirm.d.ts

@@ -34,7 +34,7 @@ export declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, con
  * @param blockHashCtx      blockhash context for confirmation
  * @return SignatureResult
  */
-export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, _blockHashCtx?: {
     blockhash: string;
     lastValidBlockHeight: number;
 }): Promise<RpcResponseAndContext<SignatureResult>>;

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

@@ -1,7 +1,7 @@
 import BN from 'bn.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext } from '../state';
+import { CompressedAccountLegacy, CompressedAccountWithMerkleContext } from '../state';
 export declare const validateSufficientBalance: (balance: BN) => void;
-export declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | CompressedAccountWithMerkleContext[]) => void;
+export declare const validateSameOwner: (compressedAccounts: CompressedAccountLegacy[] | CompressedAccountWithMerkleContext[]) => void;
 export declare const validateNumbersForProof: (hashesLength: number, newAddressesLength: number) => void;
 export declare const validateNumbersForInclusionProof: (hashesLength: number) => void;
 export declare const validateNumbersForNonInclusionProof: (newAddressesLength: number) => void;

package/dist/cjs/node/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/node/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/node/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/node/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/node/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/node/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/node/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;