@lightprotocol/compressed-token 0.23.0-beta.9 → 0.23.0

package/dist/types/index.d.ts

@@ -1,84 +1,23 @@
 /// <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,
-    TreeType,
-    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';
 
 declare class Buffer$1 extends Uint8Array {
-    length: number;
-    write(
-        string: string,
-        offset?: number,
-        length?: number,
-        encoding?: string,
-    ): number;
+    length: number
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
     toString(encoding?: string, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer'; data: any[] };
+    toJSON(): { type: 'Buffer', data: any[] };
     equals(otherBuffer: Buffer$1): boolean;
-    compare(
-        otherBuffer: Uint8Array,
-        targetStart?: number,
-        targetEnd?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
-    copy(
-        targetBuffer: Buffer$1,
-        targetStart?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
+    compare(otherBuffer: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+    copy(targetBuffer: Buffer$1, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
     slice(start?: number, end?: number): Buffer$1;
-    writeUIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeUIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
+    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
     readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
@@ -124,21 +63,9 @@ declare class Buffer$1 extends Uint8Array {
     writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
     writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
     fill(value: any, offset?: number, end?: number): this;
-    indexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    lastIndexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    includes(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): boolean;
+    indexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    includes(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): boolean;
 
     /**
      * Allocates a new buffer containing the given {str}.
@@ -146,19 +73,19 @@ declare class Buffer$1 extends Uint8Array {
      * @param str String to store in buffer.
      * @param encoding encoding to use, optional.  Default is 'utf8'
      */
-    constructor(str: string, encoding?: string);
+    constructor (str: string, encoding?: string);
     /**
      * Allocates a new buffer of {size} octets.
      *
      * @param size count of octets to allocate.
      */
-    constructor(size: number);
+    constructor (size: number);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: Uint8Array);
+    constructor (array: Uint8Array);
     /**
      * Produces a Buffer backed by the same allocated memory as
      * the given {ArrayBuffer}.
@@ -166,19 +93,19 @@ declare class Buffer$1 extends Uint8Array {
      *
      * @param arrayBuffer The ArrayBuffer with which to share memory.
      */
-    constructor(arrayBuffer: ArrayBuffer);
+    constructor (arrayBuffer: ArrayBuffer);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: any[]);
+    constructor (array: any[]);
     /**
      * Copies the passed {buffer} data onto a new {Buffer} instance.
      *
      * @param buffer The buffer to copy.
      */
-    constructor(buffer: Buffer$1);
+    constructor (buffer: Buffer$1);
     prototype: Buffer$1;
     /**
      * Allocates a new Buffer using an {array} of octets.
@@ -196,11 +123,7 @@ declare class Buffer$1 extends Uint8Array {
      * @param byteOffset
      * @param length
      */
-    static from(
-        arrayBuffer: ArrayBuffer,
-        byteOffset?: number,
-        length?: number,
-    ): Buffer$1;
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer$1;
     /**
      * Copies the passed {buffer} data onto a new Buffer instance.
      *
@@ -260,11 +183,7 @@ declare class Buffer$1 extends Uint8Array {
      *    If parameter is omitted, buffer will be filled with zeros.
      * @param encoding encoding used for call to buf.fill while initializing
      */
-    static alloc(
-        size: number,
-        fill?: string | Buffer$1 | number,
-        encoding?: string,
-    ): Buffer$1;
+    static alloc(size: number, fill?: string | Buffer$1 | number, encoding?: string): Buffer$1;
     /**
      * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.
@@ -420,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;
@@ -429,15 +348,9 @@ interface TokenMetadataInstructionData {
     updateAuthority?: PublicKey | null;
     additionalMetadata: AdditionalMetadata[] | null;
 }
-declare function createTokenMetadata(
-    name: string,
-    symbol: string,
-    uri: string,
-    updateAuthority?: PublicKey | null,
-    additionalMetadata?: AdditionalMetadata[] | null,
-): 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.
@@ -450,18 +363,7 @@ declare function createTokenMetadata(
  * @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,
-    maxTopUp?: number,
-): 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
@@ -479,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;
@@ -522,7 +424,7 @@ interface TokenMetadata {
     }[];
 }
 /**
- * Complete compressed mint structure (raw format)
+ * Complete light mint structure (raw format)
  */
 interface CompressedMint {
     base: BaseMint;
@@ -551,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) */
@@ -576,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;
@@ -595,7 +497,7 @@ declare function serializeMint(mint: CompressedMint): Buffer$1;
  * Extension type constants
  */
 declare enum ExtensionType {
-    TokenMetadata = 19,
+    TokenMetadata = 19
 }
 /**
  * Decode TokenMetadata from raw extension data using Borsh layout
@@ -613,9 +515,7 @@ declare function encodeTokenMetadata(metadata: TokenMetadata): Buffer$1;
  * @param extensions - Array of raw extensions
  * @returns Parsed TokenMetadata or null if not found
  */
-declare function extractTokenMetadata(
-    extensions: MintExtension[] | null,
-): TokenMetadata | null;
+declare function extractTokenMetadata(extensions: MintExtension[] | null): TokenMetadata | null;
 /**
  * Metadata portion of MintInstructionData
  * Used for instruction encoding when metadata extension is present
@@ -652,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
@@ -666,27 +566,18 @@ interface MintInterface {
  * @returns Object with mint, optional merkleContext, mintContext, and
  * tokenMetadata
  */
-declare function getMintInterface(
-    rpc: Rpc,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<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'>;
+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
@@ -698,27 +589,20 @@ declare function unpackMintData(data: Buffer$1 | Uint8Array): {
 };
 
 /**
- * Create instruction for updating a compressed mint's mint authority.
- * Works for both compressed and decompressed mints.
+ * 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 (null for decompressed mints)
+ * @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 | null,
-    maxTopUp?: number,
-): 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.
- * Works for both compressed and decompressed mints.
+ * 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).
@@ -727,20 +611,13 @@ declare function createUpdateMintAuthorityInstruction(
  * @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 (null for decompressed mints)
+ * @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 | null,
-    maxTopUp?: number,
-): 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).
@@ -748,26 +625,16 @@ declare function createUpdateFreezeAuthorityInstruction(
  * @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 (null for decompressed mints)
+ * @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 | null,
-    fieldType: 'name' | 'symbol' | 'uri' | 'custom',
-    value: string,
-    customKey?: string,
-    extensionIndex?: number,
-    maxTopUp?: 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).
@@ -776,21 +643,13 @@ declare function createUpdateMetadataFieldInstruction(
  * @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 (null for decompressed mints)
+ * @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 | null,
-    extensionIndex?: number,
-    maxTopUp?: 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).
@@ -798,22 +657,13 @@ declare function createUpdateMetadataAuthorityInstruction(
  * @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 (null for decompressed mints)
+ * @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 | null,
-    key: string,
-    idempotent?: boolean,
-    extensionIndex?: number,
-    maxTopUp?: 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;
@@ -827,11 +677,11 @@ interface CompressibleConfig {
     writeTopUp: number;
     compressToAccountPubkey?: CompressToPubkey | null;
 }
-interface CreateAssociatedCTokenAccountParams {
+interface CreateAssociatedLightTokenAccountParams {
     compressibleConfig?: CompressibleConfig | null;
 }
 /**
- * Default compressible config for c-token ATAs - matches Rust SDK defaults.
+ * 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)
@@ -839,7 +689,7 @@ interface CreateAssociatedCTokenAccountParams {
  * - writeTopUp: 766 - per-write top-up (~2 epochs rent) when rent < 2 epochs
  * - compressToAccountPubkey: null - required for ATAs
  *
- * Cost breakdown at ATA creation:
+ * 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
  *
@@ -847,7 +697,7 @@ interface CreateAssociatedCTokenAccountParams {
  * - 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 ctoken account):
+ * 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)
@@ -863,7 +713,7 @@ interface CreateAssociatedCTokenAccountParams {
  */
 declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
 /**
- * Create instruction for creating an associated compressed token account.
+ * Create instruction for creating an associated light-token account.
  * Uses the default rent sponsor PDA by default.
  *
  * @param feePayer          Fee payer public key.
@@ -873,16 +723,9 @@ declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
  * @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 | null,
-    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.
@@ -892,26 +735,19 @@ declare function createAssociatedCTokenAccountInstruction(
  * @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 | null,
-    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 {
+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.
@@ -920,20 +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.
- */
-declare function createAssociatedTokenAccountInterfaceInstruction(
-    payer: PublicKey,
-    associatedToken: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-    ctokenConfig?: CTokenConfig,
-): TransactionInstruction;
+ * @param lightTokenConfig             Optional light-token-specific configuration.
+ */
+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.
@@ -942,211 +770,17 @@ declare function createAssociatedTokenAccountInterfaceInstruction(
  * @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.
- */
-declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(
-    payer: PublicKey,
-    associatedToken: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-    ctokenConfig?: CTokenConfig,
-): TransactionInstruction;
+ * @param lightTokenConfig             Optional light-token-specific configuration.
+ */
+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;
 
-/**
- * Parameters for creating a MintTo instruction.
- */
-interface CreateMintToInstructionParams {
-    /** Mint account (CMint - decompressed compressed mint) */
-    mint: PublicKey;
-    /** Destination CToken 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;
-}
-/**
- * Create instruction for minting tokens to a CToken account.
- *
- * This is a simple 3-4 account instruction for minting to decompressed CToken accounts.
- * Uses discriminator 7 (CTokenMintTo).
- *
- * @param params - Mint instruction parameters
- * @returns TransactionInstruction for minting tokens
- */
-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;
-/**
- * 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>;
-/**
- * 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 const MAX_TOP_UP = 65535;
-/**
- * Rent configuration constants for compressible ctoken accounts.
- * These match the Rust SDK defaults in program-libs/compressible/src/rent/config.rs
- */
-/** 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;
-/**
- * Compressible ctoken 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
- */
-declare const COMPRESSIBLE_CTOKEN_ACCOUNT_SIZE = 272;
-/**
- * Calculate rent per epoch for a given account size.
- * Formula: base_rent + (bytes * lamports_per_byte_per_epoch)
- */
-declare function rentPerEpoch(bytes: number): number;
-/**
- * Default rent per epoch for a compressible ctoken account (272 bytes).
- * = 128 + 272 = 400 lamports
- */
-declare const COMPRESSIBLE_CTOKEN_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;
-/**
- * Calculate fee payer cost at ATA creation.
- * = compression_cost (11K) + (prepay_epochs * rent_per_epoch)
- */
-declare function calculateFeePayerCostAtCreation(
-    prepayEpochs?: number,
-    accountBytes?: number,
-): number;
-
-/**
- * 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).
- * @param maxTopUp              Optional cap on rent top-up (units of 1k lamports; default no cap)
- */
-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;
-
-/**
- * Create mint-to instruction for SPL, Token-2022, or CToken mints.
- * This instruction ONLY mints to decompressed/onchain token accounts.
- *
- * For CToken mints, the mint must be decompressed first (CMint account must exist on-chain).
- *
- * @param mintInterface   Mint interface (SPL, Token-2022, or CToken).
- * @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 createMintToInterfaceInstruction(
-    mintInterface: MintInterface,
-    destination: PublicKey,
-    authority: PublicKey,
-    payer: PublicKey,
-    amount: number | bigint,
-    validityProof?: ValidityProofWithContext,
-    multiSigners?: PublicKey[],
-): TransactionInstruction;
-
-/**
- * Create a Light token transfer instruction.
- *
- * For c-token accounts with compressible extension, the program needs
- * system_program and fee_payer to handle rent top-ups.
- *
- * @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
- * @param feePayer      Optional fee payer for top-ups (defaults to owner)
- * @returns Transaction instruction for Light token transfer
- */
-declare function createLightTokenTransferInstruction(
-    source: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    feePayer?: PublicKey,
-): TransactionInstruction;
-
 declare namespace BN {
-    type Endianness = 'le' | 'be';
-    type IPrimeName = 'k256' | 'p224' | 'p192' | 'p25519';
+    type Endianness = "le" | "be";
+    type IPrimeName = "k256" | "p224" | "p192" | "p25519";
 
     interface MPrime {
         name: string;
@@ -1168,7 +802,7 @@ declare class BN {
 
     constructor(
         number: bigint | number | string | number[] | Uint8Array | Buffer | BN,
-        base?: number | 'hex',
+        base?: number | "hex",
         endian?: BN.Endianness,
     );
     constructor(
@@ -1214,7 +848,7 @@ declare class BN {
     /**
      * @description  convert to base-string and pad with zeroes
      */
-    toString(base?: number | 'hex', length?: number): string;
+    toString(base?: number | "hex", length?: number): string;
 
     /**
      * @description convert to Javascript Number (limited to 53 bits)
@@ -1474,11 +1108,7 @@ declare class BN {
     /**
      * @description division with remainder
      */
-    divmod(
-        b: BN,
-        mode?: 'div' | 'mod',
-        positive?: boolean,
-    ): { div: BN; mod: BN };
+    divmod(b: BN, mode?: "div" | "mod", positive?: boolean): { div: BN; mod: BN };
 
     /**
      * @description reduct
@@ -1741,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.
  */
@@ -1846,21 +1547,14 @@ declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
  *
  * @returns SplInterfaceInfo for the to-be-initialized interface
  */
-declare function deriveSplInterfaceInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): SplInterfaceInfo;
+declare function deriveSplInterfaceInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): SplInterfaceInfo;
 /**
  * Check if the SPL interface info is initialized and has a balance.
  * @param mint The mint of the SPL interface
  * @param splInterfaceInfo The SPL interface info (or TokenPoolInfo for backward compatibility)
  * @returns True if the SPL interface info is initialized and has a balance
  */
-declare function checkSplInterfaceInfo(
-    splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare function checkSplInterfaceInfo(splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo, mint: PublicKey): boolean;
 /**
  * Get the SPL interface infos for a given mint.
  * @param rpc         The RPC client
@@ -1869,11 +1563,7 @@ declare function checkSplInterfaceInfo(
  *
  * @returns The SPL interface infos
  */
-declare function getSplInterfaceInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<SplInterfaceInfo[]>;
+declare function getSplInterfaceInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<SplInterfaceInfo[]>;
 type SplInterfaceActivity = {
     signature: string;
     amount: BN;
@@ -1885,7 +1575,7 @@ type SplInterfaceActivity = {
 declare enum Action {
     Compress = 1,
     Decompress = 2,
-    Transfer = 3,
+    Transfer = 3
 }
 /**
  * For `compress` and `mintTo` instructions only.
@@ -1897,9 +1587,7 @@ declare enum Action {
  *
  * @returns A random SPL interface info
  */
-declare function selectSplInterfaceInfo(
-    infos: SplInterfaceInfo[],
-): SplInterfaceInfo;
+declare function selectSplInterfaceInfo(infos: SplInterfaceInfo[]): SplInterfaceInfo;
 /**
  * Select one or multiple SPL interface infos from the SPL interface infos.
  *
@@ -1912,10 +1600,7 @@ declare function selectSplInterfaceInfo(
  *
  * @returns Array with one or more SPL interface infos.
  */
-declare function selectSplInterfaceInfosForDecompression(
-    infos: SplInterfaceInfo[],
-    decompressAmount: number | BN,
-): SplInterfaceInfo[];
+declare function selectSplInterfaceInfosForDecompression(infos: SplInterfaceInfo[], decompressAmount: number | BN): SplInterfaceInfo[];
 /**
  * @deprecated Use {@link SplInterfaceActivity} instead.
  */
@@ -1923,26 +1608,15 @@ type TokenPoolActivity = SplInterfaceActivity;
 /**
  * @deprecated Use {@link deriveSplInterfaceInfo} instead.
  */
-declare function deriveTokenPoolInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): TokenPoolInfo;
+declare function deriveTokenPoolInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): TokenPoolInfo;
 /**
  * @deprecated Use {@link checkSplInterfaceInfo} instead.
  */
-declare function checkTokenPoolInfo(
-    tokenPoolInfo: TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
 /**
  * @deprecated Use {@link getSplInterfaceInfos} instead.
  */
-declare function getTokenPoolInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<TokenPoolInfo[]>;
+declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
 /**
  * @deprecated Use {@link selectSplInterfaceInfo} instead.
  */
@@ -1950,388 +1624,196 @@ declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
 /**
  * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
  */
-declare function selectTokenPoolInfosForDecompression(
-    infos: TokenPoolInfo[],
-    decompressAmount: number | BN,
-): TokenPoolInfo[];
+declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
 
-/**
- * Create decompressInterface instruction using Transfer2.
- *
- * 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
- *
- * @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)
- * @param maxTopUp                     Optional cap on rent top-up (units of 1k lamports; default no cap)
- * @returns TransactionInstruction
- */
-declare function createDecompressInterfaceInstruction(
-    payer: PublicKey,
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    toAddress: PublicKey,
-    amount: bigint,
-    validityProof: ValidityProofWithContext,
-    splInterfaceInfo: SplInterfaceInfo | undefined,
-    decimals: number,
-    maxTopUp?: number,
-): 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 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;
-}
-/** @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 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;
+declare function sliceLast<T>(items: T[]): {
+    rest: T[];
+    last: T;
 };
+
 /**
- * Retrieve information about a token account of SPL/T22/c-token.
+ * Create a light-token transfer instruction.
  *
- * @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.
+ * For light-token accounts with compressible extension, the program needs
+ * system_program and fee_payer to handle rent top-ups.
  *
- * @return Token account information with compression context if applicable
+ * @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 getAccountInterface(
-    rpc: Rpc,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<AccountInterface>;
-
+declare function createLightTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
 /**
- * Options for interface operations (load, transfer)
+ * 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 createTransferToAccountInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, owner: PublicKey, destination: PublicKey, decimals: number, options?: InterfaceOptions, programId?: PublicKey): Promise<TransactionInstruction[][]>;
+
 interface InterfaceOptions {
-    /** SPL interface infos (fetched if not provided) */
     splInterfaceInfos?: SplInterfaceInfo[];
-}
-/**
- * Transfer tokens using the c-token interface.
- *
- * High-level action: resolves balances, builds all instructions (load +
- * transfer), signs, and sends. Creates the recipient ATA if it does not exist.
- *
- * For instruction-level control, use `createTransferInterfaceInstructions`.
- *
- * @param rpc             RPC connection
- * @param payer           Fee payer (signer)
- * @param source          Source c-token ATA address
- * @param mint            Mint address
- * @param destination     Recipient wallet public key
- * @param owner           Source owner (signer)
- * @param amount          Amount to transfer
- * @param programId       Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
- * @param confirmOptions  Optional confirm options
- * @param options         Optional interface options
- * @param wrap            Include SPL/T22 wrapping (default: false)
- * @returns Transaction signature of the transfer transaction
- */
-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>;
-/**
- * Options for createTransferInterfaceInstructions.
- */
-interface TransferOptions extends InterfaceOptions {
-    /** Include SPL/T22 wrapping to c-token ATA (unified path). Default: false. */
     wrap?: boolean;
-    /** Token program ID. Default: LIGHT_TOKEN_PROGRAM_ID. */
-    programId?: PublicKey;
     /**
-     * Include an idempotent recipient ATA creation instruction in the
-     * transfer transaction. No extra RPC fetch -- uses
-     * createAssociatedTokenAccountInterfaceIdempotentInstruction which is
-     * a no-op on-chain if the ATA already exists (~200 CU overhead).
-     * Default: true.
+     * Delegate authority pubkey. For owner-signed flows, omit this field.
      */
-    ensureRecipientAta?: boolean;
+    delegatePubkey?: PublicKey;
+}
+declare function transferToAccountInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, destination: PublicKey, owner: PublicKey, authority: Signer, amount: number | bigint | BN, programId?: PublicKey, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<TransactionSignature>;
+declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, recipient: PublicKey, owner: PublicKey, authority: Signer, amount: number | bigint | BN, programId?: PublicKey, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<TransactionSignature>;
+
+declare function createTransferInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, owner: PublicKey, recipient: PublicKey, decimals: number, options?: InterfaceOptions, programId?: PublicKey): Promise<TransactionInstruction[][]>;
+
+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;
+    /** 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;
 }
 /**
- * Splits the last element from an array.
+ * Create instruction for minting tokens to a light-token account.
  *
- * Useful for separating load transactions (parallel) from the final transfer
- * transaction (sequential) returned by `createTransferInterfaceInstructions`.
+ * This is a simple 3-4 account instruction for minting to light-token associated token accounts (hot).
+ * Uses discriminator 7 (LightTokenMintTo).
  *
- * @returns `{ rest, last }` where `rest` is everything before the last
- * element and `last` is the last element.
- * @throws if the input array is empty.
+ * @param params - Mint instruction parameters
+ * @returns TransactionInstruction for minting tokens
  */
-declare function sliceLast<T>(items: T[]): {
-    rest: T[];
-    last: T;
-};
+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;
 /**
- * Create instructions for a c-token transfer.
- *
- * Returns `TransactionInstruction[][]` -- an array of transaction instruction
- * arrays. Each inner array is one transaction to sign and send.
- *
- * - All transactions except the last can be sent in parallel (load/decompress).
- * - The last transaction is the transfer and must be sent after all others
- *   confirm.
- * - For a hot sender or <=8 cold inputs, the result is a single-element array.
- *
- * Use `sliceLast` to separate the parallel prefix from the final transfer:
- * ```
- * const batches = await createTransferInterfaceInstructions(...);
- * const { rest, last } = sliceLast(batches);
- * ```
- *
- * When `ensureRecipientAta` is true (the default), an idempotent ATA creation
- * instruction is included in the transfer (last) transaction. No extra RPC
- * fetch -- the instruction is a no-op on-chain if the ATA already exists.
- * Set `ensureRecipientAta: false` if you manage recipient ATAs yourself.
- *
- * All transactions require payer + sender as signers.
- *
- * Hash uniqueness guarantee: all compressed accounts for the sender are
- * fetched once, then partitioned into non-overlapping chunks by tree version.
- * Each hash appears in exactly one batch. This is enforced at runtime by
- * `assertUniqueInputHashes` inside `_buildLoadBatches`.
- *
- * @param rpc       RPC connection
- * @param payer     Fee payer public key
- * @param mint      Mint address
- * @param amount    Amount to transfer
- * @param sender    Sender public key (must sign all transactions)
- * @param recipient Recipient public key
- * @param options   Optional configuration
- * @returns TransactionInstruction[][] -- send [0..n-2] in parallel, then [n-1]
- */
-declare function createTransferInterfaceInstructions(
-    rpc: Rpc,
-    payer: PublicKey,
-    mint: PublicKey,
-    amount: number | bigint | BN,
-    sender: PublicKey,
-    recipient: PublicKey,
-    options?: TransferOptions,
-): Promise<TransactionInstruction[][]>;
-
-/**
- * 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.
- */
-interface ParsedAccountInfoInterface<T = unknown> {
-    /** Parsed account data (program-specific) */
-    parsed: T;
-    /** Load context - present if account is compressed (cold), undefined if hot */
-    loadContext?: MerkleContext;
+ * 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>;
 /**
- * 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.
+ * 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").
  */
-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 MAX_TOP_UP = 65535;
 /**
- * Packed compressed account for decompressAccountsIdempotent instruction
+ * Rent configuration constants for compressible light token accounts.
+ * These match the Rust SDK defaults in program-libs/compressible/src/rent/config.rs
  */
-interface PackedCompressedAccount {
-    [key: string]: unknown;
-    merkleContext: {
-        merkleTreePubkeyIndex: number;
-        queuePubkeyIndex: number;
-    };
-}
+/** 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;
 /**
- * Result from building load params
+ * 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 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_ACCOUNT_SIZE = 272;
 /**
- * Result from createLoadAccountsParams
+ * Calculate rent per epoch for a given account size.
+ * Formula: base_rent + (bytes * lamports_per_byte_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 rentPerEpoch(bytes: 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
+ * Default rent per epoch for a compressible light token account (272 bytes).
+ * = 128 + 272 = 400 lamports
+ */
+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;
+/**
+ * Calculate fee payer cost at ATA creation.
+ * = compression_cost (11K) + (prepay_epochs * rent_per_epoch)
+ */
+declare function calculateFeePayerCostAtCreation(prepayEpochs?: number, accountBytes?: number): number;
+
+/**
+ * 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.
  *
- * @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
+ * @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 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;
+
+/**
+ * Create mint-to instruction for SPL, Token-2022, or light-token mints.
+ * This instruction ONLY mints to light-token associated token accounts (hot).
  *
- * @example
- * ```typescript
- * const poolInfo = await myProgram.fetchPoolState(rpc, poolAddress);
- * const vault0Ata = getAssociatedTokenAddressInterface(token0Mint, poolAddress);
- * const vault0Info = await getAtaInterface(rpc, vault0Ata, poolAddress, token0Mint, undefined, LIGHT_TOKEN_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],
- * );
+ * For light-token mints, the light mint account must exist (mint must be decompressed first).
  *
- * // 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());
- * }
- * ```
- */
-declare function createLoadAccountsParams(
-    rpc: Rpc,
-    payer: PublicKey,
-    programId: PublicKey,
-    programAccounts?: CompressibleAccountInput[],
-    atas?: AccountInterface[],
-    options?: InterfaceOptions,
-): Promise<LoadResult>;
-/**
- * Calculate compute units for compressible load operation
- */
-declare function calculateCompressibleLoadComputeUnits(
-    compressedAccountCount: number,
-    hasValidityProof: boolean,
-): number;
+ * @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 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,
@@ -2341,23 +1823,13 @@ declare function calculateCompressibleLoadComputeUnits(
  * @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,
-    maxTopUp?: number,
-): 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 c-token account to an
+ * Create an unwrap instruction that moves tokens from a light-token account to an
  * SPL/T22 account.
  *
- * @param source           Source c-token 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
@@ -2368,55 +1840,151 @@ declare function createWrapInstruction(
  * @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 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 an instruction to approve a delegate for a light-token account.
+ *
+ * Account order per program:
+ * 0. token_account (mutable)   - the light-token account
+ * 1. delegate      (readonly)  - the delegate to approve
+ * 2. owner         (signer)    - owner of the token account
+ * 3. system_program (readonly) - for rent top-ups via CPI
+ * 4. fee_payer     (mutable, signer) - pays for rent top-ups
+ *
+ * @param tokenAccount The light-token account to set delegation on
+ * @param delegate     The delegate to approve
+ * @param owner        Owner of the token account (signer)
+ * @param amount       Amount of tokens to delegate
+ * @param feePayer     Optional fee payer for rent top-ups (defaults to owner)
+ * @returns TransactionInstruction
+ */
+declare function createLightTokenApproveInstruction(tokenAccount: PublicKey, delegate: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
+/**
+ * Create an instruction to revoke delegation for a light-token account.
+ *
+ * Account order per program:
+ * 0. token_account (mutable)   - the light-token account
+ * 1. owner         (signer)    - owner of the token account
+ * 2. system_program (readonly) - for rent top-ups via CPI
+ * 3. fee_payer     (mutable, signer) - pays for rent top-ups
+ *
+ * @param tokenAccount The light-token account to revoke delegation on
+ * @param owner        Owner of the token account (signer)
+ * @param feePayer     Optional fee payer for rent top-ups (defaults to owner)
+ * @returns TransactionInstruction
+ */
+declare function createLightTokenRevokeInstruction(tokenAccount: PublicKey, owner: PublicKey, feePayer?: PublicKey): TransactionInstruction;
+
+/**
+ * Build instruction batches for approving a delegate on an ATA.
+ *
+ * Supports light-token, SPL, and Token-2022 mints.
+ * Returns `TransactionInstruction[][]`. Send [0..n-2] in parallel, then [n-1].
+ *
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA before the approve instruction. The `amount` parameter
+ * only controls the delegate's spending limit, not the number of accounts
+ * loaded. Users with many cold accounts may see additional load transactions.
+ *
+ * @param rpc          RPC connection
+ * @param payer        Fee payer public key
+ * @param mint         Mint address
+ * @param tokenAccount ATA address
+ * @param delegate     Delegate to approve
+ * @param amount       Amount to delegate
+ * @param owner        Owner public key
+ * @param decimals     Token decimals
+ * @param programId    Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
+ * @param options      Optional interface options (`wrap` is nested here)
+ * @returns Instruction batches
+ */
+declare function createApproveInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, tokenAccount: PublicKey, delegate: PublicKey, amount: number | bigint | BN, owner: PublicKey, decimals: number, programId?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
+/**
+ * Build instruction batches for revoking delegation on an ATA.
+ *
+ * Supports light-token, SPL, and Token-2022 mints.
+ * Returns `TransactionInstruction[][]`. Send [0..n-2] in parallel, then [n-1].
+ *
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA before the revoke instruction. Users with many cold
+ * accounts may see additional load transactions.
+ *
+ * @param rpc          RPC connection
+ * @param payer        Fee payer public key
+ * @param mint         Mint address
+ * @param tokenAccount ATA address
+ * @param owner        Owner public key
+ * @param decimals     Token decimals
+ * @param programId    Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
+ * @param options      Optional interface options (`wrap` is nested here)
+ * @returns Instruction batches
+ */
+declare function createRevokeInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, tokenAccount: PublicKey, owner: PublicKey, decimals: number, programId?: PublicKey, options?: InterfaceOptions): Promise<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 LIGHT_TOKEN_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 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
  */
-declare function createMintInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mintAuthority: PublicKey | Signer,
-    freezeAuthority: PublicKey | Signer | null,
-    decimals: number,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    programId?: PublicKey,
-    tokenMetadata?: TokenMetadataInstructionData,
-    outputStateTreeInfo?: TreeInfo,
-    addressTreeInfo?: AddressTreeInfo,
-): Promise<{
+declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: PublicKey | Signer, freezeAuthority: PublicKey | Signer | null, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, programId?: PublicKey, tokenMetadata?: TokenMetadataInstructionData, outputStateTreeInfo?: TreeInfo, addressTreeInfo?: AddressTreeInfo): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
 
 /**
- * Update the mint authority of a compressed token mint.
- * Works for both compressed and decompressed mints.
+ * 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)
@@ -2425,17 +1993,10 @@ declare function createMintInterface(
  * @param newMintAuthority       New mint authority (or null to revoke)
  * @param confirmOptions         Optional confirm options
  */
-declare function updateMintAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentMintAuthority: Signer,
-    newMintAuthority: PublicKey | null,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+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.
- * Works for both compressed and decompressed mints.
+ * 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)
@@ -2444,18 +2005,11 @@ declare function updateMintAuthority(
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param confirmOptions           Optional confirm options
  */
-declare function updateFreezeAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentFreezeAuthority: Signer,
-    newFreezeAuthority: PublicKey | null,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+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.
- * Works for both compressed and decompressed mints.
+ * 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)
@@ -2467,20 +2021,10 @@ declare function updateFreezeAuthority(
  * @param extensionIndex Extension index (default: 0)
  * @param confirmOptions Optional confirm options
  */
-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.
- * Works for both compressed and decompressed mints.
+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 light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc              RPC connection
  * @param payer            Fee payer (signer)
@@ -2490,18 +2034,10 @@ declare function updateMetadataField(
  * @param extensionIndex   Extension index (default: 0)
  * @param confirmOptions   Optional confirm options
  */
-declare function updateMetadataAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentAuthority: Signer,
-    newAuthority: PublicKey,
-    extensionIndex?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+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.
- * Works for both compressed and decompressed mints.
+ * 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)
@@ -2512,20 +2048,11 @@ declare function updateMetadataAuthority(
  * @param extensionIndex Extension index (default: 0)
  * @param confirmOptions Optional confirm options
  */
-declare function removeMetadataKey(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    authority: Signer,
-    key: string,
-    idempotent?: boolean,
-    extensionIndex?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+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
@@ -2535,25 +2062,15 @@ declare function removeMetadataKey(
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
  *                                  LIGHT_TOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional rent config
+ * @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>;
-/**
- * Create an associated token account idempotently for SPL/T22/c-token. Defaults
- * to c-token program.
+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/light-token.
+ * Defaults to light-token program.
  *
  * If the account already exists, the instruction succeeds without error.
  *
@@ -2565,53 +2082,34 @@ declare function createAtaInterface(
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
  *                                  LIGHT_TOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional c-token-specific configuration
+ * @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>;
 
 /**
- * Mint tokens to a CToken account.
+ * Mint tokens to a light-token account.
  *
- * This is a simple mint instruction for minting to decompressed CToken accounts.
- * The mint must be decompressed (CMint account must exist on-chain).
+ * 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 (CMint account)
- * @param destination - Destination CToken account
+ * @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>;
+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
@@ -2623,33 +2121,23 @@ declare function mintTo$1(
  * @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,
-    maxTopUp?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function mintToCompressed(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, recipients: Array<{
+    recipient: PublicKey;
+    amount: number | bigint;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: number, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint tokens to a decompressed/onchain token account.
- * Works with SPL, Token-2022, and CToken mints.
+ * Works with SPL, Token-2022, and light-token mints.
  *
- * This function ONLY mints to decompressed onchain token accounts, never to compressed accounts.
- * For CToken mints, the mint must be decompressed first (CMint account must exist on-chain).
+ * 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).
  *
  * 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 CToken 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
@@ -2659,17 +2147,7 @@ declare function mintToCompressed(
  *
  * @returns Transaction signature
  */
-declare function mintToInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners?: Signer[],
-    confirmOptions?: ConfirmOptions,
-    programId?: PublicKey,
-): Promise<TransactionSignature>;
+declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer | PublicKey, amount: number | bigint, multiSigners?: Signer[], confirmOptions?: ConfirmOptions, programId?: PublicKey): Promise<TransactionSignature>;
 
 /**
  * Retrieve the associated token account, or create it if it doesn't exist.
@@ -2680,7 +2158,7 @@ declare function mintToInterface(
  * @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).
@@ -2694,56 +2172,18 @@ declare function mintToInterface(
  *
  * @returns AccountInterface with aggregated balance and source breakdown
  */
-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.
+declare function getOrCreateAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey | Signer, allowOwnerOffCurve?: boolean, commitment?: Commitment, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey): Promise<AccountInterface>;
+
+/**
+ * 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
@@ -2753,13 +2193,13 @@ declare function decompressInterface(
  *
  * @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,
@@ -2767,122 +2207,66 @@ declare function decompressInterface(
  *
  * @returns Transaction signature
  */
-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>;
+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>;
 
 /**
- * Build instruction batches for unwrapping c-tokens to SPL/T22 tokens.
+ * Approve a delegate for an associated token account.
  *
- * Returns `TransactionInstruction[][]` with the same shape as
- * `createLoadAtaInstructions` and `createTransferInterfaceInstructions`:
- * each inner array is one transaction. Load batches (if any) come first,
- * followed by one final unwrap transaction.
+ * Supports light-token, SPL, and Token-2022 mints. For light-token mints,
+ * loads cold accounts if needed before sending the approve instruction.
  *
- * Uses amount-aware input selection: only loads the cold inputs needed to
- * cover the unwrap amount (plus padding to fill a single proof batch).
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA, not just the delegation amount. The `amount` parameter
+ * only controls the delegate's spending limit.
  *
- * @param rpc               RPC connection
- * @param destination       Destination SPL/T22 token account (must exist)
- * @param owner             Owner of the c-token
- * @param mint              Mint address
- * @param amount            Amount to unwrap (defaults to full balance)
- * @param payer             Fee payer (defaults to owner)
- * @param splInterfaceInfo  Optional: SPL interface info
- * @param maxTopUp          Optional: cap on rent top-up (units of 1k lamports; default no cap)
- * @param interfaceOptions  Optional: interface options for load
- * @param wrap              Whether to use unified (wrap) mode for loading.
- *                          Default false.
- * @returns Instruction batches - each inner array is one transaction
+ * @param rpc            RPC connection
+ * @param payer          Fee payer (signer)
+ * @param tokenAccount   ATA address
+ * @param mint           Mint address
+ * @param delegate       Delegate to approve
+ * @param amount         Amount to delegate
+ * @param owner          Owner of the token account (signer)
+ * @param confirmOptions Optional confirm options
+ * @param programId      Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
+ * @param options        Optional interface options (`wrap` is nested here)
+ * @returns Transaction signature
  */
-declare function createUnwrapInstructions(
-    rpc: Rpc,
-    destination: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    amount?: number | bigint | BN,
-    payer?: PublicKey,
-    splInterfaceInfo?: SplInterfaceInfo,
-    maxTopUp?: number,
-    interfaceOptions?: InterfaceOptions,
-    wrap?: boolean,
-): Promise<TransactionInstruction[][]>;
-
+declare function approveInterface(rpc: Rpc, payer: Signer, tokenAccount: PublicKey, mint: PublicKey, delegate: PublicKey, amount: number | bigint | BN, owner: Signer, confirmOptions?: ConfirmOptions, programId?: PublicKey, options?: InterfaceOptions, decimals?: number): Promise<TransactionSignature>;
 /**
- * Select compressed inputs for a target amount.
+ * Revoke delegation for an associated token account.
  *
- * Sorts by amount descending (largest first), accumulates until the target
- * is met, then pads to {@link MAX_INPUT_ACCOUNTS} if possible within a
- * single batch.
+ * Supports light-token, SPL, and Token-2022 mints. For light-token mints,
+ * loads cold accounts if needed before sending the revoke instruction.
  *
- * - If the amount is covered by N <= 8 inputs, returns min(8, total) inputs.
- * - If more than 8 inputs are needed, returns exactly as many as required
- *   (no padding beyond the amount-needed count).
- * - Returns [] when `neededAmount <= 0` or `accounts` is empty.
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA before the revoke instruction.
  *
- * @param accounts      Cold compressed token accounts available for loading.
- * @param neededAmount  Amount that must be covered by selected inputs.
- * @returns Subset of `accounts`, sorted largest-first.
+ * @param rpc            RPC connection
+ * @param payer          Fee payer (signer)
+ * @param tokenAccount   ATA address
+ * @param mint           Mint address
+ * @param owner          Owner of the token account (signer)
+ * @param confirmOptions Optional confirm options
+ * @param programId      Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
+ * @param options        Optional interface options (`wrap` is nested here)
+ * @returns Transaction signature
  */
-declare function selectInputsForAmount(
-    accounts: ParsedTokenAccount[],
-    neededAmount: bigint,
-): ParsedTokenAccount[];
+declare function revokeInterface(rpc: Rpc, payer: Signer, tokenAccount: PublicKey, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions, programId?: PublicKey, options?: InterfaceOptions, decimals?: number): 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.
  * @returns                         Associated token address.
  */
-declare function getAssociatedTokenAddressInterface(
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve?: boolean,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-): PublicKey;
+declare function getAssociatedTokenAddressInterface(mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, programId?: PublicKey, associatedTokenProgramId?: PublicKey): PublicKey;
 
 /**
  * Input for creating off-chain metadata JSON.
@@ -2932,7 +2316,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);
@@ -2940,9 +2324,7 @@ interface OffChainTokenMetadataJson {
  * // Then use uri with createMint
  * await createMint(rpc, payer, { ...params, uri });
  */
-declare function toOffChainMetadataJson(
-    meta: OffChainTokenMetadata,
-): OffChainTokenMetadataJson;
+declare function toOffChainMetadataJson(meta: OffChainTokenMetadata): OffChainTokenMetadataJson;
 
 /**
  * Approve a delegate to spend tokens
@@ -2957,15 +2339,7 @@ declare function toOffChainMetadataJson(
  *
  * @return Signature of the confirmed transaction
  */
-declare function approve(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    delegate: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function approve(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, delegate: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens to a solana address from an external mint authority
@@ -2984,17 +2358,7 @@ declare function approve(
  *
  * @return Signature of the confirmed transaction
  */
-declare function approveAndMintTo(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    toPubkey: PublicKey,
-    authority: Signer,
-    amount: number | BN,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Compress SPL tokens
@@ -3014,18 +2378,7 @@ declare function approveAndMintTo(
  *
  * @return Signature of the confirmed transaction
  */
-declare function compress(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN | number[] | BN[],
-    owner: Signer,
-    sourceTokenAccount: PublicKey,
-    toAddress: PublicKey | Array<PublicKey>,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN | number[] | BN[], owner: Signer, sourceTokenAccount: PublicKey, toAddress: PublicKey | Array<PublicKey>, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Compress SPL tokens into compressed token format
@@ -3045,17 +2398,7 @@ declare function compress(
  *
  * @return Signature of the confirmed transaction
  */
-declare function compressSplTokenAccount(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    owner: Signer,
-    tokenAccount: PublicKey,
-    remainingAmount?: BN,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, tokenAccount: PublicKey, remainingAmount?: BN, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create and initialize a new SPL token mint
@@ -3075,16 +2418,7 @@ declare function compressSplTokenAccount(
  *
  * @return Object with mint address and transaction signature
  */
-declare function createMint(
-    rpc: Rpc,
-    payer: Signer,
-    mintAuthority: PublicKey | Signer,
-    decimals: number,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey | boolean,
-    freezeAuthority?: PublicKey | Signer | null,
-): Promise<{
+declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey | Signer, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey | boolean, freezeAuthority?: PublicKey | Signer | null): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
@@ -3101,13 +2435,7 @@ declare function createMint(
  *
  * @return transaction signature
  */
-declare function createSplInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey,
-): Promise<TransactionSignature>;
+declare function createSplInterface(rpc: Rpc, payer: Signer, mint: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
 /**
  * @deprecated Use {@link createSplInterface} instead.
  */
@@ -3126,14 +2454,7 @@ declare const createTokenPool: typeof createSplInterface;
  *
  * @return transaction signature
  */
-declare function addSplInterfaces(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    numMaxAdditionalPools: number,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey,
-): Promise<string>;
+declare function addSplInterfaces(rpc: Rpc, payer: Signer, mint: PublicKey, numMaxAdditionalPools: number, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<string>;
 /**
  * @deprecated Use {@link addSplInterfaces} instead.
  */
@@ -3153,13 +2474,7 @@ declare const addTokenPools: typeof addSplInterfaces;
  * @return Object with transaction signatures and the address of the created
  *         lookup table
  */
-declare function createTokenProgramLookupTable(
-    rpc: Rpc,
-    payer: Signer,
-    authority: Signer,
-    mints?: PublicKey[],
-    additionalAccounts?: PublicKey[],
-): Promise<{
+declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
     txIds: TransactionSignature[];
     address: PublicKey;
 }>;
@@ -3179,16 +2494,7 @@ declare function createTokenProgramLookupTable(
  *
  * @return confirmed transaction signature
  */
-declare function decompress(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    splInterfaceInfos?: SplInterfaceInfo[],
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, splInterfaceInfos?: SplInterfaceInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Merge multiple compressed token accounts for a given mint into fewer
@@ -3208,13 +2514,7 @@ declare function decompress(
  *
  * @return confirmed transaction signature
  */
-declare function mergeTokenAccounts(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    owner: Signer,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens to a solana address
@@ -3236,17 +2536,7 @@ declare function mergeTokenAccounts(
  *
  * @return Signature of the confirmed transaction
  */
-declare function mintTo(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    toPubkey: PublicKey | PublicKey[],
-    authority: Signer,
-    amount: number | BN | number[] | BN[],
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey | PublicKey[], authority: Signer, amount: number | BN | number[] | BN[], outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Revoke one or more delegated token accounts
@@ -3260,13 +2550,7 @@ declare function mintTo(
  *
  * @return Signature of the confirmed transaction
  */
-declare function revoke(
-    rpc: Rpc,
-    payer: Signer,
-    accounts: ParsedTokenAccount[],
-    owner: Signer,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[], owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer compressed tokens from one owner to another.
@@ -3284,15 +2568,7 @@ declare function revoke(
  *
  * @return confirmed transaction signature
  */
-declare function transfer(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer delegated compressed tokens to another owner
@@ -3307,15 +2583,7 @@ declare function transfer(
  *
  * @return confirmed transaction signature
  */
-declare function transferDelegated(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Decompress delegated compressed tokens. Remaining compressed tokens are
@@ -3333,21 +2601,10 @@ declare function transferDelegated(
  *
  * @return Signature of the confirmed transaction
  */
-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.';
+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
  */
@@ -3362,9 +2619,7 @@ interface SelectInputAccountsOptions {
 /**
  * Groups accounts by tree type for separate processing
  */
-declare function groupAccountsByTreeType(
-    accounts: ParsedTokenAccount[],
-): Map<TreeType, ParsedTokenAccount[]>;
+declare function groupAccountsByTreeType(accounts: ParsedTokenAccount[]): Map<TreeType, ParsedTokenAccount[]>;
 /**
  * Result of selectAccountsByPreferredTreeType
  */
@@ -3389,10 +2644,7 @@ interface SelectedAccountsResult {
  * @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;
+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.
  *
@@ -3411,16 +2663,11 @@ declare function selectAccountsByPreferredTreeType(
  *   - totalLamports: Total lamports from selected accounts.
  *   - maxPossibleAmount: Max approvable amount given maxInputs.
  */
-declare function selectTokenAccountsForApprove(
-    accounts: ParsedTokenAccount[],
-    approveAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Selects the minimum number of compressed token accounts required for a
@@ -3434,12 +2681,7 @@ declare function selectTokenAccountsForApprove(
  *
  * @returns Returns selected accounts and their totals.
  */
-declare function selectMinCompressedTokenAccountsForDecompression(
-    accounts: ParsedTokenAccount[],
-    amount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): {
+declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): {
     selectedAccounts: ParsedTokenAccount[];
     total: BN;
     totalLamports: BN | null;
@@ -3463,31 +2705,22 @@ declare function selectMinCompressedTokenAccountsForDecompression(
  *   maxPossibleAmount: BN
  * ]
  */
-declare function selectMinCompressedTokenAccountsForTransfer(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
  * returns partial amounts if insufficient accounts are found instead of
  * throwing an error.
  */
-declare function selectMinCompressedTokenAccountsForTransferOrPartial(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-): [
+declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Selects compressed token accounts for a transfer, ensuring one extra account
@@ -3530,31 +2763,22 @@ declare function selectMinCompressedTokenAccountsForTransferOrPartial(
  * console.log(totalLamports!.toString()); // '15'
  * console.log(maxPossibleAmount.toString()); // '150'
  */
-declare function selectSmartCompressedTokenAccountsForTransfer(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
  * returns partial amounts if insufficient accounts are found instead of
  * throwing an error.
  */
-declare function selectSmartCompressedTokenAccountsForTransferOrPartial(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-): [
+declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 
 type TokenTransferOutputData = {
@@ -3627,9 +2851,7 @@ type CompressSplTokenAccountInstructionData = {
     remainingAmount: BN | null;
     cpiContext: CompressedCpiContext | null;
 };
-declare function isSingleSplInterfaceInfo(
-    splInterfaceInfos: SplInterfaceInfo | SplInterfaceInfo[],
-): splInterfaceInfos is SplInterfaceInfo;
+declare function isSingleSplInterfaceInfo(splInterfaceInfos: SplInterfaceInfo | SplInterfaceInfo[]): splInterfaceInfos is SplInterfaceInfo;
 /**
  * @deprecated Use {@link isSingleSplInterfaceInfo} instead.
  */
@@ -3740,9 +2962,7 @@ type PackCompressedTokenAccountsParams = {
 /**
  * Packs Compressed Token Accounts.
  */
-declare function packCompressedTokenAccounts(
-    params: PackCompressedTokenAccountsParams,
-): {
+declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
     inputTokenDataWithContext: InputTokenDataWithContext$1[];
     remainingAccountMetas: AccountMeta[];
     packedOutputTokenData: PackedTokenTransferOutputData[];
@@ -3755,10 +2975,7 @@ declare function packCompressedTokenAccounts(
  * @param mint                      The mint of the token pool
  * @returns True if all input accounts belong to the same mint
  */
-declare function checkMint(
-    compressedTokenAccounts: ParsedTokenAccount[],
-    mint: PublicKey,
-): boolean;
+declare function checkMint(compressedTokenAccounts: ParsedTokenAccount[], mint: PublicKey): boolean;
 
 type LightCompressedToken = {
     version: '1.2.0';
@@ -3770,7 +2987,7 @@ type LightCompressedToken = {
                 'This instruction creates a token pool for a given mint. Every spl mint',
                 'can have one token pool. When a token is compressed the tokens are',
                 'transferrred to the token pool, and their compressed equivalent is',
-                'minted into a Merkle tree.',
+                'minted into a Merkle tree.'
             ];
             accounts: [
                 {
@@ -3803,7 +3020,7 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [];
         },
@@ -3811,7 +3028,7 @@ type LightCompressedToken = {
             name: 'addTokenPool';
             docs: [
                 'This instruction creates an additional token pool for a given mint.',
-                'The maximum number of token pools per mint is 5.',
+                'The maximum number of token pools per mint is 5.'
             ];
             accounts: [
                 {
@@ -3849,13 +3066,13 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'tokenPoolIndex';
                     type: 'u8';
-                },
+                }
             ];
         },
         {
@@ -3867,7 +3084,7 @@ type LightCompressedToken = {
                 'every amount and pubkey input pair. A constant amount of lamports can be',
                 'transferred to each output account to enable. A use case to add lamports',
                 'to a compressed token account is to prevent spam. This is the only way',
-                'to add lamports to a compressed token account.',
+                'to add lamports to a compressed token account.'
             ];
             accounts: [
                 {
@@ -3947,7 +3164,7 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                },
+                }
             ];
             args: [
                 {
@@ -3967,7 +3184,7 @@ type LightCompressedToken = {
                     type: {
                         option: 'u64';
                     };
-                },
+                }
             ];
         },
         {
@@ -3975,7 +3192,7 @@ type LightCompressedToken = {
             docs: [
                 'Compresses the balance of an spl token account sub an optional remaining',
                 'amount. This instruction does not close the spl token account. To close',
-                'the account bundle a close spl account instruction in your transaction.',
+                'the account bundle a close spl account instruction in your transaction.'
             ];
             accounts: [
                 {
@@ -3991,7 +3208,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4052,7 +3269,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -4072,7 +3289,7 @@ type LightCompressedToken = {
                             defined: 'CompressedCpiContext';
                         };
                     };
-                },
+                }
             ];
         },
         {
@@ -4085,7 +3302,7 @@ type LightCompressedToken = {
                 'accounts specify less lamports than inputs the remaining lamports are',
                 'transferred to an output compressed account. Signer must be owner or',
                 'delegate. If a delegated token account is transferred the delegate is',
-                'not preserved.',
+                'not preserved.'
             ];
             accounts: [
                 {
@@ -4101,7 +3318,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4162,13 +3379,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4179,7 +3396,7 @@ type LightCompressedToken = {
                 'be called by a delegate.',
                 'The instruction creates two output accounts:',
                 '1. one account with delegated amount',
-                '2. one account with remaining(change) amount',
+                '2. one account with remaining(change) amount'
             ];
             accounts: [
                 {
@@ -4195,7 +3412,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4238,20 +3455,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'revoke';
             docs: [
                 'Revokes a delegation. The instruction merges all inputs into one output',
-                'account. Cannot be called by a delegate. Delegates are not preserved.',
+                'account. Cannot be called by a delegate. Delegates are not preserved.'
             ];
             accounts: [
                 {
@@ -4267,7 +3484,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4310,20 +3527,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'freeze';
             docs: [
                 'Freezes compressed token accounts. Inputs must not be frozen. Creates as',
-                'many outputs as inputs. Balances and delegates are preserved.',
+                'many outputs as inputs. Balances and delegates are preserved.'
             ];
             accounts: [
                 {
@@ -4382,20 +3599,20 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'thaw';
             docs: [
                 'Thaws frozen compressed token accounts. Inputs must be frozen. Creates',
-                'as many outputs as inputs. Balances and delegates are preserved.',
+                'as many outputs as inputs. Balances and delegates are preserved.'
             ];
             accounts: [
                 {
@@ -4454,13 +3671,13 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4468,7 +3685,7 @@ type LightCompressedToken = {
             docs: [
                 'Burns compressed tokens and spl tokens from the pool account. Delegates',
                 'can burn tokens. The output compressed token account remains delegated.',
-                'Creates one output compressed token account.',
+                'Creates one output compressed token account.'
             ];
             accounts: [
                 {
@@ -4484,7 +3701,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4541,13 +3758,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4555,7 +3772,7 @@ type LightCompressedToken = {
             docs: [
                 'This function is a stub to allow Anchor to include the input types in',
                 'the IDL. It should not be included in production builds nor be called in',
-                'practice.',
+                'practice.'
             ];
             accounts: [
                 {
@@ -4571,7 +3788,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4632,7 +3849,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -4646,9 +3863,9 @@ type LightCompressedToken = {
                     type: {
                         defined: 'TokenData';
                     };
-                },
+                }
             ];
-        },
+        }
     ];
     types: [
         {
@@ -4661,7 +3878,7 @@ type LightCompressedToken = {
                     },
                     {
                         name: 'Frozen';
-                    },
+                    }
                 ];
             };
         },
@@ -4693,7 +3910,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedAccountData';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4717,7 +3934,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4730,7 +3947,7 @@ type LightCompressedToken = {
                         name: 'setContext';
                         docs: [
                             'Is set by the program that is invoking the CPI to signal that is should',
-                            'set the cpi context.',
+                            'set the cpi context.'
                         ];
                         type: 'bool';
                     },
@@ -4738,17 +3955,17 @@ type LightCompressedToken = {
                         name: 'firstSetContext';
                         docs: [
                             'Is set to wipe the cpi context since someone could have set it before',
-                            'with unrelated data.',
+                            'with unrelated data.'
                         ];
                         type: 'bool';
                     },
                     {
                         name: 'cpiContextAccountIndex';
                         docs: [
-                            'Index of cpi context account in remaining accounts.',
+                            'Index of cpi context account in remaining accounts.'
                         ];
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4774,7 +3991,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4800,7 +4017,7 @@ type LightCompressedToken = {
                         docs: [
                             'Is required if the signer is delegate,',
                             '-> delegate is authority account,',
-                            'owner = Some(owner) is the owner of the token account.',
+                            'owner = Some(owner) is the owner of the token account.'
                         ];
                         type: {
                             option: {
@@ -4847,7 +4064,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'u8';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4887,7 +4104,7 @@ type LightCompressedToken = {
                     {
                         name: 'outputAccountMerkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4945,14 +4162,14 @@ type LightCompressedToken = {
                         type: {
                             option: 'u64';
                         };
-                    },
+                    }
                 ];
             };
         },
         {
             name: 'DelegatedTransfer';
             docs: [
-                'Struct to provide the owner when the delegate is signer of the transaction.',
+                'Struct to provide the owner when the delegate is signer of the transaction.'
             ];
             type: {
                 kind: 'struct';
@@ -4967,12 +4184,12 @@ type LightCompressedToken = {
                             'Index of change compressed account in output compressed accounts. In',
                             "case that the delegate didn't spend the complete delegated compressed",
                             'account balance the change compressed account will be delegated to her',
-                            'as well.',
+                            'as well.'
                         ];
                         type: {
                             option: 'u8';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5010,12 +4227,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5071,7 +4288,7 @@ type LightCompressedToken = {
                     {
                         name: 'isCompress';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -5135,7 +4352,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5151,7 +4368,7 @@ type LightCompressedToken = {
                     {
                         name: 'seq';
                         type: 'u64';
-                    },
+                    }
                 ];
             };
         },
@@ -5177,7 +4394,7 @@ type LightCompressedToken = {
                     {
                         name: 'addressMerkleTreeRootIndex';
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -5195,7 +4412,7 @@ type LightCompressedToken = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -5219,17 +4436,17 @@ type LightCompressedToken = {
                     {
                         name: 'rootIndex';
                         docs: [
-                            'Index of root used in inclusion validity proof.',
+                            'Index of root used in inclusion validity proof.'
                         ];
                         type: 'u16';
                     },
                     {
                         name: 'readOnly';
                         docs: [
-                            'Placeholder to mark accounts read-only unimplemented set to false.',
+                            'Placeholder to mark accounts read-only unimplemented set to false.'
                         ];
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -5253,7 +4470,7 @@ type LightCompressedToken = {
                     {
                         name: 'proveByIndex';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -5283,12 +4500,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5362,7 +4579,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5380,7 +4597,7 @@ type LightCompressedToken = {
                         name: 'index';
                         docs: ['Index of compressed account hash in queue.'];
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -5408,7 +4625,7 @@ type LightCompressedToken = {
                         name: 'delegate';
                         docs: [
                             'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
+                            'the amount authorized by the delegate'
                         ];
                         type: {
                             option: 'publicKey';
@@ -5424,15 +4641,15 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
-        },
+        }
     ];
     errors: [
         {
@@ -5589,7 +4806,7 @@ type LightCompressedToken = {
         {
             code: 6032;
             name: 'NoMatchingBumpFound';
-        },
+        }
     ];
 };
 declare const IDL: LightCompressedToken;
@@ -5600,30 +4817,14 @@ declare const CompressedTokenInstructionDataTransferLayout: Layout<unknown>;
 declare const mintToLayout: Layout<unknown>;
 declare const batchCompressLayout: Layout<unknown>;
 declare const compressSplTokenAccountInstructionDataLayout: Layout<unknown>;
-declare function encodeMintToInstructionData(
-    data: MintToInstructionData,
-): Buffer$1;
-declare function decodeMintToInstructionData(
-    buffer: Buffer$1,
-): MintToInstructionData;
-declare function encodeBatchCompressInstructionData(
-    data: BatchCompressInstructionData,
-): Buffer$1;
-declare function decodeBatchCompressInstructionData(
-    buffer: Buffer$1,
-): BatchCompressInstructionData;
-declare function encodeCompressSplTokenAccountInstructionData(
-    data: CompressSplTokenAccountInstructionData,
-): Buffer$1;
-declare function decodeCompressSplTokenAccountInstructionData(
-    buffer: Buffer$1,
-): CompressSplTokenAccountInstructionData;
-declare function encodeTransferInstructionData(
-    data: CompressedTokenInstructionDataTransfer,
-): Buffer$1;
-declare function decodeTransferInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataTransfer;
+declare function encodeMintToInstructionData(data: MintToInstructionData): Buffer$1;
+declare function decodeMintToInstructionData(buffer: Buffer$1): MintToInstructionData;
+declare function encodeBatchCompressInstructionData(data: BatchCompressInstructionData): Buffer$1;
+declare function decodeBatchCompressInstructionData(buffer: Buffer$1): BatchCompressInstructionData;
+declare function encodeCompressSplTokenAccountInstructionData(data: CompressSplTokenAccountInstructionData): Buffer$1;
+declare function decodeCompressSplTokenAccountInstructionData(buffer: Buffer$1): CompressSplTokenAccountInstructionData;
+declare function encodeTransferInstructionData(data: CompressedTokenInstructionDataTransfer): Buffer$1;
+declare function decodeTransferInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataTransfer;
 interface BaseAccountsLayoutParams {
     feePayer: PublicKey;
     authority: PublicKey;
@@ -5665,44 +4866,20 @@ type freezeAccountsLayoutParams = BaseAccountsLayoutParams & {
     mint: PublicKey;
 };
 type thawAccountsLayoutParams = freezeAccountsLayoutParams;
-declare const createTokenPoolAccountsLayout: (
-    accounts: createTokenPoolAccountsLayoutParams,
-) => AccountMeta[];
-declare const addTokenPoolAccountsLayout: (
-    accounts: addTokenPoolAccountsLayoutParams,
-) => AccountMeta[];
-declare const mintToAccountsLayout: (
-    accounts: mintToAccountsLayoutParams,
-) => AccountMeta[];
-declare const transferAccountsLayout: (
-    accounts: transferAccountsLayoutParams,
-) => AccountMeta[];
-declare const approveAccountsLayout: (
-    accounts: approveAccountsLayoutParams,
-) => AccountMeta[];
-declare const revokeAccountsLayout: (
-    accounts: approveAccountsLayoutParams,
-) => AccountMeta[];
-declare const freezeAccountsLayout: (
-    accounts: freezeAccountsLayoutParams,
-) => AccountMeta[];
-declare const thawAccountsLayout: (
-    accounts: freezeAccountsLayoutParams,
-) => AccountMeta[];
+declare const createTokenPoolAccountsLayout: (accounts: createTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const addTokenPoolAccountsLayout: (accounts: addTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const mintToAccountsLayout: (accounts: mintToAccountsLayoutParams) => AccountMeta[];
+declare const transferAccountsLayout: (accounts: transferAccountsLayoutParams) => AccountMeta[];
+declare const approveAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const revokeAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const freezeAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
+declare const thawAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
 declare const CompressedTokenInstructionDataApproveLayout: Layout<unknown>;
 declare const CompressedTokenInstructionDataRevokeLayout: Layout<unknown>;
-declare function encodeApproveInstructionData(
-    data: CompressedTokenInstructionDataApprove,
-): Buffer$1;
-declare function decodeApproveInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataApprove;
-declare function encodeRevokeInstructionData(
-    data: CompressedTokenInstructionDataRevoke,
-): Buffer$1;
-declare function decodeRevokeInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataRevoke;
+declare function encodeApproveInstructionData(data: CompressedTokenInstructionDataApprove): Buffer$1;
+declare function decodeApproveInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataApprove;
+declare function encodeRevokeInstructionData(data: CompressedTokenInstructionDataRevoke): Buffer$1;
+declare function decodeRevokeInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataRevoke;
 
 type CompressParams = {
     /**
@@ -5796,11 +4973,7 @@ type DecompressParams = {
     /**
      * Token pool(s)
      */
-    tokenPoolInfos:
-        | TokenPoolInfo
-        | TokenPoolInfo[]
-        | SplInterfaceInfo
-        | SplInterfaceInfo[];
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[] | SplInterfaceInfo | SplInterfaceInfo[];
 };
 type TransferParams = {
     /**
@@ -6085,17 +5258,12 @@ declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
 /**
  * Parse compressed token accounts to get the mint, current owner and delegate.
  */
-declare const parseTokenData: (
-    compressedTokenAccounts: ParsedTokenAccount[],
-) => {
+declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
     mint: PublicKey;
     currentOwner: PublicKey;
     delegate: PublicKey | null;
 };
-declare const parseMaybeDelegatedTransfer: (
-    inputs: ParsedTokenAccount[],
-    outputs: TokenTransferOutputData[],
-) => {
+declare const parseMaybeDelegatedTransfer: (inputs: ParsedTokenAccount[], outputs: TokenTransferOutputData[]) => {
     delegatedTransfer: DelegatedTransfer | null;
     authority: PublicKey;
 };
@@ -6107,11 +5275,7 @@ declare const parseMaybeDelegatedTransfer: (
  * @returns                             Output token data for the transfer
  *                                      instruction
  */
-declare function createTransferOutputState(
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    toAddress: PublicKey,
-    amount: number | BN,
-): TokenTransferOutputData[];
+declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData[];
 /**
  * Create the output state for a compress transaction.
  * @param inputCompressedTokenAccounts  Input state
@@ -6119,10 +5283,7 @@ declare function createTransferOutputState(
  * @returns                             Output token data for the compress
  *                                      instruction
  */
-declare function createDecompressOutputState(
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    amount: number | BN,
-): TokenTransferOutputData[];
+declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData[];
 declare class CompressedTokenProgram {
     /**
      * @internal
@@ -6160,17 +5321,11 @@ declare class CompressedTokenProgram {
      *
      * @returns The index and bump number.
      */
-    static findSplInterfaceIndexAndBump(
-        poolPda: PublicKey,
-        mint: PublicKey,
-    ): [number, number];
+    static findSplInterfaceIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
     /**
      * @deprecated Use {@link findSplInterfaceIndexAndBump} instead.
      */
-    static findTokenPoolIndexAndBump(
-        poolPda: PublicKey,
-        mint: PublicKey,
-    ): [number, number];
+    static findTokenPoolIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
     /**
      * Derive the SPL interface PDA with index.
      *
@@ -6180,17 +5335,11 @@ declare class CompressedTokenProgram {
      *
      * @returns The SPL interface PDA and bump.
      */
-    static deriveSplInterfacePdaWithIndex(
-        mint: PublicKey,
-        index: number,
-    ): [PublicKey, number];
+    static deriveSplInterfacePdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /**
      * @deprecated Use {@link deriveSplInterfacePdaWithIndex} instead.
      */
-    static deriveTokenPoolPdaWithIndex(
-        mint: PublicKey,
-        index: number,
-    ): [PublicKey, number];
+    static deriveTokenPoolPdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
     /**
@@ -6211,16 +5360,7 @@ declare class CompressedTokenProgram {
      * Note that `createSplInterfaceInstruction` must be executed after
      * `initializeMintInstruction`.
      */
-    static createMint({
-        feePayer,
-        mint,
-        authority,
-        freezeAuthority,
-        decimals,
-        rentExemptBalance,
-        tokenProgramId,
-        mintSize,
-    }: CreateMintParams): Promise<TransactionInstruction[]>;
+    static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
      * Create SPL interface (omnibus account) for an existing SPL mint.
      * For new mints, use `CompressedTokenProgram.createMint`.
@@ -6232,17 +5372,11 @@ declare class CompressedTokenProgram {
      *
      * @returns The createSplInterface instruction
      */
-    static createSplInterface({
-        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>;
+    static createTokenPool(params: CreateSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Add a token pool to an existing SPL mint.  For new mints, use
      * {@link createSplInterface}.
@@ -6255,12 +5389,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The addTokenPool instruction
      */
-    static addTokenPool({
-        feePayer,
-        mint,
-        poolIndex,
-        tokenProgramId,
-    }: AddSplInterfaceParams): Promise<TransactionInstruction>;
+    static addTokenPool({ feePayer, mint, poolIndex, tokenProgramId, }: AddSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Construct mintTo instruction for compressed tokens
      *
@@ -6274,15 +5403,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The mintTo instruction
      */
-    static mintTo({
-        feePayer,
-        mint,
-        authority,
-        toPubkey,
-        amount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: MintToParams): Promise<TransactionInstruction>;
+    static mintTo({ feePayer, mint, authority, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: MintToParams): Promise<TransactionInstruction>;
     /**
      * Mint tokens from registered SPL mint account to a compressed account
      *
@@ -6298,16 +5419,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The mintTo instruction
      */
-    static approveAndMintTo({
-        feePayer,
-        mint,
-        authority,
-        authorityTokenAccount,
-        toPubkey,
-        amount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    static approveAndMintTo({ feePayer, mint, authority, authorityTokenAccount, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
     /**
      * Construct transfer instruction for compressed tokens.
      *
@@ -6322,14 +5434,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The transfer instruction
      */
-    static transfer({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: TransferParams): Promise<TransactionInstruction>;
+    static transfer({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: TransferParams): Promise<TransactionInstruction>;
     /**
      * Create lookup table instructions for the token program's default
      * accounts.
@@ -6342,13 +5447,7 @@ declare class CompressedTokenProgram {
      *
      * @returns [createInstruction, extendInstruction, option(extendInstruction2)]
      */
-    static createTokenProgramLookupTable({
-        payer,
-        authority,
-        mints,
-        recentSlot,
-        remainingAccounts,
-    }: CreateTokenProgramLookupTableParams): Promise<{
+    static createTokenProgramLookupTable({ payer, authority, mints, recentSlot, remainingAccounts, }: CreateTokenProgramLookupTableParams): Promise<{
         instructions: TransactionInstruction[];
         address: PublicKey;
     }>;
@@ -6366,16 +5465,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The compress instruction
      */
-    static compress({
-        payer,
-        owner,
-        source,
-        toAddress,
-        amount,
-        mint,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: CompressParams): Promise<TransactionInstruction>;
+    static compress({ payer, owner, source, toAddress, amount, mint, outputStateTreeInfo, tokenPoolInfo, }: CompressParams): Promise<TransactionInstruction>;
     /**
      * Construct decompress instruction
      *
@@ -6390,15 +5480,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The decompress instruction
      */
-    static decompress({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-        tokenPoolInfos,
-    }: DecompressParams): Promise<TransactionInstruction>;
+    static decompress({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, tokenPoolInfos, }: DecompressParams): Promise<TransactionInstruction>;
     /**
      * Create `mergeTokenAccounts` instruction.
      *
@@ -6411,14 +5493,7 @@ declare class CompressedTokenProgram {
      * @param recentInputStateRootIndices   Recent state root indices.
      * @returns instruction
      */
-    static mergeTokenAccounts({
-        payer,
-        owner,
-        inputCompressedTokenAccounts,
-        mint,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
+    static mergeTokenAccounts({ payer, owner, inputCompressedTokenAccounts, mint, recentValidityProof, recentInputStateRootIndices, }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
     /**
      * Create `compressSplTokenAccount` instruction
      *
@@ -6432,15 +5507,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static compressSplTokenAccount({
-        feePayer,
-        authority,
-        tokenAccount,
-        mint,
-        remainingAmount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
+    static compressSplTokenAccount({ feePayer, authority, tokenAccount, mint, remainingAmount, outputStateTreeInfo, tokenPoolInfo, }: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
     /**
      * Get the program ID for a mint
      *
@@ -6449,10 +5516,7 @@ declare class CompressedTokenProgram {
      *
      * @returns program ID
      */
-    static getMintProgramId(
-        mint: PublicKey,
-        connection: Connection,
-    ): Promise<PublicKey | undefined>;
+    static getMintProgramId(mint: PublicKey, connection: Connection): Promise<PublicKey | undefined>;
     /**
      * Create `approve` instruction to delegate compressed tokens.
      *
@@ -6465,14 +5529,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static approve({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: ApproveParams): Promise<TransactionInstruction>;
+    static approve({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: ApproveParams): Promise<TransactionInstruction>;
     /**
      * Create `revoke` instruction to revoke delegation of compressed tokens.
      *
@@ -6483,12 +5540,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static revoke({
-        payer,
-        inputCompressedTokenAccounts,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: RevokeParams): Promise<TransactionInstruction>;
+    static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
 /** Solana maximum transaction size in bytes. */
@@ -6519,10 +5571,7 @@ declare const MAX_LOAD_ONLY_BATCH_BYTES = 1000;
  * @param numSigners    Number of signers (determines signature count).
  * @returns Estimated byte size of the serialized transaction.
  */
-declare function estimateTransactionSize(
-    instructions: TransactionInstruction[],
-    numSigners: number,
-): number;
+declare function estimateTransactionSize(instructions: TransactionInstruction[], numSigners: number): number;
 
 /**
  * Retrieve associated token account for a given owner and mint.
@@ -6535,14 +5584,7 @@ declare function estimateTransactionSize(
  * @param programId   Optional program ID
  * @returns AccountInterface with ATA metadata
  */
-declare function getAtaInterface(
-    rpc: Rpc,
-    ata: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<AccountInterface>;
+declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
  * Create instruction batches for loading token balances into an ATA.
  * Returns batches of instructions, each batch is one transaction.
@@ -6555,16 +5597,9 @@ declare function getAtaInterface(
  * @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
@@ -6575,250 +5610,6 @@ declare function createLoadAtaInstructions(
  * @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>;
-
-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_CTOKEN_ACCOUNT_SIZE,
-    COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH,
-    COMPRESSION_COST,
-    COMPRESSION_INCENTIVE,
-    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,
-    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,
-    CompressedTokenProgram as LightTokenProgram,
-    type LoadResult,
-    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 PackedCompressedAccount,
-    type PackedTokenTransferOutputData,
-    type ParsedAccountInfoInterface,
-    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,
-    calculateCompressibleLoadComputeUnits,
-    calculateFeePayerCostAtCreation,
-    checkMint,
-    checkSplInterfaceInfo,
-    checkTokenPoolInfo,
-    compress,
-    compressSplTokenAccount,
-    compressSplTokenAccountInstructionDataLayout,
-    convertTokenDataToAccount,
-    createAssociatedCTokenAccountIdempotentInstruction,
-    createAssociatedCTokenAccountInstruction,
-    createAssociatedTokenAccountInterfaceIdempotentInstruction,
-    createAssociatedTokenAccountInterfaceInstruction,
-    createAtaInterface,
-    createAtaInterfaceIdempotent,
-    createAtaInterfaceIdempotentInstruction,
-    createDecompressInterfaceInstruction,
-    createDecompressOutputState,
-    createLightTokenTransferInstruction,
-    createLoadAccountsParams,
-    createLoadAtaInstructions,
-    createLoadAtaInstructionsFromInterface,
-    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,
-    decompressInterface,
-    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,
-    mintTo$1 as mintToCToken,
-    mintToCompressed,
-    mintToInterface,
-    mintToLayout,
-    packCompressedTokenAccounts,
-    parseCTokenCold,
-    parseCTokenHot,
-    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,
-};
+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, 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, approveInterface, batchCompressLayout, calculateFeePayerCostAtCreation, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createApproveInterfaceInstructions, createAssociatedLightTokenAccountIdempotentInstruction, createAssociatedLightTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createDecompressOutputState, createLightTokenApproveInstruction, createLightTokenFreezeAccountInstruction, createLightTokenRevokeInstruction, createLightTokenThawAccountInstruction, createLightTokenTransferCheckedInstruction, createLightTokenTransferInstruction, createLoadAtaInstructions, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createRevokeInterfaceInstructions, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstructions, createTransferOutputState, createTransferToAccountInterfaceInstructions, 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, revokeInterface, 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, transferToAccountInterface, unpackMintData, unpackMintInterface, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };