@lightprotocol/compressed-token 0.22.1-alpha.9 → 0.23.0-beta.10

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { PublicKey, TransactionInstruction, Commitment, AccountInfo, Signer, ConfirmOptions, TransactionSignature, AccountMeta, Keypair, Connection } from '@solana/web3.js';
-import { ValidityProofWithContext, AddressTreeInfo, TreeInfo, MerkleContext, Rpc, ParsedTokenAccount, CompressedAccountWithMerkleContext, ValidityProof, PackedMerkleContextLegacy, CompressedCpiContext, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
+import { PublicKey, TransactionInstruction, Commitment, AccountInfo, Signer, ConfirmOptions, TransactionSignature, Keypair, AccountMeta, Connection } from '@solana/web3.js';
+import { ValidityProofWithContext, AddressTreeInfo, TreeInfo, MerkleContext, Rpc, CompressedAccountWithMerkleContext, ParsedTokenAccount, TreeType, PackedMerkleContextLegacy, CompressedCpiContext, ValidityProof, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
 export { ParsedTokenAccount as ParsedTokenAccountInterface } from '@lightprotocol/stateless.js';
 import { Mint, Account } from '@solana/spl-token';
 export { Account, AccountState } from '@solana/spl-token';
@@ -339,7 +339,7 @@ interface AdditionalMetadata {
 }
 
 /**
- * Token metadata for creating a c-token mint.
+ * Token metadata for creating a light-token mint.
  */
 interface TokenMetadataInstructionData {
     name: string;
@@ -350,7 +350,7 @@ interface TokenMetadataInstructionData {
 }
 declare function createTokenMetadata(name: string, symbol: string, uri: string, updateAuthority?: PublicKey | null, additionalMetadata?: AdditionalMetadata[] | null): TokenMetadataInstructionData;
 /**
- * Create instruction for initializing a c-token mint.
+ * Create instruction for initializing a light-token mint.
  *
  * @param mintSigner          Mint signer keypair public key.
  * @param decimals            Number of decimals for the mint.
@@ -361,8 +361,9 @@ declare function createTokenMetadata(name: string, symbol: string, uri: string,
  * @param addressTreeInfo     Address tree info for the mint.
  * @param outputStateTreeInfo Output state tree info.
  * @param metadata            Optional token metadata.
+ * @param maxTopUp             Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createMintInstruction(mintSigner: PublicKey, decimals: number, mintAuthority: PublicKey, freezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext, addressTreeInfo: AddressTreeInfo, outputStateTreeInfo: TreeInfo, metadata?: TokenMetadataInstructionData): TransactionInstruction;
+declare function createMintInstruction(mintSigner: PublicKey, decimals: number, mintAuthority: PublicKey, freezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext, addressTreeInfo: AddressTreeInfo, outputStateTreeInfo: TreeInfo, metadata?: TokenMetadataInstructionData, maxTopUp?: number): TransactionInstruction;
 
 /**
  * SPL-compatible base mint structure
@@ -380,12 +381,12 @@ interface BaseMint {
     freezeAuthority: PublicKey | null;
 }
 /**
- * Compressed mint context (protocol version, SPL mint reference)
+ * Light mint context (protocol version, SPL mint reference)
  */
 interface MintContext {
     /** Protocol version for upgradability */
     version: number;
-    /** Whether the compressed mint is decompressed to a CMint Solana account */
+    /** Whether the compressed light mint has been decompressed to a light mint account */
     cmintDecompressed: boolean;
     /** PDA of the associated SPL mint */
     splMint: PublicKey;
@@ -423,7 +424,7 @@ interface TokenMetadata {
     }[];
 }
 /**
- * Complete compressed mint structure (raw format)
+ * Complete light mint structure (raw format)
  */
 interface CompressedMint {
     base: BaseMint;
@@ -452,7 +453,7 @@ interface RentConfig {
     maxTopUp: number;
 }
 /**
- * Compression info embedded in CompressedMint
+ * Compression info embedded in light mint
  */
 interface CompressionInfo {
     /** Config account version (0 = uninitialized) */
@@ -477,18 +478,18 @@ interface CompressionInfo {
     rentConfig: RentConfig;
 }
 /**
- * Deserialize a compressed mint from buffer
+ * Deserialize a light mint from buffer
  * Uses SPL's MintLayout for BaseMint and buffer-layout struct for context
  *
  * @param data - The raw account data buffer
- * @returns The deserialized CompressedMint
+ * @returns The deserialized light mint
  */
 declare function deserializeMint(data: Buffer$1 | Uint8Array): CompressedMint;
 /**
- * Serialize a CompressedMint to buffer
+ * Serialize a light mint to buffer
  * Uses SPL's MintLayout for BaseMint, helper functions for context/metadata
  *
- * @param mint - The CompressedMint to serialize
+ * @param mint - The light mint to serialize
  * @returns The serialized buffer
  */
 declare function serializeMint(mint: CompressedMint): Buffer$1;
@@ -551,11 +552,11 @@ interface MintInterface {
     mintContext?: MintContext;
     tokenMetadata?: TokenMetadata;
     extensions?: MintExtension[];
-    /** Compression info for c-token mints */
+    /** Compression info for light-token mints */
     compression?: CompressionInfo;
 }
 /**
- * Get unified mint info for SPL/T22/c-token mints.
+ * Get unified mint info for SPL/T22/light-token mints.
  *
  * @param rpc           RPC connection
  * @param address       The mint address
@@ -567,16 +568,16 @@ interface MintInterface {
  */
 declare function getMintInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<MintInterface>;
 /**
- * Unpack mint info from raw account data for SPL/T22/c-token.
+ * Unpack mint info from raw account data for SPL/T22/light-token.
  *
  * @param address       The mint pubkey
  * @param data          The raw account data or AccountInfo
- * @param programId     Token program ID. Default c-token.
+ * @param programId     Token program ID. Default light-token.
  * @returns Object with mint, optional mintContext and tokenMetadata.
  */
 declare function unpackMintInterface(address: PublicKey, data: Buffer$1 | Uint8Array | AccountInfo<Buffer$1>, programId?: PublicKey): Omit<MintInterface, 'merkleContext'>;
 /**
- * Unpack c-token mint context and metadata from raw account data
+ * Unpack light-token mint context and metadata from raw account data
  *
  * @param data  The raw account data
  * @returns     Object with mintContext, tokenMetadata, and extensions
@@ -588,17 +589,20 @@ declare function unpackMintData(data: Buffer$1 | Uint8Array): {
 };
 
 /**
- * Create instruction for updating a compressed mint's mint authority.
+ * Create instruction for updating a light mint's mint authority.
+ * Works for both compressed and decompressed light mints.
  *
  * @param mintInterface          MintInterface from getMintInterface() - must have merkleContext
  * @param currentMintAuthority   Current mint authority public key (must sign)
  * @param newMintAuthority       New mint authority (or null to revoke)
  * @param payer                  Fee payer public key
- * @param validityProof          Validity proof for the compressed mint
+ * @param validityProof          Validity proof for the compressed light mint (null for decompressed light mints)
+ * @param maxTopUp               Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterface, currentMintAuthority: PublicKey, newMintAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext): TransactionInstruction;
+declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterface, currentMintAuthority: PublicKey, newMintAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext | null, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for updating a compressed mint's freeze authority.
+ * Create instruction for updating a light mint's freeze authority.
+ * Works for both compressed and decompressed light mints.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -607,12 +611,13 @@ declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterfa
  * @param currentFreezeAuthority   Current freeze authority public key (must sign)
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param payer                    Fee payer public key
- * @param validityProof            Validity proof for the compressed mint
+ * @param validityProof            Validity proof for the compressed light mint (null for decompressed light mints)
+ * @param maxTopUp                 Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInterface, currentFreezeAuthority: PublicKey, newFreezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext): TransactionInstruction;
+declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInterface, currentFreezeAuthority: PublicKey, newFreezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext | null, maxTopUp?: number): TransactionInstruction;
 
 /**
- * Create instruction for updating a compressed mint's metadata field.
+ * Create instruction for updating a light mint's metadata field.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -620,15 +625,16 @@ declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInter
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the light mint (null for decompressed light mints)
  * @param fieldType      Field to update: 'name', 'symbol', 'uri', or 'custom'
  * @param value          New value for the field
  * @param customKey      Custom key name (required if fieldType is 'custom')
  * @param extensionIndex Extension index (default: 0)
+ * @param maxTopUp        Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number): TransactionInstruction;
+declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for updating a compressed mint's metadata authority.
+ * Create instruction for updating a light mint's metadata authority.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -637,12 +643,13 @@ declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterfa
  * @param currentAuthority Current metadata update authority public key (must sign)
  * @param newAuthority     New metadata update authority public key
  * @param payer            Fee payer public key
- * @param validityProof    Validity proof for the compressed mint
+ * @param validityProof    Validity proof for the light mint (null for decompressed light mints)
  * @param extensionIndex   Extension index (default: 0)
+ * @param maxTopUp         Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInterface, currentAuthority: PublicKey, newAuthority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, extensionIndex?: number): TransactionInstruction;
+declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInterface, currentAuthority: PublicKey, newAuthority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for removing a metadata key from a compressed mint.
+ * Create instruction for removing a metadata key from a light mint.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -650,12 +657,13 @@ declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInt
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the light mint (null for decompressed light mints)
  * @param key            Metadata key to remove
  * @param idempotent     If true, don't error if key doesn't exist (default: false)
  * @param extensionIndex Extension index (default: 0)
+ * @param maxTopUp        Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createRemoveMetadataKeyInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, key: string, idempotent?: boolean, extensionIndex?: number): TransactionInstruction;
+declare function createRemoveMetadataKeyInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, key: string, idempotent?: boolean, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 
 interface CompressToPubkey {
     bump: number;
@@ -665,49 +673,81 @@ interface CompressToPubkey {
 interface CompressibleConfig {
     tokenAccountVersion: number;
     rentPayment: number;
-    hasTopUp: number;
     compressionOnly: number;
     writeTopUp: number;
     compressToAccountPubkey?: CompressToPubkey | null;
 }
-interface CreateAssociatedCTokenAccountParams {
-    bump: number;
-    compressibleConfig?: CompressibleConfig;
+interface CreateAssociatedLightTokenAccountParams {
+    compressibleConfig?: CompressibleConfig | null;
 }
 /**
- * Create instruction for creating an associated compressed token account.
+ * Default compressible config for light-token ATAs - matches Rust SDK defaults.
+ *
+ * - tokenAccountVersion: 3 (ShaFlat) - latest hashing scheme
+ * - rentPayment: 16 - prepay 16 epochs (~24 hours rent)
+ * - compressionOnly: 1 - required for ATAs
+ * - writeTopUp: 766 - per-write top-up (~2 epochs rent) when rent < 2 epochs
+ * - compressToAccountPubkey: null - required for ATAs
+ *
+ * Cost breakdown at associated token account creation:
+ * - Rent sponsor PDA (LIGHT_TOKEN_RENT_SPONSOR) pays: rent exemption (~890,880 lamports)
+ * - Fee payer pays: compression_cost (11K) + 16 epochs rent (~6,400) = ~17,400 lamports + tx fees
+ *
+ * Per-write top-up (transfers):
+ * - When account rent is below 2 epochs, fee payer pays 766 lamports top-up
+ * - This keeps the account perpetually funded when actively used
+ *
+ * Rent calculation (272-byte compressible lightToken account):
+ * - rent_per_epoch = base_rent (128) + bytes * rent_per_byte (272 * 1) = 400 lamports
+ * - 16 epochs = 16 * 400 = 6,400 lamports (24 hours)
+ * - 2 epochs = 2 * 400 = 800 lamports (~3 hours, writeTopUp = 766 is conservative)
+ *
+ * Account size breakdown (272 bytes):
+ * - 165 bytes: SPL token base layout
+ * - 1 byte: account_type discriminator
+ * - 1 byte: Option discriminator for extensions
+ * - 4 bytes: Vec length prefix
+ * - 1 byte: extension type discriminant
+ * - 4 bytes: CompressibleExtension header (decimals_option, decimals, compression_only, is_ata)
+ * - 96 bytes: CompressionInfo struct
+ */
+declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
+/**
+ * Create instruction for creating an associated light-token account.
+ * Uses the default rent sponsor PDA by default.
  *
  * @param feePayer          Fee payer public key.
  * @param owner             Owner of the associated token account.
  * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+declare function createAssociatedLightTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 /**
- * Create idempotent instruction for creating an associated compressed token account.
+ * Create idempotent instruction for creating an associated light-token account.
+ * Uses the default rent sponsor PDA by default.
  *
  * @param feePayer          Fee payer public key.
  * @param owner             Owner of the associated token account.
  * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+declare function createAssociatedLightTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 
 /**
- * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
+ * light-token-specific config for createAssociatedTokenAccountInterfaceInstruction
  */
-interface CTokenConfig {
-    compressibleConfig?: CompressibleConfig;
+interface LightTokenConfig {
+    compressibleConfig?: CompressibleConfig | null;
     configAccount?: PublicKey;
     rentPayerPda?: PublicKey;
 }
 /**
  * Create instruction for creating an associated token account (SPL, Token-2022,
- * or c-token). Follows SPL Token API signature with optional c-token config at the
+ * or light-token). Follows SPL Token API signature with optional light-token config at the
  * end.
  *
  * @param payer                    Fee payer public key.
@@ -716,12 +756,12 @@ interface CTokenConfig {
  * @param mint                     Mint address.
  * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
  * @param associatedTokenProgramId Associated token program ID.
- * @param ctokenConfig             Optional c-token-specific configuration.
+ * @param lightTokenConfig             Optional light-token-specific configuration.
  */
-declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
+declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): TransactionInstruction;
 /**
  * Create idempotent instruction for creating an associated token account (SPL,
- * Token-2022, or c-token). Follows SPL Token API signature with optional c-token
+ * Token-2022, or light-token). Follows SPL Token API signature with optional light-token
  * config at the end.
  *
  * @param payer                    Fee payer public key.
@@ -730,110 +770,14 @@ declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicK
  * @param mint                     Mint address.
  * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
  * @param associatedTokenProgramId Associated token program ID.
- * @param ctokenConfig             Optional c-token-specific configuration.
+ * @param lightTokenConfig             Optional light-token-specific configuration.
  */
-declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
+declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): TransactionInstruction;
 /**
  * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
  */
 declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
 
-/**
- * Create instruction for minting compressed tokens to an onchain token account.
- *
- * @param authority           Mint authority public key.
- * @param payer               Fee payer public key.
- * @param validityProof       Validity proof for the compressed mint.
- * @param merkleContext       Merkle context of the compressed mint.
- * @param mintData            Mint instruction data.
- * @param outputStateTreeInfo Output state tree info.
- * @param recipientAccount    Recipient onchain token account address.
- * @param amount              Amount to mint.
- */
-declare function createMintToInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, outputStateTreeInfo: TreeInfo, recipientAccount: PublicKey, amount: number | bigint): TransactionInstruction;
-
-/**
- * Token data version enum - mirrors Rust TokenDataVersion
- * Used for compressed token account hashing strategy
- */
-declare enum TokenDataVersion {
-    /** V1: Poseidon hash with little-endian amount, discriminator [2,0,0,0,0,0,0,0] */
-    V1 = 1,
-    /** V2: Poseidon hash with big-endian amount, discriminator [0,0,0,0,0,0,0,3] */
-    V2 = 2,
-    /** ShaFlat: SHA256 hash of borsh-serialized data, discriminator [0,0,0,0,0,0,0,4] */
-    ShaFlat = 3
-}
-declare const POOL_SEED: Buffer$1<ArrayBuffer>;
-declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
-declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const MINT_TO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const TRANSFER_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const APPROVE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const REVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-
-/**
- * Create instruction for minting tokens from a c-mint to compressed accounts.
- * To mint to onchain token accounts across SPL/T22/c-mints, use
- * {@link createMintToInterfaceInstruction} instead.
- *
- * @param authority             Mint authority public key.
- * @param payer                 Fee payer public key.
- * @param validityProof         Validity proof for the compressed mint.
- * @param merkleContext         Merkle context of the compressed mint.
- * @param mintData              Mint instruction data.
- * @param recipients            Array of recipients with amounts.
- * @param outputStateTreeInfo   Optional output state tree info. Uses merkle
- * context queue if not provided.
- * @param tokenAccountVersion   Token account version (default:
- * TokenDataVersion.ShaFlat).
- */
-declare function createMintToCompressedInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, recipients: Array<{
-    recipient: PublicKey;
-    amount: number | bigint;
-}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion): TransactionInstruction;
-
-/**
- * Create mint-to instruction for SPL, Token-2022, or compressed token mints.
- * This instruction ONLY mints to decompressed/onchain token accounts.
- *
- * @param mintInterface   Mint interface (SPL, Token-2022, or compressed).
- * @param destination     Destination onchain token account address.
- * @param authority       Mint authority public key.
- * @param payer           Fee payer public key.
- * @param amount          Amount to mint.
- * @param validityProof   Validity proof (required for compressed mints).
- * @param multiSigners    Multi-signature signer public keys.
- */
-declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
-
-/**
- * Create a c-token transfer instruction.
- *
- * @param source        Source c-token account
- * @param destination   Destination c-token account
- * @param owner         Owner of the source account (signer, also pays for compressible extension top-ups)
- * @param amount        Amount to transfer
- * @returns Transaction instruction for c-token transfer
- */
-declare function createCTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint): TransactionInstruction;
-/**
- * Construct a transfer instruction for SPL/T22/c-token. Defaults to c-token
- * program. For cross-program transfers (SPL <> c-token), use `wrap`/`unwrap`.
- *
- * @param source        Source token account
- * @param destination   Destination token account
- * @param owner         Owner of the source account (signer)
- * @param amount        Amount to transfer
- * @returns instruction for c-token transfer
- */
-declare function createTransferInterfaceInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, multiSigners?: (Signer | PublicKey)[], programId?: PublicKey): TransactionInstruction;
-
 declare namespace BN {
     type Endianness = "le" | "be";
     type IPrimeName = "k256" | "p224" | "p192" | "p25519";
@@ -1427,6 +1371,77 @@ declare class RedBN extends BN {
     redPow(b: BN): RedBN;
 }
 
+declare const TokenAccountSourceType: {
+    readonly Spl: "spl";
+    readonly Token2022: "token2022";
+    readonly SplCold: "spl-cold";
+    readonly Token2022Cold: "token2022-cold";
+    readonly LightTokenHot: "light-token-hot";
+    readonly LightTokenCold: "light-token-cold";
+};
+type TokenAccountSourceTypeValue = (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
+/** @internal */
+interface TokenAccountSource {
+    type: TokenAccountSourceTypeValue;
+    address: PublicKey;
+    amount: bigint;
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext?: MerkleContext;
+    parsed: Account;
+}
+interface AccountInterface {
+    accountInfo: AccountInfo<Buffer$1>;
+    parsed: Account;
+    isCold: boolean;
+    loadContext?: MerkleContext;
+    _sources?: TokenAccountSource[];
+    _needsConsolidation?: boolean;
+    _hasDelegate?: boolean;
+    _anyFrozen?: boolean;
+    /** True when fetched via getAtaInterface */
+    _isAta?: boolean;
+    /** Associated token account owner - set by getAtaInterface */
+    _owner?: PublicKey;
+    /** Associated token account mint - set by getAtaInterface */
+    _mint?: PublicKey;
+}
+/** @internal */
+declare function convertTokenDataToAccount(address: PublicKey, tokenData: {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: number;
+    tlv: Buffer$1 | null;
+}): Account;
+/** Convert compressed account to AccountInfo */
+declare function toAccountInfo(compressedAccount: CompressedAccountWithMerkleContext): AccountInfo<Buffer$1>;
+/** @internal */
+declare function parseLightTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext: undefined;
+    parsed: Account;
+    isCold: false;
+};
+/** @internal */
+declare function parseLightTokenCold(address: PublicKey, compressedAccount: CompressedAccountWithMerkleContext): {
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext: MerkleContext;
+    parsed: Account;
+    isCold: true;
+};
+/**
+ * Retrieve information about a token account of SPL/T22/light-token.
+ *
+ * @param rpc        RPC connection to use
+ * @param address    Token account address
+ * @param commitment Desired level of commitment for querying the state
+ * @param programId  Token program ID. If not provided, tries all programs concurrently.
+ *
+ * @return Token account information with compression context if applicable
+ */
+declare function getAccountInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
+
 /**
  * SPL interface PDA info.
  */
@@ -1611,277 +1626,275 @@ declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
  */
 declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
 
+declare function sliceLast<T>(items: T[]): {
+    rest: T[];
+    last: T;
+};
+
 /**
- * Create decompressInterface instruction using Transfer2.
+ * Create a light-token transfer instruction.
  *
- * Supports decompressing to both c-token accounts and SPL token accounts:
- * - For c-token destinations: No splInterfaceInfo needed
- * - For SPL destinations: Provide splInterfaceInfo (token pool info) and decimals
+ * For light-token accounts with compressible extension, the program needs
+ * system_program and fee_payer to handle rent top-ups.
  *
- * @param payer                        Fee payer public key
- * @param inputCompressedTokenAccounts Input compressed token accounts
- * @param toAddress                    Destination token account address (c-token or SPL ATA)
- * @param amount                       Amount to decompress
- * @param validityProof                Validity proof (contains compressedProof and rootIndices)
- * @param splInterfaceInfo             Optional: SPL interface info for SPL destinations
- * @param decimals                     Mint decimals (required for SPL destinations)
- * @returns TransactionInstruction
+ * @param source        Source light-token account
+ * @param destination   Destination light-token account
+ * @param owner         Owner of the source account (signer, also pays for compressible extension top-ups)
+ * @param amount        Amount to transfer
+ * @param feePayer      Optional fee payer for top-ups (defaults to owner)
+ * @returns Transaction instruction for light-token transfer
  */
-declare function createDecompressInterfaceInstruction(payer: PublicKey, inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: bigint, validityProof: ValidityProofWithContext, splInterfaceInfo: SplInterfaceInfo | undefined, decimals: number): TransactionInstruction;
+declare function createLightTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
+/**
+ * Create a light-token transfer_checked instruction. Same semantics as SPL
+ * TransferChecked.
+ */
+declare function createLightTokenTransferCheckedInstruction(source: PublicKey, destination: PublicKey, mint: PublicKey, owner: PublicKey, amount: number | bigint, decimals: number, payer: PublicKey): TransactionInstruction;
+declare function createTransferInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, sender: PublicKey, destination: PublicKey, decimals: number, options?: TransferOptions): Promise<TransactionInstruction[][]>;
 
-declare const TokenAccountSourceType: {
-    readonly Spl: "spl";
-    readonly Token2022: "token2022";
-    readonly SplCold: "spl-cold";
-    readonly Token2022Cold: "token2022-cold";
-    readonly CTokenHot: "ctoken-hot";
-    readonly CTokenCold: "ctoken-cold";
-};
-type TokenAccountSourceTypeValue = (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
-/** @internal */
-interface TokenAccountSource {
-    type: TokenAccountSourceTypeValue;
-    address: PublicKey;
-    amount: bigint;
-    accountInfo: AccountInfo<Buffer$1>;
-    loadContext?: MerkleContext;
-    parsed: Account;
+interface InterfaceOptions {
+    splInterfaceInfos?: SplInterfaceInfo[];
+    /**
+     * ATA owner (authority owner) used to derive the ATA when the signer is a
+     * delegate. For owner-signed flows, omit this field.
+     */
+    owner?: PublicKey;
 }
-interface AccountInterface {
-    accountInfo: AccountInfo<Buffer$1>;
-    parsed: Account;
-    isCold: boolean;
-    loadContext?: MerkleContext;
-    _sources?: TokenAccountSource[];
-    _needsConsolidation?: boolean;
-    _hasDelegate?: boolean;
-    _anyFrozen?: boolean;
-    /** True when fetched via getAtaInterface */
-    _isAta?: boolean;
-    /** ATA owner - set by getAtaInterface */
-    _owner?: PublicKey;
-    /** ATA mint - set by getAtaInterface */
-    _mint?: PublicKey;
+declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, destination: PublicKey, owner: Signer, amount: number | bigint | BN, programId?: PublicKey, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, wrap?: boolean, decimals?: number): Promise<TransactionSignature>;
+interface TransferOptions extends InterfaceOptions {
+    wrap?: boolean;
+    programId?: PublicKey;
 }
-/** @internal */
-declare function convertTokenDataToAccount(address: PublicKey, tokenData: {
+
+declare function selectInputsForAmount(accounts: ParsedTokenAccount[], neededAmount: bigint): ParsedTokenAccount[];
+
+/**
+ * Parameters for creating a MintTo instruction.
+ */
+interface CreateMintToInstructionParams {
+    /** Light mint account (decompressed from compressed light mint) */
     mint: PublicKey;
-    owner: PublicKey;
-    amount: BN;
-    delegate: PublicKey | null;
-    state: number;
-    tlv: Buffer$1 | null;
-}): Account;
-/** Convert compressed account to AccountInfo */
-declare function toAccountInfo(compressedAccount: CompressedAccountWithMerkleContext): AccountInfo<Buffer$1>;
-/** @internal */
-declare function parseCTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
-    accountInfo: AccountInfo<Buffer$1>;
-    loadContext: undefined;
-    parsed: Account;
-    isCold: false;
-};
-/** @internal */
-declare function parseCTokenCold(address: PublicKey, compressedAccount: CompressedAccountWithMerkleContext): {
-    accountInfo: AccountInfo<Buffer$1>;
-    loadContext: MerkleContext;
-    parsed: Account;
-    isCold: true;
-};
+    /** Destination light-token account to mint to */
+    destination: PublicKey;
+    /** Amount of tokens to mint */
+    amount: number | bigint;
+    /** Mint authority (must be signer) */
+    authority: PublicKey;
+    /** Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (u16::MAX = no limit, 0 = no top-ups allowed) */
+    maxTopUp?: number;
+    /** Optional fee payer for rent top-ups. If not provided, authority pays. */
+    feePayer?: PublicKey;
+}
 /**
- * Retrieve information about a token account of SPL/T22/c-token.
+ * Create instruction for minting tokens to a light-token account.
  *
- * @param rpc        RPC connection to use
- * @param address    Token account address
- * @param commitment Desired level of commitment for querying the state
- * @param programId  Token program ID. If not provided, tries all programs concurrently.
+ * This is a simple 3-4 account instruction for minting to light-token associated token accounts (hot).
+ * Uses discriminator 7 (LightTokenMintTo).
  *
- * @return Token account information with compression context if applicable
+ * @param params - Mint instruction parameters
+ * @returns TransactionInstruction for minting tokens
  */
-declare function getAccountInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
+declare function createMintToInstruction(params: CreateMintToInstructionParams): TransactionInstruction;
 
+/** Default compressible config PDA (V1) */
+declare const LIGHT_TOKEN_CONFIG: PublicKey;
+/** Default rent sponsor PDA (V1) */
+declare const LIGHT_TOKEN_RENT_SPONSOR: PublicKey;
 /**
- * Options for interface operations (load, transfer)
+ * Token data version enum - mirrors Rust TokenDataVersion
+ * Used for compressed token account hashing strategy
  */
-interface InterfaceOptions {
-    /** SPL interface infos (fetched if not provided) */
-    splInterfaceInfos?: SplInterfaceInfo[];
+declare enum TokenDataVersion {
+    /** V1: Poseidon hash with little-endian amount, discriminator [2,0,0,0,0,0,0,0] */
+    V1 = 1,
+    /** V2: Poseidon hash with big-endian amount, discriminator [0,0,0,0,0,0,0,3] */
+    V2 = 2,
+    /** ShaFlat: SHA256 hash of borsh-serialized data, discriminator [0,0,0,0,0,0,0,4] */
+    ShaFlat = 3
 }
+declare const POOL_SEED: Buffer$1<ArrayBuffer>;
+declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
+declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
+declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const MINT_TO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const TRANSFER_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const APPROVE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const REVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
 /**
- * Transfer tokens using the c-token interface.
- *
- * Matches SPL Token's transferChecked signature order. Destination must exist.
- *
- * @param rpc             RPC connection
- * @param payer           Fee payer (signer)
- * @param source          Source c-token ATA address
- * @param mint            Mint address
- * @param destination     Destination c-token ATA address (must exist)
- * @param owner           Source owner (signer)
- * @param amount          Amount to transfer
- * @param programId       Token program ID (default: CTOKEN_PROGRAM_ID)
- * @param confirmOptions  Optional confirm options
- * @param options         Optional interface options
- * @param wrap            Include SPL/T22 wrapping (default: false)
- * @returns Transaction signature
+ * Maximum lamports for rent top-up in a single instruction.
+ * u16::MAX = no limit; 0 = no top-ups allowed.
+ * Matches Rust SDK (e.g. token-sdk create_mints uses u16::MAX for "no limit").
  */
-declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, destination: PublicKey, owner: Signer, amount: number | bigint | BN, programId?: PublicKey, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, wrap?: boolean): Promise<TransactionSignature>;
-
+declare const MAX_TOP_UP = 65535;
 /**
- * Account info interface for compressible accounts.
- * Matches return structure of getAccountInterface/getAtaInterface.
- *
- * Integrating programs provide their own fetch/parse - this is just the data shape.
+ * Rent configuration constants for compressible light token accounts.
+ * These match the Rust SDK defaults in program-libs/compressible/src/rent/config.rs
  */
-interface ParsedAccountInfoInterface<T = unknown> {
-    /** Parsed account data (program-specific) */
-    parsed: T;
-    /** Load context - present if account is compressed (cold), undefined if hot */
-    loadContext?: MerkleContext;
-}
+/** Base rent per epoch (lamports) */
+declare const BASE_RENT_PER_EPOCH = 128;
+/** Rent per byte per epoch (lamports) */
+declare const RENT_PER_BYTE_PER_EPOCH = 1;
+/** Slots per rent epoch (1.5 hours) */
+declare const SLOTS_PER_RENT_EPOCH = 13500;
+/** Compression cost (lamports) - paid at account creation */
+declare const COMPRESSION_COST = 10000;
+/** Compression incentive (lamports) - paid at account creation */
+declare const COMPRESSION_INCENTIVE = 1000;
+/** Total compression cost (COMPRESSION_COST + COMPRESSION_INCENTIVE) */
+declare const TOTAL_COMPRESSION_COST: number;
 /**
- * Input for createLoadAccountsParams.
- * Supports both program PDAs and c-token vaults.
- *
- * The integrating program is responsible for fetching and parsing their accounts.
- * This helper just packs them for the decompressAccountsIdempotent instruction.
+ * Compressible light token account size in bytes.
+ * = 165 (base SPL token) + 1 (account_type) + 1 (Option) + 4 (Vec len) + 1 (ext disc) + 4 (ext header) + 96 (CompressionInfo) = 272
+ * Source: program-libs/token-interface/src/state/token/top_up.rs MIN_SIZE_WITH_COMPRESSIBLE
  */
-interface CompressibleAccountInput<T = unknown> {
-    /** Account address */
-    address: PublicKey;
-    /**
-     * Account type key for packing:
-     * - For PDAs: program-specific type name (e.g., "poolState", "observationState")
-     * - For c-token vaults: "cTokenData"
-     */
-    accountType: string;
-    /**
-     * Token variant - required when accountType is "cTokenData".
-     * Examples: "lpVault", "token0Vault", "token1Vault"
-     */
-    tokenVariant?: string;
-    /** Parsed account info (from program-specific fetch) */
-    info: ParsedAccountInfoInterface<T>;
-}
+declare const COMPRESSIBLE_LIGHT_TOKEN_ACCOUNT_SIZE = 272;
 /**
- * Packed compressed account for decompressAccountsIdempotent instruction
+ * Calculate rent per epoch for a given account size.
+ * Formula: base_rent + (bytes * lamports_per_byte_per_epoch)
  */
-interface PackedCompressedAccount {
-    [key: string]: unknown;
-    merkleContext: {
-        merkleTreePubkeyIndex: number;
-        queuePubkeyIndex: number;
-    };
-}
+declare function rentPerEpoch(bytes: number): number;
 /**
- * Result from building load params
+ * Default rent per epoch for a compressible light token account (272 bytes).
+ * = 128 + 272 = 400 lamports
  */
-interface CompressibleLoadParams {
-    /** Validity proof wrapped in option (null if all proveByIndex) */
-    proofOption: {
-        0: ValidityProof | null;
-    };
-    /** Packed compressed accounts data for instruction */
-    compressedAccounts: PackedCompressedAccount[];
-    /** Offset to system accounts in remainingAccounts */
-    systemAccountsOffset: number;
-    /** Account metas for remaining accounts */
-    remainingAccounts: AccountMeta[];
-}
+declare const COMPRESSIBLE_LIGHT_TOKEN_RENT_PER_EPOCH: number;
+/** Default prepaid epochs (24 hours = 16 epochs * 1.5h) */
+declare const DEFAULT_PREPAY_EPOCHS = 16;
+/** Default write top-up (lamports) - ~2 epochs rent */
+declare const DEFAULT_WRITE_TOP_UP = 766;
 /**
- * Result from createLoadAccountsParams
+ * Calculate fee payer cost at ATA creation.
+ * = compression_cost (11K) + (prepay_epochs * rent_per_epoch)
  */
-interface LoadResult {
-    /** Params for decompressAccountsIdempotent (null if no program accounts need decompressing) */
-    decompressParams: CompressibleLoadParams | null;
-    /** Instructions to load ATAs (create ATA, wrap SPL/T22, decompressInterface) */
-    ataInstructions: TransactionInstruction[];
-}
+declare function calculateFeePayerCostAtCreation(prepayEpochs?: number, accountBytes?: number): number;
+
 /**
- * Create params for loading program accounts and ATAs.
- *
- * Returns:
- * - decompressParams: for a caller program's standardized
- *   decompressAccountsIdempotent instruction
- * - ataInstructions: for loading user ATAs
- *
- * @param rpc              RPC connection
- * @param payer            Fee payer (needed for ATA instructions)
- * @param programId        Program ID for decompressAccountsIdempotent
- * @param programAccounts  PDAs and vaults (caller pre-fetches)
- * @param atas             User ATAs (fetched via getAtaInterface)
- * @param options          Optional load options
- * @returns                LoadResult with decompressParams and ataInstructions
- *
- * @example
- * ```typescript
- * const poolInfo = await myProgram.fetchPoolState(rpc, poolAddress);
- * const vault0Ata = getAssociatedTokenAddressInterface(token0Mint, poolAddress);
- * const vault0Info = await getAtaInterface(rpc, vault0Ata, poolAddress, token0Mint, undefined, CTOKEN_PROGRAM_ID);
- * const userAta = getAssociatedTokenAddressInterface(tokenMint, userWallet);
- * const userAtaInfo = await getAtaInterface(rpc, userAta, userWallet, tokenMint);
- *
- * const result = await createLoadAccountsParams(
- *     rpc,
- *     payer.publicKey,
- *     programId,
- *     [
- *         { address: poolAddress, accountType: 'poolState', info: poolInfo },
- *         { address: vault0, accountType: 'cTokenData', tokenVariant: 'token0Vault', info: vault0Info },
- *     ],
- *     [userAta],
- * );
+ * Create instruction for minting tokens from a light mint to compressed accounts.
+ * To mint to light-token associated token accounts across SPL/T22/light mints, use
+ * {@link createMintToInterfaceInstruction} instead.
  *
- * // Build transaction with both program decompress and ATA load
- * const instructions = [...result.ataInstructions];
- * if (result.decompressParams) {
- *     instructions.push(await program.methods
- *         .decompressAccountsIdempotent(
- *             result.decompressParams.proofOption,
- *             result.decompressParams.compressedAccounts,
- *             result.decompressParams.systemAccountsOffset,
- *         )
- *         .remainingAccounts(result.decompressParams.remainingAccounts)
- *         .instruction());
- * }
- * ```
+ * @param authority             Mint authority public key.
+ * @param payer                 Fee payer public key.
+ * @param validityProof         Validity proof for the light mint.
+ * @param merkleContext         Merkle context of the light mint.
+ * @param mintData              Mint instruction data.
+ * @param recipients            Array of recipients with amounts.
+ * @param outputStateTreeInfo   Optional output state tree info. Uses merkle
+ * context queue if not provided.
+ * @param tokenAccountVersion   Token account version (default:
+ * TokenDataVersion.ShaFlat).
+ * @param maxTopUp              Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createLoadAccountsParams(rpc: Rpc, payer: PublicKey, programId: PublicKey, programAccounts?: CompressibleAccountInput[], atas?: AccountInterface[], options?: InterfaceOptions): Promise<LoadResult>;
+declare function createMintToCompressedInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, recipients: Array<{
+    recipient: PublicKey;
+    amount: number | bigint;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion, maxTopUp?: number): TransactionInstruction;
+
 /**
- * Calculate compute units for compressible load operation
+ * Create mint-to instruction for SPL, Token-2022, or light-token mints.
+ * This instruction ONLY mints to light-token associated token accounts (hot).
+ *
+ * For light-token mints, the light mint account must exist (mint must be decompressed first).
+ *
+ * @param mintInterface   Mint interface (SPL, Token-2022, or light-token).
+ * @param destination     Destination onchain token account address.
+ * @param authority       Mint authority public key.
+ * @param payer           Fee payer public key.
+ * @param amount          Amount to mint.
+ * @param validityProof   Not used (legacy parameter, kept for compatibility).
+ * @param multiSigners    Multi-signature signer public keys (SPL/T22 only).
  */
-declare function calculateCompressibleLoadComputeUnits(compressedAccountCount: number, hasValidityProof: boolean): number;
+declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
 
 /**
  * Create a wrap instruction that moves tokens from an SPL/T22 account to a
- * c-token account.
+ * light-token account.
  *
  * @param source            Source SPL/T22 token account
- * @param destination       Destination c-token account
+ * @param destination       Destination light-token account
  * @param owner             Owner of the source account (signer)
  * @param mint              Mint address
  * @param amount            Amount to wrap,
  * @param splInterfaceInfo  SPL interface info for the compression
  * @param decimals          Mint decimals (required for transfer_checked)
  * @param payer             Fee payer (defaults to owner)
+ * @param maxTopUp          Optional cap on rent top-up (units of 1k lamports; default no cap)
  * @returns Instruction to wrap tokens
  */
-declare function createWrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey): TransactionInstruction;
+declare function createWrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey, maxTopUp?: number): TransactionInstruction;
+
+/**
+ * Create an unwrap instruction that moves tokens from a light-token account to an
+ * SPL/T22 account.
+ *
+ * @param source           Source light-token account
+ * @param destination      Destination SPL/T22 token account
+ * @param owner            Owner of the source account (signer)
+ * @param mint             Mint address
+ * @param amount           Amount to unwrap,
+ * @param splInterfaceInfo SPL interface info for the decompression
+ * @param decimals         Mint decimals (required for transfer_checked)
+ * @param payer            Fee payer (defaults to owner if not provided)
+ * @param maxTopUp         Optional cap on rent top-up (units of 1k lamports; default no cap)
+ * @returns TransactionInstruction to unwrap tokens
+ */
+declare function createUnwrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey, maxTopUp?: number): TransactionInstruction;
+declare function createUnwrapInstructions(rpc: Rpc, destination: PublicKey, owner: PublicKey, mint: PublicKey, decimals: number, amount?: number | bigint | BN, payer?: PublicKey, splInterfaceInfo?: SplInterfaceInfo, maxTopUp?: number, interfaceOptions?: InterfaceOptions, wrap?: boolean): Promise<TransactionInstruction[][]>;
+
+/**
+ * Create an instruction to freeze a decompressed light-token account.
+ *
+ * Freezing sets the account state to AccountState::Frozen, preventing
+ * transfers and other token operations. Only the mint's freeze_authority
+ * can freeze accounts.
+ *
+ * Account order per program:
+ * 0. token_account (mutable) - the light-token account to freeze
+ * 1. mint (readonly)         - the mint associated with the token account
+ * 2. freeze_authority        - must match mint.freeze_authority (signer)
+ *
+ * @param tokenAccount   The light-token account to freeze (must be Initialized)
+ * @param mint           The mint of the light-token account
+ * @param freezeAuthority The freeze authority of the mint (signer)
+ * @returns TransactionInstruction
+ */
+declare function createLightTokenFreezeAccountInstruction(tokenAccount: PublicKey, mint: PublicKey, freezeAuthority: PublicKey): TransactionInstruction;
+/**
+ * Create an instruction to thaw (unfreeze) a frozen light-token account.
+ *
+ * Thawing restores the account state from AccountState::Frozen to
+ * AccountState::Initialized, re-enabling token operations. Only the
+ * mint's freeze_authority can thaw accounts.
+ *
+ * Account order per program:
+ * 0. token_account (mutable) - the frozen light-token account to thaw
+ * 1. mint (readonly)         - the mint associated with the token account
+ * 2. freeze_authority        - must match mint.freeze_authority (signer)
+ *
+ * @param tokenAccount   The frozen light-token account to thaw
+ * @param mint           The mint of the light-token account
+ * @param freezeAuthority The freeze authority of the mint (signer)
+ * @returns TransactionInstruction
+ */
+declare function createLightTokenThawAccountInstruction(tokenAccount: PublicKey, mint: PublicKey, freezeAuthority: PublicKey): TransactionInstruction;
 
 /**
- * Create and initialize a new mint for SPL/T22/c-token.
+ * Create and initialize a new mint for SPL/T22/light-token.
  *
  * @param rpc                   RPC connection to use
  * @param payer                 Fee payer
- * @param mintAuthority         Account that will control minting (signer for c-token mints)
+ * @param mintAuthority         Account that will control minting (signer for light-token mints)
  * @param freezeAuthority       Account that will control freeze and thaw (optional)
  * @param decimals              Location of the decimal place
  * @param keypair               Mint keypair (defaults to a random keypair)
  * @param confirmOptions        Confirm options
- * @param programId             Token program ID (defaults to CTOKEN_PROGRAM_ID)
- * @param tokenMetadata         Optional token metadata (c-token mints only)
- * @param outputStateTreeInfo   Optional output state tree info (c-token mints only)
- * @param addressTreeInfo       Optional address tree info (c-token mints only)
+ * @param programId             Token program ID (defaults to LIGHT_TOKEN_PROGRAM_ID)
+ * @param tokenMetadata         Optional token metadata (light-token mints only)
+ * @param outputStateTreeInfo   Optional output state tree info (light-token mints only)
+ * @param addressTreeInfo       Optional address tree info (light-token mints only)
  *
  * @returns Object with mint address and transaction signature
  */
@@ -1891,7 +1904,8 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
 }>;
 
 /**
- * Update the mint authority of a compressed token mint.
+ * Update the mint authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc                    RPC connection
  * @param payer                  Fee payer (signer)
@@ -1902,7 +1916,8 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
  */
 declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentMintAuthority: Signer, newMintAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Update the freeze authority of a compressed token mint.
+ * Update the freeze authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc                      RPC connection
  * @param payer                    Fee payer (signer)
@@ -1914,7 +1929,8 @@ declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, c
 declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentFreezeAuthority: Signer, newFreezeAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Update a metadata field on a compressed token mint.
+ * Update a metadata field on a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -1928,7 +1944,8 @@ declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey,
  */
 declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Update the metadata authority of a compressed token mint.
+ * Update the metadata authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc              RPC connection
  * @param payer            Fee payer (signer)
@@ -1940,7 +1957,8 @@ declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, a
  */
 declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentAuthority: Signer, newAuthority: PublicKey, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Remove a metadata key from a compressed token mint.
+ * Remove a metadata key from a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -1954,8 +1972,8 @@ declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKe
 declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, key: string, idempotent?: boolean, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Create an associated token account for SPL/T22/c-token. Defaults to c-token
- * program.
+ * Create an associated token account for SPL/T22/light-token. Defaults to
+ * light-token program.
  *
  * @param rpc                       RPC connection
  * @param payer                     Fee payer and transaction signer
@@ -1964,16 +1982,16 @@ declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, aut
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional rent config
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  associated token account program ID
+ *                                  (auto-derived if not provided)
+ * @param lightTokenConfig              Optional rent config
  * @returns Address of the new associated token account
  */
-declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): Promise<PublicKey>;
 /**
- * Create an associated token account idempotently for SPL/T22/c-token. Defaults
- * to c-token program.
+ * Create an associated token account idempotently for SPL/T22/light-token.
+ * Defaults to light-token program.
  *
  * If the account already exists, the instruction succeeds without error.
  *
@@ -1984,19 +2002,35 @@ declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, ow
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional c-token-specific configuration
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  associated token account program ID
+ *                                  (auto-derived if not provided)
+ * @param lightTokenConfig              Optional light-token-specific configuration
  *
  * @returns Address of the associated token account
  */
-declare function createAtaInterfaceIdempotent(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+declare function createAtaInterfaceIdempotent(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): Promise<PublicKey>;
 
-declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, recipientAccount: PublicKey, authority: Signer, amount: number | bigint, outputQueue?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/**
+ * Mint tokens to a light-token account.
+ *
+ * This is a simple mint instruction for minting to light-token associated token accounts (hot).
+ * The light mint account must exist (mint must be decompressed first).
+ *
+ * @param rpc - RPC connection
+ * @param payer - Fee payer (signer)
+ * @param mint - Mint address (light mint account)
+ * @param destination - Destination light-token account
+ * @param authority - Mint authority (signer)
+ * @param amount - Amount to mint
+ * @param maxTopUp - Optional maximum lamports for rent top-up
+ * @param confirmOptions - Optional confirm options
+ * @returns Transaction signature
+ */
+declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | bigint, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Mint compressed tokens directly to compressed accounts.
+ * Mint light-tokens directly to compressed accounts.
  *
  * @param rpc                   RPC connection
  * @param payer                 Fee payer
@@ -2005,29 +2039,32 @@ declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, recipientAcc
  * @param recipients            Array of recipients with amounts
  * @param outputStateTreeInfo   Optional output state tree info (auto-fetched if not provided)
  * @param tokenAccountVersion   Token account version (default: 3)
+ * @param maxTopUp              Optional: cap on rent top-up (units of 1k lamports; default no cap)
  * @param confirmOptions        Optional confirm options
  */
 declare function mintToCompressed(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, recipients: Array<{
     recipient: PublicKey;
     amount: number | bigint;
-}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: number, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint tokens to a decompressed/onchain token account.
- * Works with SPL, Token-2022, and compressed token (c-token) mints.
+ * Works with SPL, Token-2022, and light-token mints.
+ *
+ * This function ONLY mints to light-token associated token accounts (hot), never to compressed light-token accounts (cold).
+ * For light-token mints, the light mint account must exist (mint must be decompressed first).
  *
- * This function ONLY mints to decompressed onchain token accounts, never to compressed accounts.
  * The signature matches the standard SPL mintTo for simplicity and consistency.
  *
  * @param rpc - RPC connection to use
  * @param payer - Transaction fee payer
- * @param mint - Mint address (SPL, Token-2022, or compressed mint)
+ * @param mint - Mint address (SPL, Token-2022, or light-token mint)
  * @param destination - Destination token account address (must be an existing onchain token account)
  * @param authority - Mint authority (can be Signer or PublicKey if multiSigners provided)
  * @param amount - Amount to mint
  * @param multiSigners - Optional: Multi-signature signers (default: [])
  * @param confirmOptions - Optional: Transaction confirmation options
- * @param programId - Optional: Token program ID (TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, or CTOKEN_PROGRAM_ID). If undefined, auto-detects.
+ * @param programId - Optional: Token program ID. If undefined, auto-detects.
  *
  * @returns Transaction signature
  */
@@ -2042,7 +2079,7 @@ declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, desti
  * @param mint                      Mint associated with the account to set or
  *                                  verify.
  * @param owner                     Owner of the account. Pass Signer to
- *                                  auto-load cold (compressed) tokens, or
+ *                                  auto-load compressed light-tokens (cold balance), or
  *                                  PublicKey for read-only.
  * @param allowOwnerOffCurve        Allow the owner account to be a PDA (Program
  *                                  Derived Address).
@@ -2050,7 +2087,7 @@ declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, desti
  *                                  state.
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (defaults to
- *                                  CTOKEN_PROGRAM_ID)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  Associated token program ID (auto-derived if
  *                                  not provided)
  *
@@ -2059,48 +2096,31 @@ declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, desti
 declare function getOrCreateAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey | Signer, allowOwnerOffCurve?: boolean, commitment?: Commitment, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey): Promise<AccountInterface>;
 
 /**
- * Decompress compressed (cold) tokens to an on-chain token account.
- *
- * For unified loading, use {@link loadAta} instead.
- *
- * @param rpc                  RPC connection
- * @param payer                Fee payer (signer)
- * @param owner                Owner of the compressed tokens (signer)
- * @param mint                 Mint address
- * @param amount               Amount to decompress (defaults to all)
- * @param destinationAta       Destination token account address
- * @param destinationOwner     Owner of the destination ATA
- * @param splInterfaceInfo     SPL interface info for SPL/T22 destinations
- * @param confirmOptions       Confirm options
- * @returns Transaction signature, null if nothing to load.
- */
-declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, mint: PublicKey, amount?: number | bigint | BN, destinationAta?: PublicKey, destinationOwner?: PublicKey, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature | null>;
-
-/**
- * Wrap tokens from an SPL/T22 account to a c-token account.
+ * Wrap tokens from an SPL/T22 account to a light-token account.
  *
  * This is an agnostic action that takes explicit account addresses (spl-token style).
- * Use getAssociatedTokenAddressSync() to derive ATA addresses if needed.
+ * Use getAssociatedTokenAddressSync() to derive associated token account addresses if needed.
  *
  * @param rpc             RPC connection
  * @param payer           Fee payer
- * @param source          Source SPL/T22 token account (any token account, not just ATA)
- * @param destination     Destination c-token account
+ * @param source          Source SPL/T22 token account (any token account, not just associated token account)
+ * @param destination     Destination light-token account
  * @param owner           Owner/authority of the source account (must sign)
  * @param mint            Mint address
  * @param amount          Amount to wrap
  * @param splInterfaceInfo Optional: SPL interface info (will be fetched if not provided)
+ * @param maxTopUp         Optional: cap on rent top-up (units of 1k lamports; default no cap)
  * @param confirmOptions  Optional: Confirm options
  *
  * @example
  * const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey, false, TOKEN_PROGRAM_ID);
- * const ctokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // defaults to c-token
+ * const lightTokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // defaults to light-token
  *
  * await wrap(
  *   rpc,
  *   payer,
  *   splAta,
- *   ctokenAta,
+ *   lightTokenAta,
  *   owner,
  *   mint,
  *   1000n,
@@ -2108,34 +2128,16 @@ declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, min
  *
  * @returns Transaction signature
  */
-declare function wrap(rpc: Rpc, payer: Signer, source: PublicKey, destination: PublicKey, owner: Signer, mint: PublicKey, amount: bigint, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function wrap(rpc: Rpc, payer: Signer, source: PublicKey, destination: PublicKey, owner: Signer, mint: PublicKey, amount: bigint, splInterfaceInfo?: SplInterfaceInfo, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Create instructions to load an ATA from its AccountInterface.
- *
- * Behavior depends on `wrap` parameter:
- * - wrap=false (standard): Decompress compressed tokens to the target ATA type
- *   (SPL ATA via pool, T22 ATA via pool, or c-token ATA direct)
- * - wrap=true (unified): Wrap SPL/T22 + decompress all to c-token ATA
- *
- * @param rpc         RPC connection
- * @param payer       Fee payer
- * @param ata         AccountInterface from getAtaInterface (must have _isAta, _owner, _mint)
- * @param options     Optional load options
- * @param wrap        Unified mode: wrap SPL/T22 to c-token (default: false)
- * @param targetAta   Target ATA address (used for type detection in standard mode)
- * @returns           Array of instructions (empty if nothing to load)
- */
-declare function createLoadAtaInstructionsFromInterface(rpc: Rpc, payer: PublicKey, ata: AccountInterface, options?: InterfaceOptions, wrap?: boolean, targetAta?: PublicKey): Promise<TransactionInstruction[]>;
-
-/**
- * Derive the canonical associated token address for any of SPL/T22/c-token.
- * Defaults to using c-token as the canonical ATA.
+ * Derive the canonical associated token address for any of SPL/T22/light-token.
+ * Defaults to using light-token as the canonical associated token account.
  *
  * @param mint                      Mint public key
  * @param owner                     Owner public key
  * @param allowOwnerOffCurve        Allow owner to be a PDA. Default false.
- * @param programId                 Token program ID. Default c-token.
+ * @param programId                 Token program ID. Default light-token.
  *
  * @param associatedTokenProgramId  Associated token program ID. Default
  *                                  auto-detected.
@@ -2191,7 +2193,7 @@ interface OffChainTokenMetadataJson {
  * const metadataJson = toOffChainMetadataJson({
  *     name: 'My Token',
  *     symbol: 'MTK',
- *     description: 'A compressed token',
+ *     description: 'A light-token',
  *     image: 'https://example.com/image.png',
  * });
  * const uri = await umi.uploader.uploadJson(metadataJson);
@@ -2373,9 +2375,13 @@ declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: nu
 
 /**
  * Merge multiple compressed token accounts for a given mint into fewer
- * accounts. Each call merges up to 4 accounts (V1) or 8 accounts (V2) at a
- * time. Call repeatedly until only 1 account remains if full consolidation
- * is needed.
+ * accounts. Each call merges up to 4 accounts at a time.
+ *
+ * Supports automatic V1 -> V2 migration: when running in V2 mode,
+ * merging V1 token accounts will produce a V2 output.
+ *
+ * IMPORTANT: Only accounts from the same tree type can be merged in one
+ * transaction. If you have mixed V1+V2 accounts, merge them separately.
  *
  * @param rpc                   RPC connection to use
  * @param payer                 Fee payer
@@ -2415,6 +2421,7 @@ declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: Publ
  * @param rpc                   Rpc connection to use
  * @param payer                 Fee payer
  * @param accounts              Delegated compressed token accounts to revoke
+ *                              (must all be from the same tree type)
  * @param owner                 Owner of the compressed tokens
  * @param confirmOptions        Options for confirming the transaction
  *
@@ -2423,7 +2430,10 @@ declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: Publ
 declare function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[], owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Transfer compressed tokens from one owner to another
+ * Transfer compressed tokens from one owner to another.
+ *
+ * Supports automatic V1 -> V2 migration: when running in V2 mode,
+ * V1 token inputs will produce V2 token outputs.
  *
  * @param rpc                   Rpc connection to use
  * @param payer                 Fee payer
@@ -2471,12 +2481,54 @@ declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amo
 declare function decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, splInterfaceInfos?: SplInterfaceInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
+declare const ERROR_MIXED_TREE_TYPES = "Cannot select accounts from different tree types (V1/V2) in the same batch. Filter accounts by tree type first.";
+/**
+ * Options for input account selection
+ */
+interface SelectInputAccountsOptions {
+    /**
+     * Filter accounts by tree type. If provided, only accounts in trees of
+     * this type will be selected. This prevents mixed V1/V2 batches which
+     * fail at proof generation.
+     */
+    treeType?: TreeType;
+}
+/**
+ * Groups accounts by tree type for separate processing
+ */
+declare function groupAccountsByTreeType(accounts: ParsedTokenAccount[]): Map<TreeType, ParsedTokenAccount[]>;
+/**
+ * Result of selectAccountsByPreferredTreeType
+ */
+interface SelectedAccountsResult {
+    /** The selected accounts (all from the same tree type) */
+    accounts: ParsedTokenAccount[];
+    /** The tree type of the selected accounts */
+    treeType: TreeType;
+    /** Total balance of selected accounts */
+    totalBalance: BN;
+}
+/**
+ * Selects accounts by preferred tree type with automatic fallback.
+ *
+ * In V2 mode, prefers StateV2 accounts. Falls back to StateV1 if V2
+ * has insufficient balance.
+ *
+ * This ensures all returned accounts are from the same tree type,
+ * preventing mixed V1/V2 batch proof failures.
+ *
+ * @param accounts All available accounts (can be mixed V1/V2)
+ * @param requiredAmount Minimum amount needed (optional - if not provided, returns all from preferred type)
+ * @returns Selected accounts from a single tree type
+ */
+declare function selectAccountsByPreferredTreeType(accounts: ParsedTokenAccount[], requiredAmount?: BN): SelectedAccountsResult;
 /**
  * Selects token accounts for approval, first trying to find an exact match, then falling back to minimum selection.
  *
  * @param {ParsedTokenAccount[]} accounts - Token accounts to choose from.
  * @param {BN} approveAmount - Amount to approve.
  * @param {number} [maxInputs=4] - Max accounts to select when falling back to minimum selection.
+ * @param {SelectInputAccountsOptions} [options] - Optional selection options.
  * @returns {[
  *   selectedAccounts: ParsedTokenAccount[],
  *   total: BN,
@@ -2488,7 +2540,7 @@ declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for t
  *   - totalLamports: Total lamports from selected accounts.
  *   - maxPossibleAmount: Max approvable amount given maxInputs.
  */
-declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number): [
+declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
@@ -2502,10 +2554,11 @@ declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], a
  * @param {BN} amount                       Amount to decompress.
  * @param {number} [maxInputs=4]            Max accounts to select. Default
  *                                          is 4.
+ * @param {SelectInputAccountsOptions} [options] - Optional selection options.
  *
  * @returns Returns selected accounts and their totals.
  */
-declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number): {
+declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): {
     selectedAccounts: ParsedTokenAccount[];
     total: BN;
     totalLamports: BN | null;
@@ -2519,6 +2572,8 @@ declare function selectMinCompressedTokenAccountsForDecompression(accounts: Pars
  * @param {BN} transferAmount               Amount to transfer or decompress.
  * @param {number} [maxInputs=4]            Max accounts to select. Default
  *                                          is 4.
+ * @param {SelectInputAccountsOptions} [options] - Optional selection options.
+ *                                          Use treeType to filter by V1/V2.
  *
  * @returns Returns selected accounts and their totals. [
  *   selectedAccounts: ParsedTokenAccount[],
@@ -2527,7 +2582,7 @@ declare function selectMinCompressedTokenAccountsForDecompression(accounts: Pars
  *   maxPossibleAmount: BN
  * ]
  */
-declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
@@ -2555,6 +2610,8 @@ declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts:
  * @param {ParsedTokenAccount[]} accounts - The list of token accounts to select from.
  * @param {BN} transferAmount - The token amount to be transferred.
  * @param {number} [maxInputs=4] - The maximum number of accounts to select. Default: 4.
+ * @param {SelectInputAccountsOptions} [options] - Optional selection options.
+ *                                          Use treeType to filter by V1/V2.
  * @returns {[
  *   selectedAccounts: ParsedTokenAccount[],
  *   total: BN,
@@ -2583,7 +2640,7 @@ declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts:
  * console.log(totalLamports!.toString()); // '15'
  * console.log(maxPossibleAmount.toString()); // '150'
  */
-declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
@@ -2765,9 +2822,9 @@ type PackCompressedTokenAccountsParams = {
     /** Input state to be consumed */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
     /**
-     * State trees that the output should be inserted into. Defaults to the 0th
-     * state tree of the input state. Gets padded to the length of
-     * outputCompressedAccounts.
+     * Output state tree. Required for mint/compress (no inputs).
+     * For transfer/merge with V1 inputs: pass a V2 tree for migration.
+     * If not provided with inputs, uses input tree.
      */
     outputStateTreeInfo?: TreeInfo;
     /** Optional remaining accounts to append to */
@@ -5175,14 +5232,14 @@ declare class CompressedTokenProgram {
      * @param mintSize              Optional: mint size. Default: MINT_SIZE
      *
      * @returns [createMintAccountInstruction, initializeMintInstruction,
-     * createTokenPoolInstruction]
+     * createSplInterfaceInstruction]
      *
-     * Note that `createTokenPoolInstruction` must be executed after
+     * Note that `createSplInterfaceInstruction` must be executed after
      * `initializeMintInstruction`.
      */
     static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * Create SPL interface (omnibus account) for an existing SPL mint.
      * For new mints, use `CompressedTokenProgram.createMint`.
      *
      * @param feePayer              Fee payer.
@@ -5190,12 +5247,16 @@ declare class CompressedTokenProgram {
      * @param tokenProgramId        Optional: Token program ID. Default: SPL
      *                              Token Program ID
      *
-     * @returns The createTokenPool instruction
+     * @returns The createSplInterface instruction
      */
-    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    static createSplInterface({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    /**
+     * @deprecated Use {@link createSplInterface} instead.
+     */
+    static createTokenPool(params: CreateSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Add a token pool to an existing SPL mint.  For new mints, use
-     * {@link createTokenPool}.
+     * {@link createSplInterface}.
      *
      * @param feePayer              Fee payer.
      * @param mint                  SPL Mint address.
@@ -5237,7 +5298,9 @@ declare class CompressedTokenProgram {
      */
     static approveAndMintTo({ feePayer, mint, authority, authorityTokenAccount, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
     /**
-     * Construct transfer instruction for compressed tokens
+     * Construct transfer instruction for compressed tokens.
+     *
+     * V1 inputs automatically migrate to V2 outputs when in V2 mode.
      *
      * @param payer                         Fee payer.
      * @param inputCompressedTokenAccounts  Source compressed token accounts.
@@ -5296,7 +5359,7 @@ declare class CompressedTokenProgram {
      */
     static decompress({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, tokenPoolInfos, }: DecompressParams): Promise<TransactionInstruction>;
     /**
-     * Create `mergeTokenAccounts` instruction
+     * Create `mergeTokenAccounts` instruction.
      *
      * @param payer                         Fee payer.
      * @param owner                         Owner of the compressed token
@@ -5305,7 +5368,6 @@ declare class CompressedTokenProgram {
      * @param mint                          SPL Token mint address.
      * @param recentValidityProof           Recent validity proof.
      * @param recentInputStateRootIndices   Recent state root indices.
-     *
      * @returns instruction
      */
     static mergeTokenAccounts({ payer, owner, inputCompressedTokenAccounts, mint, recentValidityProof, recentInputStateRootIndices, }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
@@ -5358,6 +5420,36 @@ declare class CompressedTokenProgram {
     static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
+/** Solana maximum transaction size in bytes. */
+declare const MAX_TRANSACTION_SIZE = 1232;
+/**
+ * Conservative size budget for a combined batch (load + transfer + ATA).
+ * Leaves headroom below MAX_TRANSACTION_SIZE for edge-case key counts.
+ */
+declare const MAX_COMBINED_BATCH_BYTES = 900;
+/**
+ * Conservative size budget for a load-only or setup-only batch.
+ */
+declare const MAX_LOAD_ONLY_BATCH_BYTES = 1000;
+/**
+ * Estimate the serialized byte size of a V0 VersionedTransaction built from
+ * the given instructions and signer count.
+ *
+ * The estimate accounts for Solana's account-key deduplication: all unique
+ * pubkeys across every instruction (keys + programIds) are collected into a
+ * single set, matching the behaviour of
+ * `TransactionMessage.compileToV0Message`.
+ *
+ * This intentionally does NOT use address lookup tables, so the result is an
+ * upper bound. If lookup tables are used at send time the actual size will be
+ * smaller.
+ *
+ * @param instructions  The instructions that will be included in the tx.
+ * @param numSigners    Number of signers (determines signature count).
+ * @returns Estimated byte size of the serialized transaction.
+ */
+declare function estimateTransactionSize(instructions: TransactionInstruction[], numSigners: number): number;
+
 /**
  * Retrieve associated token account for a given owner and mint.
  *
@@ -5371,19 +5463,20 @@ declare class CompressedTokenProgram {
  */
 declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
- * Create instructions to load token balances into a c-token ATA.
+ * Create instruction batches for loading token balances into an ATA.
+ * Returns batches of instructions, each batch is one transaction.
  *
- * @param rpc     RPC connection
- * @param ata     Associated token address
- * @param owner   Owner public key
- * @param mint    Mint public key
- * @param payer   Fee payer (defaults to owner)
- * @param options Optional load options
- * @returns       Array of instructions (empty if nothing to load)
+ * @param rpc               RPC connection
+ * @param ata               Associated token address
+ * @param owner             Owner public key
+ * @param mint              Mint public key
+ * @param payer             Fee payer (defaults to owner)
+ * @param options           Optional load options
+ * @returns Instruction batches - each inner array is one transaction
  */
-declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, payer?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[]>;
+declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, payer?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
 /**
- * Load token balances into a c-token ATA.
+ * Load token balances into a light-token ATA.
  *
  * @param rpc               RPC connection
  * @param ata               Associated token address
@@ -5394,6 +5487,6 @@ declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: Publ
  * @param interfaceOptions  Optional interface options
  * @returns Transaction signature, or null if nothing to load
  */
-declare function loadAta(rpc: Rpc, ata: PublicKey, owner: Signer, mint: PublicKey, payer?: Signer, confirmOptions?: ConfirmOptions, interfaceOptions?: InterfaceOptions): Promise<TransactionSignature | null>;
+declare function loadAta(rpc: Rpc, ata: PublicKey, owner: Signer, mint: PublicKey, payer?: Signer, confirmOptions?: ConfirmOptions, interfaceOptions?: InterfaceOptions, decimals?: number): Promise<TransactionSignature | null>;
 
-export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CTokenConfig, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleAccountInput, type CompressibleConfig, type CompressibleLoadParams, CpiContextLayout, type CreateAssociatedCTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, type LightCompressedToken, type LoadResult, MINT_TO_DISCRIMINATOR, type MergeTokenAccountsParams, type MintContext, type MintExtension, type MintInterface, type MintToInstructionData, type MintToParams, type OffChainTokenMetadata, type OffChainTokenMetadataJson, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedCompressedAccount, type PackedTokenTransferOutputData, type ParsedAccountInfoInterface, REVOKE_DISCRIMINATOR, type RevokeParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type SplInterfaceActivity, type SplInterfaceInfo, TRANSFER_DISCRIMINATOR, type TokenAccountSource, type TokenData, TokenDataVersion, type TokenMetadata, type TokenMetadataInstructionData, type TokenPoolActivity, type TokenPoolInfo, type TokenTransferOutputData, type TransferParams, addSplInterfaces, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, calculateCompressibleLoadComputeUnits, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createAssociatedCTokenAccountIdempotentInstruction, createAssociatedCTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createCTokenTransferInstruction, createDecompressInterfaceInstruction, createDecompressOutputState, createLoadAccountsParams, createLoadAtaInstructions, createLoadAtaInstructionsFromInterface, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstruction, createTransferOutputState, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, decompressInterface, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, extractTokenMetadata, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedTokenAddressInterface, getAtaInterface, getMintInterface, getOrCreateAtaInterface, getSplInterfaceInfos, getTokenPoolInfos, isSingleSplInterfaceInfo, isSingleTokenPoolInfo, loadAta, mergeTokenAccounts, mintTo, mintToAccountsLayout, type mintToAccountsLayoutParams, mintTo$1 as mintToCToken, mintToCompressed, mintToInterface, mintToLayout, packCompressedTokenAccounts, parseCTokenCold, parseCTokenHot, parseMaybeDelegatedTransfer, parseTokenData, removeMetadataKey, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, selectMinCompressedTokenAccountsForDecompression, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, selectSplInterfaceInfo, selectSplInterfaceInfosForDecompression, selectTokenAccountsForApprove, selectTokenPoolInfo, selectTokenPoolInfosForDecompression, serializeMint, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, toAccountInfo, toOffChainMetadataJson, toTokenPoolInfo, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, transferInterface, unpackMintData, unpackMintInterface, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };
+export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BASE_RENT_PER_EPOCH, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESSIBLE_LIGHT_TOKEN_ACCOUNT_SIZE, COMPRESSIBLE_LIGHT_TOKEN_RENT_PER_EPOCH, COMPRESSION_COST, COMPRESSION_INCENTIVE, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleConfig, CpiContextLayout, type CreateAssociatedLightTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DEFAULT_COMPRESSIBLE_CONFIG, DEFAULT_PREPAY_EPOCHS, DEFAULT_WRITE_TOP_UP, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_MIXED_TREE_TYPES, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR, type LightCompressedToken, type LightTokenConfig, CompressedTokenProgram as LightTokenProgram, MAX_COMBINED_BATCH_BYTES, MAX_LOAD_ONLY_BATCH_BYTES, MAX_TOP_UP, MAX_TRANSACTION_SIZE, MINT_TO_DISCRIMINATOR, type MergeTokenAccountsParams, type MintContext, type MintExtension, type MintInterface, type MintToInstructionData, type MintToParams, type OffChainTokenMetadata, type OffChainTokenMetadataJson, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedTokenTransferOutputData, RENT_PER_BYTE_PER_EPOCH, REVOKE_DISCRIMINATOR, type RevokeParams, SLOTS_PER_RENT_EPOCH, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type SelectInputAccountsOptions, type SelectedAccountsResult, type SplInterfaceActivity, type SplInterfaceInfo, TOTAL_COMPRESSION_COST, TRANSFER_DISCRIMINATOR, type TokenAccountSource, type TokenData, TokenDataVersion, type TokenMetadata, type TokenMetadataInstructionData, type TokenPoolActivity, type TokenPoolInfo, type TokenTransferOutputData, type TransferParams, addSplInterfaces, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, calculateFeePayerCostAtCreation, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createAssociatedLightTokenAccountIdempotentInstruction, createAssociatedLightTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createDecompressOutputState, createLightTokenFreezeAccountInstruction, createLightTokenThawAccountInstruction, createLightTokenTransferCheckedInstruction, createLightTokenTransferInstruction, createLoadAtaInstructions, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstructions, createTransferOutputState, createUnwrapInstruction, createUnwrapInstructions, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, estimateTransactionSize, extractTokenMetadata, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedTokenAddressInterface, getAtaInterface, getMintInterface, getOrCreateAtaInterface, getSplInterfaceInfos, getTokenPoolInfos, groupAccountsByTreeType, isSingleSplInterfaceInfo, isSingleTokenPoolInfo, loadAta, mergeTokenAccounts, mintTo, mintToAccountsLayout, type mintToAccountsLayoutParams, mintToCompressed, mintToInterface, mintToLayout, mintTo$1 as mintToLightToken, packCompressedTokenAccounts, parseLightTokenCold, parseLightTokenHot, parseMaybeDelegatedTransfer, parseTokenData, removeMetadataKey, rentPerEpoch, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, selectAccountsByPreferredTreeType, selectInputsForAmount, selectMinCompressedTokenAccountsForDecompression, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, selectSplInterfaceInfo, selectSplInterfaceInfosForDecompression, selectTokenAccountsForApprove, selectTokenPoolInfo, selectTokenPoolInfosForDecompression, serializeMint, sliceLast, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, toAccountInfo, toOffChainMetadataJson, toTokenPoolInfo, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, transferInterface, unpackMintData, unpackMintInterface, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };