@lightprotocol/compressed-token 0.23.0-beta.1 → 0.23.0-beta.11

package/dist/types/unified/index.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, AccountInfo, Commitment, TransactionInstruction, Signer, AccountMeta, Keypair, ConfirmOptions, TransactionSignature, Connection } from '@solana/web3.js';
-import { MerkleContext, CompressedAccountWithMerkleContext, Rpc, ValidityProofWithContext, AddressTreeInfo, TreeInfo, ParsedTokenAccount, ValidityProof, TreeType, PackedMerkleContextLegacy, CompressedCpiContext, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
+import { PublicKey, AccountInfo, Commitment, TransactionInstruction, Signer, Keypair, ConfirmOptions, TransactionSignature, AccountMeta, Connection } from '@solana/web3.js';
+import { MerkleContext, CompressedAccountWithMerkleContext, Rpc, ValidityProofWithContext, AddressTreeInfo, TreeInfo, ParsedTokenAccount, TreeType, PackedMerkleContextLegacy, CompressedCpiContext, ValidityProof, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
 export { ParsedTokenAccount } from '@lightprotocol/stateless.js';
 import { Account, Mint } from '@solana/spl-token';
 export { AccountState } from '@solana/spl-token';
@@ -799,8 +798,8 @@ declare const TokenAccountSourceType: {
     readonly Token2022: "token2022";
     readonly SplCold: "spl-cold";
     readonly Token2022Cold: "token2022-cold";
-    readonly CTokenHot: "ctoken-hot";
-    readonly CTokenCold: "ctoken-cold";
+    readonly LightTokenHot: "light-token-hot";
+    readonly LightTokenCold: "light-token-cold";
 };
 type TokenAccountSourceTypeValue = (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
 /** @internal */
@@ -823,9 +822,9 @@ interface AccountInterface {
     _anyFrozen?: boolean;
     /** True when fetched via getAtaInterface */
     _isAta?: boolean;
-    /** ATA owner - set by getAtaInterface */
+    /** Associated token account owner - set by getAtaInterface */
     _owner?: PublicKey;
-    /** ATA mint - set by getAtaInterface */
+    /** Associated token account mint - set by getAtaInterface */
     _mint?: PublicKey;
 }
 /** @internal */
@@ -840,21 +839,21 @@ declare function convertTokenDataToAccount(address: PublicKey, tokenData: {
 /** Convert compressed account to AccountInfo */
 declare function toAccountInfo(compressedAccount: CompressedAccountWithMerkleContext): AccountInfo<Buffer$1>;
 /** @internal */
-declare function parseCTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
+declare function parseLightTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
     accountInfo: AccountInfo<Buffer$1>;
     loadContext: undefined;
     parsed: Account;
     isCold: false;
 };
 /** @internal */
-declare function parseCTokenCold(address: PublicKey, compressedAccount: CompressedAccountWithMerkleContext): {
+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/c-token.
+ * Retrieve information about a token account of SPL/T22/light-token.
  *
  * @param rpc        RPC connection to use
  * @param address    Token account address
@@ -865,6 +864,228 @@ declare function parseCTokenCold(address: PublicKey, compressedAccount: Compress
  */
 declare function getAccountInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 
+/**
+ * SPL interface PDA info.
+ */
+type SplInterfaceInfo = {
+    /**
+     * The mint of the SPL interface
+     */
+    mint: PublicKey;
+    /**
+     * The SPL interface address
+     */
+    splInterfacePda: PublicKey;
+    /**
+     * The token program of the SPL interface
+     */
+    tokenProgram: PublicKey;
+    /**
+     * count of txs and volume in the past 60 seconds.
+     */
+    activity?: {
+        txs: number;
+        amountAdded: BN;
+        amountRemoved: BN;
+    };
+    /**
+     * Whether the SPL interface is initialized
+     */
+    isInitialized: boolean;
+    /**
+     * The balance of the SPL interface
+     */
+    balance: BN;
+    /**
+     * The index of the SPL interface
+     */
+    poolIndex: number;
+    /**
+     * The bump used to derive the SPL interface PDA
+     */
+    bump: number;
+};
+/**
+ * @deprecated Use {@link SplInterfaceInfo} instead.
+ * This type maintains backward compatibility by including both tokenPoolPda and splInterfacePda.
+ * Both properties point to the same PublicKey value.
+ */
+type TokenPoolInfo = {
+    /**
+     * The mint of the SPL interface
+     */
+    mint: PublicKey;
+    /**
+     * @deprecated Use splInterfacePda instead.
+     */
+    tokenPoolPda: PublicKey;
+    /**
+     * The SPL interface address (new name).
+     * For backward compatibility, tokenPoolPda is also available.
+     */
+    splInterfacePda: PublicKey;
+    /**
+     * The token program of the SPL interface
+     */
+    tokenProgram: PublicKey;
+    /**
+     * count of txs and volume in the past 60 seconds.
+     */
+    activity?: {
+        txs: number;
+        amountAdded: BN;
+        amountRemoved: BN;
+    };
+    /**
+     * Whether the SPL interface is initialized
+     */
+    isInitialized: boolean;
+    /**
+     * The balance of the SPL interface
+     */
+    balance: BN;
+    /**
+     * The index of the SPL interface
+     */
+    poolIndex: number;
+    /**
+     * The bump used to derive the SPL interface PDA
+     */
+    bump: number;
+};
+/**
+ * Convert SplInterfaceInfo to TokenPoolInfo for backward compatibility.
+ * @internal
+ */
+declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
+/**
+ * Derive SplInterfaceInfo for an SPL interface that will be initialized in the
+ * same transaction. Use this when you need to create an SPL interface and
+ * compress in a single transaction.
+ *
+ * @param mint           The mint of the SPL interface
+ * @param tokenProgramId The token program (TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID)
+ * @param poolIndex      The pool index. Default 0.
+ *
+ * @returns SplInterfaceInfo for the to-be-initialized interface
+ */
+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;
+/**
+ * Get the SPL interface infos for a given mint.
+ * @param rpc         The RPC client
+ * @param mint        The mint of the SPL interface
+ * @param commitment  The commitment to use
+ *
+ * @returns The SPL interface infos
+ */
+declare function getSplInterfaceInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<SplInterfaceInfo[]>;
+type SplInterfaceActivity = {
+    signature: string;
+    amount: BN;
+    action: Action;
+};
+/**
+ * @internal
+ */
+declare enum Action {
+    Compress = 1,
+    Decompress = 2,
+    Transfer = 3
+}
+/**
+ * For `compress` and `mintTo` instructions only.
+ * Select a random SPL interface info from the SPL interface infos.
+ *
+ * For `decompress`, use {@link selectSplInterfaceInfosForDecompression} instead.
+ *
+ * @param infos The SPL interface infos
+ *
+ * @returns A random SPL interface info
+ */
+declare function selectSplInterfaceInfo(infos: SplInterfaceInfo[]): SplInterfaceInfo;
+/**
+ * Select one or multiple SPL interface infos from the SPL interface infos.
+ *
+ * Use this function for `decompress`.
+ *
+ * For `compress`, `mintTo` use {@link selectSplInterfaceInfo} instead.
+ *
+ * @param infos             The SPL interface infos
+ * @param decompressAmount  The amount of tokens to withdraw
+ *
+ * @returns Array with one or more SPL interface infos.
+ */
+declare function selectSplInterfaceInfosForDecompression(infos: SplInterfaceInfo[], decompressAmount: number | BN): SplInterfaceInfo[];
+/**
+ * @deprecated Use {@link SplInterfaceActivity} instead.
+ */
+type TokenPoolActivity = SplInterfaceActivity;
+/**
+ * @deprecated Use {@link deriveSplInterfaceInfo} instead.
+ */
+declare function deriveTokenPoolInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): TokenPoolInfo;
+/**
+ * @deprecated Use {@link checkSplInterfaceInfo} instead.
+ */
+declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
+/**
+ * @deprecated Use {@link getSplInterfaceInfos} instead.
+ */
+declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
+/**
+ * @deprecated Use {@link selectSplInterfaceInfo} instead.
+ */
+declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+/**
+ * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
+ */
+declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
+
+declare function sliceLast<T>(items: T[]): {
+    rest: T[];
+    last: T;
+};
+
+/**
+ * Create a light-token transfer instruction.
+ *
+ * For light-token accounts with compressible extension, the program needs
+ * system_program and fee_payer to handle rent top-ups.
+ *
+ * @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 createLightTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
+/**
+ * Create a light-token transfer_checked instruction. Same semantics as SPL
+ * TransferChecked.
+ */
+declare function createLightTokenTransferCheckedInstruction(source: PublicKey, destination: PublicKey, mint: PublicKey, owner: PublicKey, amount: number | bigint, decimals: number, payer: PublicKey): TransactionInstruction;
+
+interface InterfaceOptions {
+    splInterfaceInfos?: SplInterfaceInfo[];
+    /**
+     * ATA owner (authority owner) used to derive the ATA when the signer is a
+     * delegate. For owner-signed flows, omit this field.
+     */
+    owner?: PublicKey;
+}
+interface TransferOptions extends InterfaceOptions {
+    wrap?: boolean;
+    programId?: PublicKey;
+}
+
 interface LayoutObject {
     [key: string]: any;
 }
@@ -1004,7 +1225,7 @@ interface AdditionalMetadata {
 }
 
 /**
- * Token metadata for creating a c-token mint.
+ * Token metadata for creating a light-token mint.
  */
 interface TokenMetadataInstructionData {
     name: string;
@@ -1015,7 +1236,7 @@ interface TokenMetadataInstructionData {
 }
 declare function createTokenMetadata(name: string, symbol: string, uri: string, updateAuthority?: PublicKey | null, additionalMetadata?: AdditionalMetadata[] | null): TokenMetadataInstructionData;
 /**
- * Create instruction for initializing a c-token mint.
+ * Create instruction for initializing a light-token mint.
  *
  * @param mintSigner          Mint signer keypair public key.
  * @param decimals            Number of decimals for the mint.
@@ -1026,8 +1247,9 @@ declare function createTokenMetadata(name: string, symbol: string, uri: string,
  * @param addressTreeInfo     Address tree info for the mint.
  * @param outputStateTreeInfo Output state tree info.
  * @param metadata            Optional token metadata.
+ * @param maxTopUp             Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createMintInstruction(mintSigner: PublicKey, decimals: number, mintAuthority: PublicKey, freezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext, addressTreeInfo: AddressTreeInfo, outputStateTreeInfo: TreeInfo, metadata?: TokenMetadataInstructionData): TransactionInstruction;
+declare function createMintInstruction(mintSigner: PublicKey, decimals: number, mintAuthority: PublicKey, freezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext, addressTreeInfo: AddressTreeInfo, outputStateTreeInfo: TreeInfo, metadata?: TokenMetadataInstructionData, maxTopUp?: number): TransactionInstruction;
 
 /**
  * SPL-compatible base mint structure
@@ -1045,12 +1267,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;
@@ -1088,7 +1310,7 @@ interface TokenMetadata {
     }[];
 }
 /**
- * Complete compressed mint structure (raw format)
+ * Complete light mint structure (raw format)
  */
 interface CompressedMint {
     base: BaseMint;
@@ -1117,7 +1339,7 @@ interface RentConfig {
     maxTopUp: number;
 }
 /**
- * Compression info embedded in CompressedMint
+ * Compression info embedded in light mint
  */
 interface CompressionInfo {
     /** Config account version (0 = uninitialized) */
@@ -1142,18 +1364,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;
@@ -1216,11 +1438,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
@@ -1232,16 +1454,16 @@ interface MintInterface {
  */
 declare function getMintInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<MintInterface>;
 /**
- * Unpack mint info from raw account data for SPL/T22/c-token.
+ * Unpack mint info from raw account data for SPL/T22/light-token.
  *
  * @param address       The mint pubkey
  * @param data          The raw account data or AccountInfo
- * @param programId     Token program ID. Default c-token.
+ * @param programId     Token program ID. Default light-token.
  * @returns Object with mint, optional mintContext and tokenMetadata.
  */
 declare function unpackMintInterface(address: PublicKey, data: Buffer$1 | Uint8Array | AccountInfo<Buffer$1>, programId?: PublicKey): Omit<MintInterface, 'merkleContext'>;
 /**
- * Unpack c-token mint context and metadata from raw account data
+ * Unpack light-token mint context and metadata from raw account data
  *
  * @param data  The raw account data
  * @returns     Object with mintContext, tokenMetadata, and extensions
@@ -1253,17 +1475,20 @@ declare function unpackMintData(data: Buffer$1 | Uint8Array): {
 };
 
 /**
- * Create instruction for updating a compressed mint's mint authority.
+ * Create instruction for updating a light mint's mint authority.
+ * Works for both compressed and decompressed light mints.
  *
  * @param mintInterface          MintInterface from getMintInterface() - must have merkleContext
  * @param currentMintAuthority   Current mint authority public key (must sign)
  * @param newMintAuthority       New mint authority (or null to revoke)
  * @param payer                  Fee payer public key
- * @param validityProof          Validity proof for the compressed mint
+ * @param validityProof          Validity proof for the compressed light mint (null for decompressed light mints)
+ * @param maxTopUp               Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterface, currentMintAuthority: PublicKey, newMintAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext): TransactionInstruction;
+declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterface, currentMintAuthority: PublicKey, newMintAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext | null, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for updating a compressed mint's freeze authority.
+ * Create instruction for updating a light mint's freeze authority.
+ * Works for both compressed and decompressed light mints.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -1272,12 +1497,13 @@ declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterfa
  * @param currentFreezeAuthority   Current freeze authority public key (must sign)
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param payer                    Fee payer public key
- * @param validityProof            Validity proof for the compressed mint
+ * @param validityProof            Validity proof for the compressed light mint (null for decompressed light mints)
+ * @param maxTopUp                 Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInterface, currentFreezeAuthority: PublicKey, newFreezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext): TransactionInstruction;
+declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInterface, currentFreezeAuthority: PublicKey, newFreezeAuthority: PublicKey | null, payer: PublicKey, validityProof: ValidityProofWithContext | null, maxTopUp?: number): TransactionInstruction;
 
 /**
- * Create instruction for updating a compressed mint's metadata field.
+ * Create instruction for updating a light mint's metadata field.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -1285,15 +1511,16 @@ declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInter
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the light mint (null for decompressed light mints)
  * @param fieldType      Field to update: 'name', 'symbol', 'uri', or 'custom'
  * @param value          New value for the field
  * @param customKey      Custom key name (required if fieldType is 'custom')
  * @param extensionIndex Extension index (default: 0)
+ * @param maxTopUp        Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number): TransactionInstruction;
+declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for updating a compressed mint's metadata authority.
+ * Create instruction for updating a light mint's metadata authority.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -1302,12 +1529,13 @@ declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterfa
  * @param currentAuthority Current metadata update authority public key (must sign)
  * @param newAuthority     New metadata update authority public key
  * @param payer            Fee payer public key
- * @param validityProof    Validity proof for the compressed mint
+ * @param validityProof    Validity proof for the light mint (null for decompressed light mints)
  * @param extensionIndex   Extension index (default: 0)
+ * @param maxTopUp         Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInterface, currentAuthority: PublicKey, newAuthority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, extensionIndex?: number): TransactionInstruction;
+declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInterface, currentAuthority: PublicKey, newAuthority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 /**
- * Create instruction for removing a metadata key from a compressed mint.
+ * Create instruction for removing a metadata key from a light mint.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -1315,12 +1543,13 @@ declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInt
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the light mint (null for decompressed light mints)
  * @param key            Metadata key to remove
  * @param idempotent     If true, don't error if key doesn't exist (default: false)
  * @param extensionIndex Extension index (default: 0)
+ * @param maxTopUp        Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createRemoveMetadataKeyInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, key: string, idempotent?: boolean, extensionIndex?: number): TransactionInstruction;
+declare function createRemoveMetadataKeyInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext | null, key: string, idempotent?: boolean, extensionIndex?: number, maxTopUp?: number): TransactionInstruction;
 
 interface CompressToPubkey {
     bump: number;
@@ -1330,531 +1559,274 @@ interface CompressToPubkey {
 interface CompressibleConfig {
     tokenAccountVersion: number;
     rentPayment: number;
-    hasTopUp: number;
     compressionOnly: number;
     writeTopUp: number;
-    compressToAccountPubkey?: CompressToPubkey | null;
-}
-interface CreateAssociatedCTokenAccountParams {
-    bump: number;
-    compressibleConfig?: CompressibleConfig;
-}
-/**
- * Create instruction for creating an associated compressed token account.
- *
- * @param feePayer          Fee payer public key.
- * @param owner             Owner of the associated token account.
- * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
- */
-declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
-/**
- * Create idempotent instruction for creating an associated compressed token account.
- *
- * @param feePayer          Fee payer public key.
- * @param owner             Owner of the associated token account.
- * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
- */
-declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
-
-/**
- * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
- */
-interface CTokenConfig {
-    compressibleConfig?: CompressibleConfig;
-    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
- * end.
- *
- * @param payer                    Fee payer public key.
- * @param associatedToken          Associated token account address.
- * @param owner                    Owner of the associated token account.
- * @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;
-/**
- * Create idempotent 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 end.
- *
- * @param payer                    Fee payer public key.
- * @param associatedToken          Associated token account address.
- * @param owner                    Owner of the associated token account.
- * @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;
-/**
- * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
- */
-declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
-
-/**
- * Create instruction for minting compressed tokens to an onchain token account.
- *
- * @param authority           Mint authority public key.
- * @param payer               Fee payer public key.
- * @param validityProof       Validity proof for the compressed mint.
- * @param merkleContext       Merkle context of the compressed mint.
- * @param mintData            Mint instruction data.
- * @param outputStateTreeInfo Output state tree info.
- * @param recipientAccount    Recipient onchain token account address.
- * @param amount              Amount to mint.
- */
-declare function createMintToInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, outputStateTreeInfo: TreeInfo, recipientAccount: PublicKey, amount: number | bigint): TransactionInstruction;
-
-/**
- * Token data version enum - mirrors Rust TokenDataVersion
- * Used for compressed token account hashing strategy
- */
-declare enum TokenDataVersion {
-    /** V1: Poseidon hash with little-endian amount, discriminator [2,0,0,0,0,0,0,0] */
-    V1 = 1,
-    /** V2: Poseidon hash with big-endian amount, discriminator [0,0,0,0,0,0,0,3] */
-    V2 = 2,
-    /** ShaFlat: SHA256 hash of borsh-serialized data, discriminator [0,0,0,0,0,0,0,4] */
-    ShaFlat = 3
-}
-declare const POOL_SEED: Buffer$1<ArrayBuffer>;
-declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
-declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const MINT_TO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const TRANSFER_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const APPROVE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const REVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-declare const DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
-
-/**
- * Create instruction for minting tokens from a c-mint to compressed accounts.
- * To mint to onchain token accounts across SPL/T22/c-mints, use
- * {@link createMintToInterfaceInstruction} instead.
- *
- * @param authority             Mint authority public key.
- * @param payer                 Fee payer public key.
- * @param validityProof         Validity proof for the compressed mint.
- * @param merkleContext         Merkle context of the compressed mint.
- * @param mintData              Mint instruction data.
- * @param recipients            Array of recipients with amounts.
- * @param outputStateTreeInfo   Optional output state tree info. Uses merkle
- * context queue if not provided.
- * @param tokenAccountVersion   Token account version (default:
- * TokenDataVersion.ShaFlat).
- */
-declare function createMintToCompressedInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, recipients: Array<{
-    recipient: PublicKey;
-    amount: number | bigint;
-}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion): TransactionInstruction;
-
-/**
- * Create mint-to instruction for SPL, Token-2022, or compressed token mints.
- * This instruction ONLY mints to decompressed/onchain token accounts.
- *
- * @param mintInterface   Mint interface (SPL, Token-2022, or compressed).
- * @param destination     Destination onchain token account address.
- * @param authority       Mint authority public key.
- * @param payer           Fee payer public key.
- * @param amount          Amount to mint.
- * @param validityProof   Validity proof (required for compressed mints).
- * @param multiSigners    Multi-signature signer public keys.
- */
-declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
-
-/**
- * Create a c-token transfer instruction.
- *
- * @param source        Source c-token account
- * @param destination   Destination c-token account
- * @param owner         Owner of the source account (signer, also pays for compressible extension top-ups)
- * @param amount        Amount to transfer
- * @returns Transaction instruction for c-token transfer
- */
-declare function createCTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint): TransactionInstruction;
-/**
- * Construct a transfer instruction for SPL/T22/c-token. Defaults to c-token
- * program. For cross-program transfers (SPL <> c-token), use `wrap`/`unwrap`.
- *
- * @param source        Source token account
- * @param destination   Destination token account
- * @param owner         Owner of the source account (signer)
- * @param amount        Amount to transfer
- * @returns instruction for c-token transfer
- */
-declare function createTransferInterfaceInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, multiSigners?: (Signer | PublicKey)[], programId?: PublicKey): TransactionInstruction;
-
-/**
- * SPL interface PDA info.
- */
-type SplInterfaceInfo = {
-    /**
-     * The mint of the SPL interface
-     */
-    mint: PublicKey;
-    /**
-     * The SPL interface address
-     */
-    splInterfacePda: PublicKey;
-    /**
-     * The token program of the SPL interface
-     */
-    tokenProgram: PublicKey;
-    /**
-     * count of txs and volume in the past 60 seconds.
-     */
-    activity?: {
-        txs: number;
-        amountAdded: BN;
-        amountRemoved: BN;
-    };
-    /**
-     * Whether the SPL interface is initialized
-     */
-    isInitialized: boolean;
-    /**
-     * The balance of the SPL interface
-     */
-    balance: BN;
-    /**
-     * The index of the SPL interface
-     */
-    poolIndex: number;
-    /**
-     * The bump used to derive the SPL interface PDA
-     */
-    bump: number;
-};
-/**
- * @deprecated Use {@link SplInterfaceInfo} instead.
- * This type maintains backward compatibility by including both tokenPoolPda and splInterfacePda.
- * Both properties point to the same PublicKey value.
- */
-type TokenPoolInfo = {
-    /**
-     * The mint of the SPL interface
-     */
-    mint: PublicKey;
-    /**
-     * @deprecated Use splInterfacePda instead.
-     */
-    tokenPoolPda: PublicKey;
-    /**
-     * The SPL interface address (new name).
-     * For backward compatibility, tokenPoolPda is also available.
-     */
-    splInterfacePda: PublicKey;
-    /**
-     * The token program of the SPL interface
-     */
-    tokenProgram: PublicKey;
-    /**
-     * count of txs and volume in the past 60 seconds.
-     */
-    activity?: {
-        txs: number;
-        amountAdded: BN;
-        amountRemoved: BN;
-    };
-    /**
-     * Whether the SPL interface is initialized
-     */
-    isInitialized: boolean;
-    /**
-     * The balance of the SPL interface
-     */
-    balance: BN;
-    /**
-     * The index of the SPL interface
-     */
-    poolIndex: number;
-    /**
-     * The bump used to derive the SPL interface PDA
-     */
-    bump: number;
-};
-/**
- * Convert SplInterfaceInfo to TokenPoolInfo for backward compatibility.
- * @internal
- */
-declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
-/**
- * Derive SplInterfaceInfo for an SPL interface that will be initialized in the
- * same transaction. Use this when you need to create an SPL interface and
- * compress in a single transaction.
- *
- * @param mint           The mint of the SPL interface
- * @param tokenProgramId The token program (TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID)
- * @param poolIndex      The pool index. Default 0.
- *
- * @returns SplInterfaceInfo for the to-be-initialized interface
- */
-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;
-/**
- * Get the SPL interface infos for a given mint.
- * @param rpc         The RPC client
- * @param mint        The mint of the SPL interface
- * @param commitment  The commitment to use
- *
- * @returns The SPL interface infos
- */
-declare function getSplInterfaceInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<SplInterfaceInfo[]>;
-type SplInterfaceActivity = {
-    signature: string;
-    amount: BN;
-    action: Action;
-};
-/**
- * @internal
- */
-declare enum Action {
-    Compress = 1,
-    Decompress = 2,
-    Transfer = 3
-}
-/**
- * For `compress` and `mintTo` instructions only.
- * Select a random SPL interface info from the SPL interface infos.
- *
- * For `decompress`, use {@link selectSplInterfaceInfosForDecompression} instead.
- *
- * @param infos The SPL interface infos
- *
- * @returns A random SPL interface info
- */
-declare function selectSplInterfaceInfo(infos: SplInterfaceInfo[]): SplInterfaceInfo;
+    compressToAccountPubkey?: CompressToPubkey | null;
+}
+interface CreateAssociatedLightTokenAccountParams {
+    compressibleConfig?: CompressibleConfig | null;
+}
 /**
- * Select one or multiple SPL interface infos from the SPL interface infos.
+ * Default compressible config for light-token ATAs - matches Rust SDK defaults.
  *
- * Use this function for `decompress`.
+ * - tokenAccountVersion: 3 (ShaFlat) - latest hashing scheme
+ * - rentPayment: 16 - prepay 16 epochs (~24 hours rent)
+ * - compressionOnly: 1 - required for ATAs
+ * - writeTopUp: 766 - per-write top-up (~2 epochs rent) when rent < 2 epochs
+ * - compressToAccountPubkey: null - required for ATAs
  *
- * For `compress`, `mintTo` use {@link selectSplInterfaceInfo} instead.
+ * 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
  *
- * @param infos             The SPL interface infos
- * @param decompressAmount  The amount of tokens to withdraw
+ * Per-write top-up (transfers):
+ * - When account rent is below 2 epochs, fee payer pays 766 lamports top-up
+ * - This keeps the account perpetually funded when actively used
  *
- * @returns Array with one or more SPL interface infos.
+ * Rent calculation (272-byte compressible lightToken account):
+ * - rent_per_epoch = base_rent (128) + bytes * rent_per_byte (272 * 1) = 400 lamports
+ * - 16 epochs = 16 * 400 = 6,400 lamports (24 hours)
+ * - 2 epochs = 2 * 400 = 800 lamports (~3 hours, writeTopUp = 766 is conservative)
+ *
+ * Account size breakdown (272 bytes):
+ * - 165 bytes: SPL token base layout
+ * - 1 byte: account_type discriminator
+ * - 1 byte: Option discriminator for extensions
+ * - 4 bytes: Vec length prefix
+ * - 1 byte: extension type discriminant
+ * - 4 bytes: CompressibleExtension header (decimals_option, decimals, compression_only, is_ata)
+ * - 96 bytes: CompressionInfo struct
  */
-declare function selectSplInterfaceInfosForDecompression(infos: SplInterfaceInfo[], decompressAmount: number | BN): SplInterfaceInfo[];
+declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
 /**
- * @deprecated Use {@link SplInterfaceActivity} instead.
+ * Create instruction for creating an associated light-token account.
+ * Uses the default rent sponsor PDA by default.
+ *
+ * @param feePayer          Fee payer public key.
+ * @param owner             Owner of the associated token account.
+ * @param mint              Mint address.
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-type TokenPoolActivity = SplInterfaceActivity;
+declare function createAssociatedLightTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 /**
- * @deprecated Use {@link deriveSplInterfaceInfo} instead.
+ * Create idempotent instruction for creating an associated light-token account.
+ * Uses the default rent sponsor PDA by default.
+ *
+ * @param feePayer          Fee payer public key.
+ * @param owner             Owner of the associated token account.
+ * @param mint              Mint address.
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function deriveTokenPoolInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): TokenPoolInfo;
+declare function createAssociatedLightTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+
 /**
- * @deprecated Use {@link checkSplInterfaceInfo} instead.
+ * light-token-specific config for createAssociatedTokenAccountInterfaceInstruction
  */
-declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
+interface LightTokenConfig {
+    compressibleConfig?: CompressibleConfig | null;
+    configAccount?: PublicKey;
+    rentPayerPda?: PublicKey;
+}
 /**
- * @deprecated Use {@link getSplInterfaceInfos} instead.
+ * Create instruction for creating an associated token account (SPL, Token-2022,
+ * or light-token). Follows SPL Token API signature with optional light-token config at the
+ * end.
+ *
+ * @param payer                    Fee payer public key.
+ * @param associatedToken          Associated token account address.
+ * @param owner                    Owner of the associated token account.
+ * @param mint                     Mint address.
+ * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
+ * @param associatedTokenProgramId Associated token program ID.
+ * @param lightTokenConfig             Optional light-token-specific configuration.
  */
-declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
+declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): TransactionInstruction;
 /**
- * @deprecated Use {@link selectSplInterfaceInfo} instead.
+ * Create idempotent instruction for creating an associated token account (SPL,
+ * Token-2022, or light-token). Follows SPL Token API signature with optional light-token
+ * config at the end.
+ *
+ * @param payer                    Fee payer public key.
+ * @param associatedToken          Associated token account address.
+ * @param owner                    Owner of the associated token account.
+ * @param mint                     Mint address.
+ * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
+ * @param associatedTokenProgramId Associated token program ID.
+ * @param lightTokenConfig             Optional light-token-specific configuration.
  */
-declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): TransactionInstruction;
 /**
- * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
+ * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
  */
-declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
+declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
 
 /**
- * Create decompressInterface instruction using Transfer2.
+ * 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;
+}
+/**
+ * Create instruction for minting tokens to a light-token account.
  *
- * 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
+ * This is a simple 3-4 account instruction for minting to light-token associated token accounts (hot).
+ * Uses discriminator 7 (LightTokenMintTo).
  *
- * @param payer                        Fee payer public key
- * @param inputCompressedTokenAccounts Input compressed token accounts
- * @param toAddress                    Destination token account address (c-token or SPL ATA)
- * @param amount                       Amount to decompress
- * @param validityProof                Validity proof (contains compressedProof and rootIndices)
- * @param splInterfaceInfo             Optional: SPL interface info for SPL destinations
- * @param decimals                     Mint decimals (required for SPL destinations)
- * @returns TransactionInstruction
+ * @param params - Mint instruction parameters
+ * @returns TransactionInstruction for minting tokens
  */
-declare function createDecompressInterfaceInstruction(payer: PublicKey, inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: bigint, validityProof: ValidityProofWithContext, splInterfaceInfo: SplInterfaceInfo | undefined, decimals: number): TransactionInstruction;
+declare function createMintToInstruction(params: CreateMintToInstructionParams): TransactionInstruction;
 
+/** Default compressible config PDA (V1) */
+declare const LIGHT_TOKEN_CONFIG: PublicKey;
+/** Default rent sponsor PDA (V1) */
+declare const LIGHT_TOKEN_RENT_SPONSOR: PublicKey;
 /**
- * Options for interface operations (load, transfer)
+ * Token data version enum - mirrors Rust TokenDataVersion
+ * Used for compressed token account hashing strategy
  */
-interface InterfaceOptions {
-    /** SPL interface infos (fetched if not provided) */
-    splInterfaceInfos?: SplInterfaceInfo[];
+declare enum TokenDataVersion {
+    /** V1: Poseidon hash with little-endian amount, discriminator [2,0,0,0,0,0,0,0] */
+    V1 = 1,
+    /** V2: Poseidon hash with big-endian amount, discriminator [0,0,0,0,0,0,0,3] */
+    V2 = 2,
+    /** ShaFlat: SHA256 hash of borsh-serialized data, discriminator [0,0,0,0,0,0,0,4] */
+    ShaFlat = 3
 }
-
+declare const POOL_SEED: Buffer$1<ArrayBuffer>;
+declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
+declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
+declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const MINT_TO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const TRANSFER_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const APPROVE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const REVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
 /**
- * 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.
+ * 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 ParsedAccountInfoInterface<T = unknown> {
-    /** Parsed account data (program-specific) */
-    parsed: T;
-    /** Load context - present if account is compressed (cold), undefined if hot */
-    loadContext?: MerkleContext;
-}
+declare const MAX_TOP_UP = 65535;
 /**
- * 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.
+ * Rent configuration constants for compressible light token accounts.
+ * These match the Rust SDK defaults in program-libs/compressible/src/rent/config.rs
  */
-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>;
-}
+/** 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;
 /**
- * Packed compressed account for decompressAccountsIdempotent instruction
+ * Compressible light token account size in bytes.
+ * = 165 (base SPL token) + 1 (account_type) + 1 (Option) + 4 (Vec len) + 1 (ext disc) + 4 (ext header) + 96 (CompressionInfo) = 272
+ * Source: program-libs/token-interface/src/state/token/top_up.rs MIN_SIZE_WITH_COMPRESSIBLE
  */
-interface PackedCompressedAccount {
-    [key: string]: unknown;
-    merkleContext: {
-        merkleTreePubkeyIndex: number;
-        queuePubkeyIndex: number;
-    };
-}
+declare const COMPRESSIBLE_LIGHT_TOKEN_ACCOUNT_SIZE = 272;
 /**
- * Result from building load params
+ * Calculate rent per epoch for a given account size.
+ * Formula: base_rent + (bytes * lamports_per_byte_per_epoch)
  */
-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 function rentPerEpoch(bytes: number): number;
 /**
- * Result from createLoadAccountsParams
+ * Default rent per epoch for a compressible light token account (272 bytes).
+ * = 128 + 272 = 400 lamports
  */
-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 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;
 /**
- * Create params for loading program accounts and ATAs.
- *
- * Returns:
- * - decompressParams: for a caller program's standardized
- *   decompressAccountsIdempotent instruction
- * - ataInstructions: for loading user ATAs
- *
- * @param rpc              RPC connection
- * @param payer            Fee payer (needed for ATA instructions)
- * @param programId        Program ID for decompressAccountsIdempotent
- * @param programAccounts  PDAs and vaults (caller pre-fetches)
- * @param atas             User ATAs (fetched via getAtaInterface)
- * @param options          Optional load options
- * @returns                LoadResult with decompressParams and ataInstructions
- *
- * @example
- * ```typescript
- * const poolInfo = await myProgram.fetchPoolState(rpc, poolAddress);
- * const vault0Ata = getAssociatedTokenAddressInterface(token0Mint, poolAddress);
- * const vault0Info = await getAtaInterface(rpc, vault0Ata, poolAddress, token0Mint, undefined, CTOKEN_PROGRAM_ID);
- * const userAta = getAssociatedTokenAddressInterface(tokenMint, userWallet);
- * const userAtaInfo = await getAtaInterface(rpc, userAta, userWallet, tokenMint);
- *
- * const result = await createLoadAccountsParams(
- *     rpc,
- *     payer.publicKey,
- *     programId,
- *     [
- *         { address: poolAddress, accountType: 'poolState', info: poolInfo },
- *         { address: vault0, accountType: 'cTokenData', tokenVariant: 'token0Vault', info: vault0Info },
- *     ],
- *     [userAta],
- * );
+ * 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.
  *
- * // Build transaction with both program decompress and ATA load
- * const instructions = [...result.ataInstructions];
- * if (result.decompressParams) {
- *     instructions.push(await program.methods
- *         .decompressAccountsIdempotent(
- *             result.decompressParams.proofOption,
- *             result.decompressParams.compressedAccounts,
- *             result.decompressParams.systemAccountsOffset,
- *         )
- *         .remainingAccounts(result.decompressParams.remainingAccounts)
- *         .instruction());
- * }
- * ```
+ * @param authority             Mint authority public key.
+ * @param payer                 Fee payer public key.
+ * @param validityProof         Validity proof for the light mint.
+ * @param merkleContext         Merkle context of the light mint.
+ * @param mintData              Mint instruction data.
+ * @param recipients            Array of recipients with amounts.
+ * @param outputStateTreeInfo   Optional output state tree info. Uses merkle
+ * context queue if not provided.
+ * @param tokenAccountVersion   Token account version (default:
+ * TokenDataVersion.ShaFlat).
+ * @param maxTopUp              Optional cap on rent top-up (units of 1k lamports; default no cap)
  */
-declare function createLoadAccountsParams(rpc: Rpc, payer: PublicKey, programId: PublicKey, programAccounts?: CompressibleAccountInput[], atas?: AccountInterface[], options?: InterfaceOptions): Promise<LoadResult>;
+declare function createMintToCompressedInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, recipients: Array<{
+    recipient: PublicKey;
+    amount: number | bigint;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion, maxTopUp?: number): TransactionInstruction;
+
 /**
- * Calculate compute units for compressible load operation
+ * Create mint-to instruction for SPL, Token-2022, or light-token mints.
+ * This instruction ONLY mints to light-token associated token accounts (hot).
+ *
+ * For light-token mints, the light mint account must exist (mint must be decompressed first).
+ *
+ * @param mintInterface   Mint interface (SPL, Token-2022, or light-token).
+ * @param destination     Destination onchain token account address.
+ * @param authority       Mint authority public key.
+ * @param payer           Fee payer public key.
+ * @param amount          Amount to mint.
+ * @param validityProof   Not used (legacy parameter, kept for compatibility).
+ * @param multiSigners    Multi-signature signer public keys (SPL/T22 only).
  */
-declare function calculateCompressibleLoadComputeUnits(compressedAccountCount: number, hasValidityProof: boolean): number;
+declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
 
 /**
  * Create a wrap instruction that moves tokens from an SPL/T22 account to a
- * c-token account.
+ * light-token account.
  *
  * @param source            Source SPL/T22 token account
- * @param destination       Destination c-token account
+ * @param destination       Destination light-token account
  * @param owner             Owner of the source account (signer)
  * @param mint              Mint address
  * @param amount            Amount to wrap,
  * @param splInterfaceInfo  SPL interface info for the compression
  * @param decimals          Mint decimals (required for transfer_checked)
  * @param payer             Fee payer (defaults to owner)
+ * @param maxTopUp          Optional cap on rent top-up (units of 1k lamports; default no cap)
  * @returns Instruction to wrap tokens
  */
-declare function createWrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey): TransactionInstruction;
+declare function createWrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey, maxTopUp?: number): TransactionInstruction;
 
 /**
- * Create an unwrap instruction that moves tokens from a 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
@@ -1862,24 +1834,96 @@ declare function createWrapInstruction(source: PublicKey, destination: PublicKey
  * @param splInterfaceInfo SPL interface info for the decompression
  * @param decimals         Mint decimals (required for transfer_checked)
  * @param payer            Fee payer (defaults to owner if not provided)
+ * @param maxTopUp         Optional cap on rent top-up (units of 1k lamports; default no cap)
  * @returns TransactionInstruction to unwrap tokens
  */
-declare function createUnwrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey): TransactionInstruction;
+declare function createUnwrapInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount: bigint, splInterfaceInfo: SplInterfaceInfo, decimals: number, payer?: PublicKey, maxTopUp?: number): 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;
 
 /**
- * Create and initialize a new mint for SPL/T22/c-token.
+ * Create and initialize a new mint for SPL/T22/light-token.
  *
  * @param rpc                   RPC connection to use
  * @param payer                 Fee payer
- * @param mintAuthority         Account that will control minting (signer for c-token mints)
+ * @param mintAuthority         Account that will control minting (signer for light-token mints)
  * @param freezeAuthority       Account that will control freeze and thaw (optional)
  * @param decimals              Location of the decimal place
  * @param keypair               Mint keypair (defaults to a random keypair)
  * @param confirmOptions        Confirm options
- * @param programId             Token program ID (defaults to CTOKEN_PROGRAM_ID)
- * @param tokenMetadata         Optional token metadata (c-token mints only)
- * @param outputStateTreeInfo   Optional output state tree info (c-token mints only)
- * @param addressTreeInfo       Optional address tree info (c-token mints only)
+ * @param programId             Token program ID (defaults to LIGHT_TOKEN_PROGRAM_ID)
+ * @param tokenMetadata         Optional token metadata (light-token mints only)
+ * @param outputStateTreeInfo   Optional output state tree info (light-token mints only)
+ * @param addressTreeInfo       Optional address tree info (light-token mints only)
  *
  * @returns Object with mint address and transaction signature
  */
@@ -1889,7 +1933,8 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
 }>;
 
 /**
- * Update the mint authority of a compressed token mint.
+ * Update the mint authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc                    RPC connection
  * @param payer                  Fee payer (signer)
@@ -1900,7 +1945,8 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
  */
 declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentMintAuthority: Signer, newMintAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Update the freeze authority of a compressed token mint.
+ * Update the freeze authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc                      RPC connection
  * @param payer                    Fee payer (signer)
@@ -1912,7 +1958,8 @@ declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, c
 declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentFreezeAuthority: Signer, newFreezeAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Update a metadata field on a compressed token mint.
+ * Update a metadata field on a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -1926,7 +1973,8 @@ declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey,
  */
 declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Update the metadata authority of a compressed token mint.
+ * Update the metadata authority of a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc              RPC connection
  * @param payer            Fee payer (signer)
@@ -1938,7 +1986,8 @@ declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, a
  */
 declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentAuthority: Signer, newAuthority: PublicKey, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
- * Remove a metadata key from a compressed token mint.
+ * Remove a metadata key from a light-token mint.
+ * Works for both compressed and decompressed light mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -1952,8 +2001,8 @@ declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKe
 declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, key: string, idempotent?: boolean, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Create an associated token account for SPL/T22/c-token. Defaults to c-token
- * program.
+ * Create an associated token account for SPL/T22/light-token. Defaults to
+ * light-token program.
  *
  * @param rpc                       RPC connection
  * @param payer                     Fee payer and transaction signer
@@ -1962,16 +2011,16 @@ declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, aut
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional rent config
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  associated token account program ID
+ *                                  (auto-derived if not provided)
+ * @param lightTokenConfig              Optional rent config
  * @returns Address of the new associated token account
  */
-declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): Promise<PublicKey>;
 /**
- * Create an associated token account idempotently for SPL/T22/c-token. Defaults
- * to c-token program.
+ * Create an associated token account idempotently for SPL/T22/light-token.
+ * Defaults to light-token program.
  *
  * If the account already exists, the instruction succeeds without error.
  *
@@ -1982,19 +2031,35 @@ declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, ow
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
- * @param associatedTokenProgramId  ATA program ID (auto-derived if not
- *                                  provided)
- * @param ctokenConfig              Optional c-token-specific configuration
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  associated token account program ID
+ *                                  (auto-derived if not provided)
+ * @param lightTokenConfig              Optional light-token-specific configuration
  *
  * @returns Address of the associated token account
  */
-declare function createAtaInterfaceIdempotent(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+declare function createAtaInterfaceIdempotent(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, lightTokenConfig?: LightTokenConfig): Promise<PublicKey>;
 
-declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, recipientAccount: PublicKey, authority: Signer, amount: number | bigint, outputQueue?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/**
+ * Mint tokens to a light-token account.
+ *
+ * This is a simple mint instruction for minting to light-token associated token accounts (hot).
+ * The light mint account must exist (mint must be decompressed first).
+ *
+ * @param rpc - RPC connection
+ * @param payer - Fee payer (signer)
+ * @param mint - Mint address (light mint account)
+ * @param destination - Destination light-token account
+ * @param authority - Mint authority (signer)
+ * @param amount - Amount to mint
+ * @param maxTopUp - Optional maximum lamports for rent top-up
+ * @param confirmOptions - Optional confirm options
+ * @returns Transaction signature
+ */
+declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | bigint, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
- * Mint compressed tokens directly to compressed accounts.
+ * Mint light-tokens directly to compressed accounts.
  *
  * @param rpc                   RPC connection
  * @param payer                 Fee payer
@@ -2003,77 +2068,63 @@ declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, recipientAcc
  * @param recipients            Array of recipients with amounts
  * @param outputStateTreeInfo   Optional output state tree info (auto-fetched if not provided)
  * @param tokenAccountVersion   Token account version (default: 3)
+ * @param maxTopUp              Optional: cap on rent top-up (units of 1k lamports; default no cap)
  * @param confirmOptions        Optional confirm options
  */
 declare function mintToCompressed(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, recipients: Array<{
     recipient: PublicKey;
     amount: number | bigint;
-}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: number, maxTopUp?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint tokens to a decompressed/onchain token account.
- * Works with SPL, Token-2022, and compressed token (c-token) mints.
+ * Works with SPL, Token-2022, and light-token mints.
+ *
+ * This function ONLY mints to light-token associated token accounts (hot), never to compressed light-token accounts (cold).
+ * For light-token mints, the light mint account must exist (mint must be decompressed first).
  *
- * This function ONLY mints to decompressed onchain token accounts, never to compressed accounts.
  * The signature matches the standard SPL mintTo for simplicity and consistency.
  *
  * @param rpc - RPC connection to use
  * @param payer - Transaction fee payer
- * @param mint - Mint address (SPL, Token-2022, or compressed mint)
+ * @param mint - Mint address (SPL, Token-2022, or light-token mint)
  * @param destination - Destination token account address (must be an existing onchain token account)
  * @param authority - Mint authority (can be Signer or PublicKey if multiSigners provided)
  * @param amount - Amount to mint
  * @param multiSigners - Optional: Multi-signature signers (default: [])
  * @param confirmOptions - Optional: Transaction confirmation options
- * @param programId - Optional: Token program ID (TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, or CTOKEN_PROGRAM_ID). If undefined, auto-detects.
+ * @param programId - Optional: Token program ID. If undefined, auto-detects.
  *
  * @returns Transaction signature
  */
 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>;
 
 /**
- * Decompress compressed (cold) tokens to an on-chain token account.
- *
- * For unified loading, use {@link loadAta} instead.
- *
- * @param rpc                  RPC connection
- * @param payer                Fee payer (signer)
- * @param owner                Owner of the compressed tokens (signer)
- * @param mint                 Mint address
- * @param amount               Amount to decompress (defaults to all)
- * @param destinationAta       Destination token account address
- * @param destinationOwner     Owner of the destination ATA
- * @param splInterfaceInfo     SPL interface info for SPL/T22 destinations
- * @param confirmOptions       Confirm options
- * @returns Transaction signature, null if nothing to load.
- */
-declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, mint: PublicKey, amount?: number | bigint | BN, destinationAta?: PublicKey, destinationOwner?: PublicKey, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature | null>;
-
-/**
- * Wrap tokens from an SPL/T22 account to a c-token account.
+ * Wrap tokens from an SPL/T22 account to a light-token account.
  *
  * This is an agnostic action that takes explicit account addresses (spl-token style).
- * Use getAssociatedTokenAddressSync() to derive ATA addresses if needed.
+ * Use getAssociatedTokenAddressSync() to derive associated token account addresses if needed.
  *
  * @param rpc             RPC connection
  * @param payer           Fee payer
- * @param source          Source SPL/T22 token account (any token account, not just ATA)
- * @param destination     Destination c-token account
+ * @param source          Source SPL/T22 token account (any token account, not just associated token account)
+ * @param destination     Destination light-token account
  * @param owner           Owner/authority of the source account (must sign)
  * @param mint            Mint address
  * @param amount          Amount to wrap
  * @param splInterfaceInfo Optional: SPL interface info (will be fetched if not provided)
+ * @param maxTopUp         Optional: cap on rent top-up (units of 1k lamports; default no cap)
  * @param confirmOptions  Optional: Confirm options
  *
  * @example
  * const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey, false, TOKEN_PROGRAM_ID);
- * const ctokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // defaults to c-token
+ * const lightTokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // defaults to light-token
  *
  * await wrap(
  *   rpc,
  *   payer,
  *   splAta,
- *   ctokenAta,
+ *   lightTokenAta,
  *   owner,
  *   mint,
  *   1000n,
@@ -2081,41 +2132,7 @@ declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, min
  *
  * @returns Transaction signature
  */
-declare function wrap(rpc: Rpc, payer: Signer, source: PublicKey, destination: PublicKey, owner: Signer, mint: PublicKey, amount: bigint, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
-/**
- * Unwrap c-tokens to SPL tokens.
- *
- * @param rpc                RPC connection
- * @param payer              Fee payer
- * @param destination        Destination SPL/T22 token account
- * @param owner              Owner of the c-token (signer)
- * @param mint               Mint address
- * @param amount             Amount to unwrap (defaults to all)
- * @param splInterfaceInfo   SPL interface info
- * @param confirmOptions     Confirm options
- *
- * @returns Transaction signature
- */
-declare function unwrap(rpc: Rpc, payer: Signer, destination: PublicKey, owner: Signer, mint: PublicKey, amount?: number | bigint | BN, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
-/**
- * Create instructions to load an ATA from its AccountInterface.
- *
- * Behavior depends on `wrap` parameter:
- * - wrap=false (standard): Decompress compressed tokens to the target ATA type
- *   (SPL ATA via pool, T22 ATA via pool, or c-token ATA direct)
- * - wrap=true (unified): Wrap SPL/T22 + decompress all to c-token ATA
- *
- * @param rpc         RPC connection
- * @param payer       Fee payer
- * @param ata         AccountInterface from getAtaInterface (must have _isAta, _owner, _mint)
- * @param options     Optional load options
- * @param wrap        Unified mode: wrap SPL/T22 to c-token (default: false)
- * @param targetAta   Target ATA address (used for type detection in standard mode)
- * @returns           Array of instructions (empty if nothing to load)
- */
-declare function createLoadAtaInstructionsFromInterface(rpc: Rpc, payer: PublicKey, ata: AccountInterface, options?: InterfaceOptions, wrap?: boolean, targetAta?: PublicKey): Promise<TransactionInstruction[]>;
+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>;
 
 /**
  * Input for creating off-chain metadata JSON.
@@ -2165,7 +2182,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);
@@ -2176,18 +2193,30 @@ interface OffChainTokenMetadataJson {
 declare function toOffChainMetadataJson(meta: OffChainTokenMetadata): OffChainTokenMetadataJson;
 
 /**
- * Returns the compressed mint address as bytes.
+ * Returns the light mint address as bytes.
+ * @internal
  */
 declare function deriveCMintAddress(mintSeed: PublicKey, addressTreeInfo: TreeInfo): number[];
 declare const COMPRESSED_MINT_SEED: Buffer$1;
 /**
- * Finds the SPL mint PDA for a c-token mint.
+ * Finds the SPL mint PDA for a light-token mint.
  * @param mintSeed The mint seed public key.
  * @returns [PDA, bump]
+ * @internal
  */
 declare function findMintAddress(mintSigner: PublicKey): [PublicKey, number];
-declare function getAssociatedCTokenAddressAndBump(owner: PublicKey, mint: PublicKey): [PublicKey, number];
-declare function getAssociatedCTokenAddress(owner: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * Same as "getAssociatedTokenAddress" but returns the bump as well.
+ * Uses light-token program ID.
+ * @internal
+ */
+declare function getAssociatedLightTokenAddressAndBump(owner: PublicKey, mint: PublicKey): [PublicKey, number];
+/**
+ * Same as "getAssociatedTokenAddress", returning just the associated token address.
+ * Uses light-token program ID.
+ * @internal
+ */
+declare function getAssociatedLightTokenAddress(owner: PublicKey, mint: PublicKey): PublicKey;
 
 /**
  * Approve a delegate to spend tokens
@@ -5218,14 +5247,14 @@ declare class CompressedTokenProgram {
      * @param mintSize              Optional: mint size. Default: MINT_SIZE
      *
      * @returns [createMintAccountInstruction, initializeMintInstruction,
-     * createTokenPoolInstruction]
+     * createSplInterfaceInstruction]
      *
-     * Note that `createTokenPoolInstruction` must be executed after
+     * Note that `createSplInterfaceInstruction` must be executed after
      * `initializeMintInstruction`.
      */
     static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * Create SPL interface (omnibus account) for an existing SPL mint.
      * For new mints, use `CompressedTokenProgram.createMint`.
      *
      * @param feePayer              Fee payer.
@@ -5233,12 +5262,16 @@ declare class CompressedTokenProgram {
      * @param tokenProgramId        Optional: Token program ID. Default: SPL
      *                              Token Program ID
      *
-     * @returns The createTokenPool instruction
+     * @returns The createSplInterface instruction
      */
-    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    static createSplInterface({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    /**
+     * @deprecated Use {@link createSplInterface} instead.
+     */
+    static createTokenPool(params: CreateSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Add a token pool to an existing SPL mint.  For new mints, use
-     * {@link createTokenPool}.
+     * {@link createSplInterface}.
      *
      * @param feePayer              Fee payer.
      * @param mint                  SPL Mint address.
@@ -5402,6 +5435,13 @@ declare class CompressedTokenProgram {
     static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
+/**
+ * Exports for @lightprotocol/compressed-token/unified
+ *
+ * Import from `/unified` to get a single unified associated token account for SPL/T22 and light-token
+ * mints.
+ */
+
 /**
  * Get associated token account with unified balance
  *
@@ -5415,21 +5455,21 @@ declare class CompressedTokenProgram {
  */
 declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
- * Derive the canonical token ATA for SPL/T22/c-token in the unified path.
+ * Derive the canonical token associated token account for SPL/T22/light-token in the unified path.
  *
- * Enforces CTOKEN_PROGRAM_ID.
+ * Enforces LIGHT_TOKEN_PROGRAM_ID.
  *
  * @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;
 /**
- * Create instructions to load ALL token balances into a c-token ATA.
+ * Create instruction batches for loading ALL token balances into a light-token associated token account.
  *
  * @param rpc     RPC connection
  * @param ata     Associated token address
@@ -5437,18 +5477,18 @@ declare function getAssociatedTokenAddressInterface(mint: PublicKey, owner: Publ
  * @param mint    Mint public key
  * @param payer   Fee payer (defaults to owner)
  * @param options Optional interface options
- * @returns Array of instructions (empty if nothing to load)
+ * @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<_solana_web3_js.TransactionInstruction[]>;
+declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, payer?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
 /**
- * Load all token balances into the c-token ATA.
+ * Load all token balances into the light-token associated token account.
  *
- * Wraps SPL/Token-2022 balances and decompresses compressed c-tokens
- * into the on-chain c-token ATA. If no balances exist and the ATA doesn't
+ * Wraps SPL/Token-2022 balances and decompresses compressed light-tokens
+ * into the on-chain light-token associated token account. If no balances exist and the associated token account doesn't
  * exist, creates an empty ATA (idempotent).
  *
  * @param rpc               RPC connection
- * @param ata               Associated token address (c-token)
+ * @param ata               Associated token address (light-token)
  * @param owner             Owner of the tokens (signer)
  * @param mint              Mint public key
  * @param payer             Fee payer (signer, defaults to owner)
@@ -5456,38 +5496,44 @@ declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: Publ
  * @param interfaceOptions  Optional interface options
  * @returns Transaction signature, or null if ATA exists and nothing to load
  */
-declare function loadAta(rpc: Rpc, ata: PublicKey, owner: Signer, mint: PublicKey, payer?: Signer, confirmOptions?: ConfirmOptions, interfaceOptions?: InterfaceOptions): Promise<string | null>;
+declare function loadAta(rpc: Rpc, ata: PublicKey, owner: Signer, mint: PublicKey, payer?: Signer, confirmOptions?: ConfirmOptions, interfaceOptions?: InterfaceOptions, decimals?: number): Promise<string | null>;
 /**
  * Transfer tokens using the unified ata interface.
  *
- * Matches SPL Token's transferChecked signature order. Destination must exist.
+ * Destination ATA is derived from `recipient` and created idempotently.
+ * Automatically wraps SPL/T22 to light-token associated token account.
  *
  * @param rpc             RPC connection
  * @param payer           Fee payer (signer)
- * @param source          Source c-token ATA address
+ * @param source          Source light-token associated token account address
  * @param mint            Mint address
- * @param destination     Destination c-token ATA address (must exist)
+ * @param recipient       Destination owner wallet address
  * @param owner           Source owner (signer)
  * @param amount          Amount to transfer
- * @param programId       Token program ID (default: CTOKEN_PROGRAM_ID)
  * @param confirmOptions  Optional confirm options
  * @param options         Optional interface options
  * @returns Transaction signature
  */
-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): Promise<string>;
+declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, recipient: PublicKey, owner: Signer, amount: number | bigint | BN, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<string>;
+/**
+ * Transfer tokens to an explicit destination token account.
+ *
+ * Use this for advanced routing to non-ATA destinations.
+ */
+declare function transferToAccountInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, destination: PublicKey, owner: Signer, amount: number | bigint | BN, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<string>;
 /**
- * Get or create c-token ATA with unified balance detection and auto-loading.
+ * Get or create light-token ATA with unified balance detection and auto-loading.
  *
- * Enforces CTOKEN_PROGRAM_ID. Aggregates balances from:
- * - c-token hot (on-chain) account
- * - c-token cold (compressed) accounts
+ * Enforces LIGHT_TOKEN_PROGRAM_ID. Aggregates balances from:
+ * - light-token associated token account (hot balance)
+ * - compressed light-token accounts (cold balance)
  * - SPL token accounts (for unified wrapping)
  * - Token-2022 accounts (for unified wrapping)
  *
  * When owner is a Signer:
  * - Creates hot ATA if it doesn't exist
  * - Loads cold (compressed) tokens into hot ATA
- * - Wraps SPL/T22 tokens into c-token ATA
+ * - Wraps SPL/T22 tokens into light-token associated token account
  * - Returns account with all tokens ready to use
  *
  * When owner is a PublicKey:
@@ -5504,5 +5550,121 @@ declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, m
  * @returns AccountInterface with unified balance and source breakdown
  */
 declare function getOrCreateAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey | Signer, allowOwnerOffCurve?: boolean, commitment?: Commitment, confirmOptions?: ConfirmOptions): Promise<AccountInterface>;
+/**
+ * Create transfer instructions for a unified token transfer.
+ *
+ * Unified variant: always wraps SPL/T22 to light-token associated token account.
+ * Recipient must be an on-curve wallet address. For PDA/off-curve owners,
+ * use createTransferToAccountInterfaceInstructions with an explicit destination ATA.
+ *
+ * Returns `TransactionInstruction[][]`. Send [0..n-2] in parallel, then [n-1].
+ * Use `sliceLast` to separate the parallel prefix from the final transfer.
+ *
+ * @see createTransferInterfaceInstructions in v3/actions/transfer-interface.ts
+ */
+declare function createTransferInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, sender: PublicKey, recipient: PublicKey, options?: Omit<TransferOptions, 'wrap'>): Promise<TransactionInstruction[][]>;
+/**
+ * Create transfer instructions that route to an explicit destination token
+ * account.
+ */
+declare function createTransferToAccountInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, sender: PublicKey, destination: PublicKey, options?: Omit<TransferOptions, 'wrap'>): Promise<TransactionInstruction[][]>;
+/**
+ * Build instruction batches for unwrapping light-tokens to SPL/T22.
+ *
+ * Load batches (cold -> hot) come first if needed; unwrap is bundled into the
+ * final batch.
+ * SPL/T22 balances are not consolidated; only light ATA (hot + cold) is unwrapped.
+ *
+ * Returns `TransactionInstruction[][]`. Load-only batches (if any) come first;
+ * the last batch contains unwrap.
+ *
+ * @param rpc               RPC connection
+ * @param destination       Destination SPL/T22 token account (must exist)
+ * @param owner             Owner of the light-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 interfaceOptions  Optional: interface options for load
+ * @returns Instruction batches - each inner array is one transaction
+ */
+declare function createUnwrapInstructions(rpc: Rpc, destination: PublicKey, owner: PublicKey, mint: PublicKey, amount?: number | bigint | BN, payer?: PublicKey, splInterfaceInfo?: SplInterfaceInfo, interfaceOptions?: InterfaceOptions): Promise<TransactionInstruction[][]>;
+/**
+ * Unwrap light-tokens to SPL tokens.
+ *
+ * Loads cold into hot if needed, then unwraps from light ATA to destination SPL/T22.
+ * SPL/T22 balances are not consolidated; only light ATA balance is unwrapped.
+ *
+ * @param rpc                RPC connection
+ * @param payer              Fee payer
+ * @param destination        Destination SPL/T22 token account
+ * @param owner              Owner of the light-token (signer)
+ * @param mint               Mint address
+ * @param amount             Amount to unwrap (defaults to all)
+ * @param splInterfaceInfo   SPL interface info
+ * @param confirmOptions     Confirm options
+ * @returns Transaction signature of the unwrap transaction
+ */
+declare function unwrap(rpc: Rpc, payer: Signer, destination: PublicKey, owner: Signer, mint: PublicKey, amount?: number | bigint | BN, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions, decimals?: number): Promise<string>;
+
+/**
+ * Approve a delegate for an associated token account.
+ *
+ * Auto-detects mint type (light-token, SPL, or Token-2022) and dispatches
+ * to the appropriate instruction.
+ *
+ * @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 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
+ * @returns Transaction signature
+ */
+declare function approveInterface(rpc: Rpc, payer: Signer, tokenAccount: PublicKey, mint: PublicKey, delegate: PublicKey, amount: number | bigint | BN, owner: Signer, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<string>;
+/**
+ * Build instruction batches for approving a delegate on an ATA.
+ *
+ * Auto-detects mint type (light-token, SPL, or Token-2022).
+ *
+ * @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.
+ */
+declare function createApproveInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, tokenAccount: PublicKey, delegate: PublicKey, amount: number | bigint | BN, owner: PublicKey, decimals?: number, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
+/**
+ * Revoke delegation for an associated token account.
+ *
+ * Auto-detects mint type (light-token, SPL, or Token-2022) and dispatches
+ * to the appropriate instruction.
+ *
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA before the revoke instruction.
+ *
+ * @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
+ * @returns Transaction signature
+ */
+declare function revokeInterface(rpc: Rpc, payer: Signer, tokenAccount: PublicKey, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, decimals?: number): Promise<string>;
+/**
+ * Build instruction batches for revoking delegation on an ATA.
+ *
+ * Auto-detects mint type (light-token, SPL, or Token-2022).
+ *
+ * @remarks For light-token mints, all cold (compressed) balances are loaded
+ * into the hot ATA before the revoke instruction.
+ */
+declare function createRevokeInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, tokenAccount: PublicKey, owner: PublicKey, decimals?: number, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
 
-export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESSED_MINT_SEED, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CTokenConfig, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleAccountInput, type CompressibleConfig, type CompressibleLoadParams, CpiContextLayout, type CreateAssociatedCTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_MIXED_TREE_TYPES, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, type LightCompressedToken, type LoadResult, MINT_TO_DISCRIMINATOR, type MergeTokenAccountsParams, type MintContext, type MintExtension, type MintInterface, type MintToInstructionData, type MintToParams, type OffChainTokenMetadata, type OffChainTokenMetadataJson, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedCompressedAccount, type PackedTokenTransferOutputData, type ParsedAccountInfoInterface, REVOKE_DISCRIMINATOR, type RevokeParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type SelectInputAccountsOptions, type SelectedAccountsResult, type SplInterfaceActivity, type SplInterfaceInfo, TRANSFER_DISCRIMINATOR, type TokenAccountSource, type TokenData, TokenDataVersion, type TokenMetadata, type TokenMetadataInstructionData, type TokenPoolActivity, type TokenPoolInfo, type TokenTransferOutputData, type TransferParams, addSplInterfaces, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, calculateCompressibleLoadComputeUnits, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createAssociatedCTokenAccountIdempotentInstruction, createAssociatedCTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createCTokenTransferInstruction, createDecompressInterfaceInstruction, createDecompressOutputState, createLoadAccountsParams, createLoadAtaInstructions, createLoadAtaInstructionsFromInterface, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstruction, createTransferOutputState, createUnwrapInstruction, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, decompressInterface, deriveCMintAddress, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, extractTokenMetadata, findMintAddress, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedCTokenAddress, getAssociatedCTokenAddressAndBump, 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, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, selectAccountsByPreferredTreeType, selectMinCompressedTokenAccountsForDecompression, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, selectSplInterfaceInfo, selectSplInterfaceInfosForDecompression, selectTokenAccountsForApprove, selectTokenPoolInfo, selectTokenPoolInfosForDecompression, serializeMint, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, toAccountInfo, toOffChainMetadataJson, toTokenPoolInfo, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, transferInterface, unpackMintData, unpackMintInterface, unwrap, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };
+export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BASE_RENT_PER_EPOCH, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESSED_MINT_SEED, 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, MAX_TOP_UP, 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 TransferOptions, type TransferParams, type TransferOptions as TransferToAccountOptions, 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, deriveCMintAddress, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, extractTokenMetadata, findMintAddress, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedLightTokenAddress, getAssociatedLightTokenAddressAndBump, 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, 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, unwrap, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };