@lightprotocol/compressed-token 0.23.0-beta.4 → 0.23.0-beta.6

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

@@ -1,39 +1,13 @@
 /// <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, AccountMeta, Signer, 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';
 export { ParsedTokenAccount } from '@lightprotocol/stateless.js';
 import { Account, Mint } from '@solana/spl-token';
 export { AccountState } from '@solana/spl-token';
 
 declare namespace BN {
-    type Endianness = 'le' | 'be';
-    type IPrimeName = 'k256' | 'p224' | 'p192' | 'p25519';
+    type Endianness = "le" | "be";
+    type IPrimeName = "k256" | "p224" | "p192" | "p25519";
 
     interface MPrime {
         name: string;
@@ -55,7 +29,7 @@ declare class BN {
 
     constructor(
         number: bigint | number | string | number[] | Uint8Array | Buffer | BN,
-        base?: number | 'hex',
+        base?: number | "hex",
         endian?: BN.Endianness,
     );
     constructor(
@@ -101,7 +75,7 @@ declare class BN {
     /**
      * @description  convert to base-string and pad with zeroes
      */
-    toString(base?: number | 'hex', length?: number): string;
+    toString(base?: number | "hex", length?: number): string;
 
     /**
      * @description convert to Javascript Number (limited to 53 bits)
@@ -361,11 +335,7 @@ declare class BN {
     /**
      * @description division with remainder
      */
-    divmod(
-        b: BN,
-        mode?: 'div' | 'mod',
-        positive?: boolean,
-    ): { div: BN; mod: BN };
+    divmod(b: BN, mode?: "div" | "mod", positive?: boolean): { div: BN; mod: BN };
 
     /**
      * @description reduct
@@ -629,54 +599,18 @@ declare class RedBN extends BN {
 }
 
 declare class Buffer$1 extends Uint8Array {
-    length: number;
-    write(
-        string: string,
-        offset?: number,
-        length?: number,
-        encoding?: string,
-    ): number;
+    length: number
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
     toString(encoding?: string, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer'; data: any[] };
+    toJSON(): { type: 'Buffer', data: any[] };
     equals(otherBuffer: Buffer$1): boolean;
-    compare(
-        otherBuffer: Uint8Array,
-        targetStart?: number,
-        targetEnd?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
-    copy(
-        targetBuffer: Buffer$1,
-        targetStart?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
+    compare(otherBuffer: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+    copy(targetBuffer: Buffer$1, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
     slice(start?: number, end?: number): Buffer$1;
-    writeUIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeUIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
+    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
     readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
@@ -722,21 +656,9 @@ declare class Buffer$1 extends Uint8Array {
     writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
     writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
     fill(value: any, offset?: number, end?: number): this;
-    indexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    lastIndexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    includes(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): boolean;
+    indexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    includes(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): boolean;
 
     /**
      * Allocates a new buffer containing the given {str}.
@@ -744,19 +666,19 @@ declare class Buffer$1 extends Uint8Array {
      * @param str String to store in buffer.
      * @param encoding encoding to use, optional.  Default is 'utf8'
      */
-    constructor(str: string, encoding?: string);
+    constructor (str: string, encoding?: string);
     /**
      * Allocates a new buffer of {size} octets.
      *
      * @param size count of octets to allocate.
      */
-    constructor(size: number);
+    constructor (size: number);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: Uint8Array);
+    constructor (array: Uint8Array);
     /**
      * Produces a Buffer backed by the same allocated memory as
      * the given {ArrayBuffer}.
@@ -764,19 +686,19 @@ declare class Buffer$1 extends Uint8Array {
      *
      * @param arrayBuffer The ArrayBuffer with which to share memory.
      */
-    constructor(arrayBuffer: ArrayBuffer);
+    constructor (arrayBuffer: ArrayBuffer);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: any[]);
+    constructor (array: any[]);
     /**
      * Copies the passed {buffer} data onto a new {Buffer} instance.
      *
      * @param buffer The buffer to copy.
      */
-    constructor(buffer: Buffer$1);
+    constructor (buffer: Buffer$1);
     prototype: Buffer$1;
     /**
      * Allocates a new Buffer using an {array} of octets.
@@ -794,11 +716,7 @@ declare class Buffer$1 extends Uint8Array {
      * @param byteOffset
      * @param length
      */
-    static from(
-        arrayBuffer: ArrayBuffer,
-        byteOffset?: number,
-        length?: number,
-    ): Buffer$1;
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer$1;
     /**
      * Copies the passed {buffer} data onto a new Buffer instance.
      *
@@ -858,11 +776,7 @@ declare class Buffer$1 extends Uint8Array {
      *    If parameter is omitted, buffer will be filled with zeros.
      * @param encoding encoding used for call to buf.fill while initializing
      */
-    static alloc(
-        size: number,
-        fill?: string | Buffer$1 | number,
-        encoding?: string,
-    ): Buffer$1;
+    static alloc(size: number, fill?: string | Buffer$1 | number, encoding?: string): Buffer$1;
     /**
      * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.
@@ -880,15 +794,14 @@ declare class Buffer$1 extends Uint8Array {
 }
 
 declare const TokenAccountSourceType: {
-    readonly Spl: 'spl';
-    readonly Token2022: 'token2022';
-    readonly SplCold: 'spl-cold';
-    readonly Token2022Cold: 'token2022-cold';
-    readonly CTokenHot: 'ctoken-hot';
-    readonly CTokenCold: 'ctoken-cold';
+    readonly Spl: "spl";
+    readonly Token2022: "token2022";
+    readonly SplCold: "spl-cold";
+    readonly Token2022Cold: "token2022-cold";
+    readonly CTokenHot: "ctoken-hot";
+    readonly CTokenCold: "ctoken-cold";
 };
-type TokenAccountSourceTypeValue =
-    (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
+type TokenAccountSourceTypeValue = (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
 /** @internal */
 interface TokenAccountSource {
     type: TokenAccountSourceTypeValue;
@@ -915,36 +828,25 @@ interface AccountInterface {
     _mint?: PublicKey;
 }
 /** @internal */
-declare function convertTokenDataToAccount(
-    address: PublicKey,
-    tokenData: {
-        mint: PublicKey;
-        owner: PublicKey;
-        amount: BN;
-        delegate: PublicKey | null;
-        state: number;
-        tlv: Buffer$1 | null;
-    },
-): Account;
+declare function convertTokenDataToAccount(address: PublicKey, tokenData: {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: number;
+    tlv: Buffer$1 | null;
+}): Account;
 /** Convert compressed account to AccountInfo */
-declare function toAccountInfo(
-    compressedAccount: CompressedAccountWithMerkleContext,
-): AccountInfo<Buffer$1>;
+declare function toAccountInfo(compressedAccount: CompressedAccountWithMerkleContext): AccountInfo<Buffer$1>;
 /** @internal */
-declare function parseCTokenHot(
-    address: PublicKey,
-    accountInfo: AccountInfo<Buffer$1>,
-): {
+declare function parseCTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
     accountInfo: AccountInfo<Buffer$1>;
     loadContext: undefined;
     parsed: Account;
     isCold: false;
 };
 /** @internal */
-declare function parseCTokenCold(
-    address: PublicKey,
-    compressedAccount: CompressedAccountWithMerkleContext,
-): {
+declare function parseCTokenCold(address: PublicKey, compressedAccount: CompressedAccountWithMerkleContext): {
     accountInfo: AccountInfo<Buffer$1>;
     loadContext: MerkleContext;
     parsed: Account;
@@ -960,12 +862,230 @@ declare function parseCTokenCold(
  *
  * @return Token account information with compression context if applicable
  */
-declare function getAccountInterface(
-    rpc: Rpc,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<AccountInterface>;
+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[];
+
+/**
+ * Options for interface operations (load, transfer)
+ */
+interface InterfaceOptions {
+    /** SPL interface infos (fetched if not provided) */
+    splInterfaceInfos?: SplInterfaceInfo[];
+}
+/**
+ * Options for createTransferInterfaceInstructions.
+ */
+interface TransferOptions extends InterfaceOptions {
+    /** Include SPL/T22 wrapping to c-token ATA (unified path). Default: false. */
+    wrap?: boolean;
+    /** Token program ID. Default: LIGHT_TOKEN_PROGRAM_ID. */
+    programId?: PublicKey;
+    /**
+     * Include an idempotent recipient ATA creation instruction in the
+     * transfer transaction. No extra RPC fetch -- uses
+     * createAssociatedTokenAccountInterfaceIdempotentInstruction which is
+     * a no-op on-chain if the ATA already exists (~200 CU overhead).
+     * Default: true.
+     */
+    ensureRecipientAta?: boolean;
+}
+/**
+ * Splits the last element from an array.
+ *
+ * Useful for separating load transactions (parallel) from the final transfer
+ * transaction (sequential) returned by `createTransferInterfaceInstructions`.
+ *
+ * @returns `{ rest, last }` where `rest` is everything before the last
+ * element and `last` is the last element.
+ * @throws if the input array is empty.
+ */
+declare function sliceLast<T>(items: T[]): {
+    rest: T[];
+    last: T;
+};
 
 interface LayoutObject {
     [key: string]: any;
@@ -1115,13 +1235,7 @@ interface TokenMetadataInstructionData {
     updateAuthority?: PublicKey | null;
     additionalMetadata: AdditionalMetadata[] | null;
 }
-declare function createTokenMetadata(
-    name: string,
-    symbol: string,
-    uri: string,
-    updateAuthority?: PublicKey | null,
-    additionalMetadata?: AdditionalMetadata[] | null,
-): TokenMetadataInstructionData;
+declare function createTokenMetadata(name: string, symbol: string, uri: string, updateAuthority?: PublicKey | null, additionalMetadata?: AdditionalMetadata[] | null): TokenMetadataInstructionData;
 /**
  * Create instruction for initializing a c-token mint.
  *
@@ -1135,17 +1249,7 @@ declare function createTokenMetadata(
  * @param outputStateTreeInfo Output state tree info.
  * @param metadata            Optional token metadata.
  */
-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): TransactionInstruction;
 
 /**
  * SPL-compatible base mint structure
@@ -1279,7 +1383,7 @@ declare function serializeMint(mint: CompressedMint): Buffer$1;
  * Extension type constants
  */
 declare enum ExtensionType {
-    TokenMetadata = 19,
+    TokenMetadata = 19
 }
 /**
  * Decode TokenMetadata from raw extension data using Borsh layout
@@ -1297,9 +1401,7 @@ declare function encodeTokenMetadata(metadata: TokenMetadata): Buffer$1;
  * @param extensions - Array of raw extensions
  * @returns Parsed TokenMetadata or null if not found
  */
-declare function extractTokenMetadata(
-    extensions: MintExtension[] | null,
-): TokenMetadata | null;
+declare function extractTokenMetadata(extensions: MintExtension[] | null): TokenMetadata | null;
 /**
  * Metadata portion of MintInstructionData
  * Used for instruction encoding when metadata extension is present
@@ -1350,12 +1452,7 @@ interface MintInterface {
  * @returns Object with mint, optional merkleContext, mintContext, and
  * tokenMetadata
  */
-declare function getMintInterface(
-    rpc: Rpc,
-    address: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<MintInterface>;
+declare function getMintInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<MintInterface>;
 /**
  * Unpack mint info from raw account data for SPL/T22/c-token.
  *
@@ -1364,11 +1461,7 @@ declare function getMintInterface(
  * @param programId     Token program ID. Default c-token.
  * @returns Object with mint, optional mintContext and tokenMetadata.
  */
-declare function unpackMintInterface(
-    address: PublicKey,
-    data: Buffer$1 | Uint8Array | AccountInfo<Buffer$1>,
-    programId?: PublicKey,
-): Omit<MintInterface, 'merkleContext'>;
+declare function unpackMintInterface(address: PublicKey, data: Buffer$1 | Uint8Array | AccountInfo<Buffer$1>, programId?: PublicKey): Omit<MintInterface, 'merkleContext'>;
 /**
  * Unpack c-token mint context and metadata from raw account data
  *
@@ -1383,22 +1476,18 @@ declare function unpackMintData(data: Buffer$1 | Uint8Array): {
 
 /**
  * Create instruction for updating a compressed mint's mint authority.
+ * Works for both compressed and decompressed 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 mint (null for decompressed mints)
  */
-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): TransactionInstruction;
 /**
  * Create instruction for updating a compressed mint's freeze authority.
+ * Works for both compressed and decompressed mints.
  *
  * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
  * (preferring nextTreeInfo.queue if available for rollover support).
@@ -1407,15 +1496,9 @@ declare function createUpdateMintAuthorityInstruction(
  * @param currentFreezeAuthority   Current freeze authority public key (must sign)
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param payer                    Fee payer public key
- * @param validityProof            Validity proof for the compressed mint
+ * @param validityProof            Validity proof for the compressed mint (null for decompressed mints)
  */
-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): TransactionInstruction;
 
 /**
  * Create instruction for updating a compressed mint's metadata field.
@@ -1426,22 +1509,13 @@ declare function createUpdateFreezeAuthorityInstruction(
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the compressed mint (null for decompressed 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)
  */
-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): TransactionInstruction;
 /**
  * Create instruction for updating a compressed mint's metadata authority.
  *
@@ -1452,17 +1526,10 @@ declare function createUpdateMetadataFieldInstruction(
  * @param currentAuthority Current metadata update authority public key (must sign)
  * @param newAuthority     New metadata update authority public key
  * @param payer            Fee payer public key
- * @param validityProof    Validity proof for the compressed mint
+ * @param validityProof    Validity proof for the compressed mint (null for decompressed mints)
  * @param extensionIndex   Extension index (default: 0)
  */
-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): TransactionInstruction;
 /**
  * Create instruction for removing a metadata key from a compressed mint.
  *
@@ -1472,20 +1539,12 @@ declare function createUpdateMetadataAuthorityInstruction(
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the compressed mint (null for decompressed 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)
  */
-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): TransactionInstruction;
 
 interface CompressToPubkey {
     bump: number;
@@ -1495,456 +1554,260 @@ interface CompressToPubkey {
 interface CompressibleConfig {
     tokenAccountVersion: number;
     rentPayment: number;
-    hasTopUp: number;
     compressionOnly: number;
     writeTopUp: number;
     compressToAccountPubkey?: CompressToPubkey | null;
 }
 interface CreateAssociatedCTokenAccountParams {
-    bump: number;
-    compressibleConfig?: CompressibleConfig;
+    compressibleConfig?: CompressibleConfig | null;
 }
 /**
- * Create instruction for creating an associated compressed token account.
+ * Default compressible config for c-token ATAs - matches Rust SDK defaults.
  *
- * @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.
+ * - 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
  *
- * @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.
+ * Cost breakdown at ATA 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 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.
+ * 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
  *
- * @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.
+ * Rent calculation (272-byte compressible ctoken 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)
  *
- * @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.
+ * 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 createMintToInstruction(
-    authority: PublicKey,
-    payer: PublicKey,
-    validityProof: ValidityProofWithContext,
-    merkleContext: MerkleContext,
-    mintData: MintInstructionData,
-    outputStateTreeInfo: TreeInfo,
-    recipientAccount: PublicKey,
-    amount: number | bigint,
-): TransactionInstruction;
-
+declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
 /**
- * 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.
+ * Create instruction for creating an associated compressed token account.
+ * Uses the default rent sponsor PDA by default.
  *
- * @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
+ * @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 createCTokenTransferInstruction(
-    source: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-): TransactionInstruction;
+declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): 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`.
+ * Create idempotent instruction for creating an associated compressed token account.
+ * Uses the default rent sponsor PDA by default.
  *
- * @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;
-};
+ * @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 createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+
 /**
- * Convert SplInterfaceInfo to TokenPoolInfo for backward compatibility.
- * @internal
+ * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
  */
-declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
+interface CTokenConfig {
+    compressibleConfig?: CompressibleConfig | null;
+    configAccount?: PublicKey;
+    rentPayerPda?: PublicKey;
+}
 /**
- * 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.
+ * 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.
  *
- * @returns SplInterfaceInfo for the to-be-initialized interface
+ * @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 deriveSplInterfaceInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): SplInterfaceInfo;
+declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
 /**
- * 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
+ * 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 checkSplInterfaceInfo(
-    splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
 /**
- * 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
+ * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
  */
-declare function getSplInterfaceInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<SplInterfaceInfo[]>;
-type SplInterfaceActivity = {
-    signature: string;
-    amount: BN;
-    action: Action;
-};
+declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
+
 /**
- * @internal
+ * Parameters for creating a MintTo instruction.
  */
-declare enum Action {
-    Compress = 1,
-    Decompress = 2,
-    Transfer = 3,
+interface CreateMintToInstructionParams {
+    /** Mint account (CMint - decompressed compressed mint) */
+    mint: PublicKey;
+    /** Destination CToken account to mint to */
+    destination: PublicKey;
+    /** Amount of tokens to mint */
+    amount: number | bigint;
+    /** Mint authority (must be signer) */
+    authority: PublicKey;
+    /** Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit) */
+    maxTopUp?: number;
+    /** Optional fee payer for rent top-ups. If not provided, authority pays. */
+    feePayer?: PublicKey;
 }
 /**
- * For `compress` and `mintTo` instructions only.
- * Select a random SPL interface info from the SPL interface infos.
- *
- * For `decompress`, use {@link selectSplInterfaceInfosForDecompression} instead.
+ * Create instruction for minting tokens to a CToken account.
  *
- * @param infos The SPL interface infos
+ * This is a simple 3-4 account instruction for minting to decompressed CToken accounts.
+ * Uses discriminator 7 (CTokenMintTo).
  *
- * @returns A random SPL interface info
+ * @param params - Mint instruction parameters
+ * @returns TransactionInstruction for minting tokens
  */
-declare function selectSplInterfaceInfo(
-    infos: SplInterfaceInfo[],
-): SplInterfaceInfo;
+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;
 /**
- * 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.
+ * 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>;
+/**
+ * Rent configuration constants for compressible ctoken accounts.
+ * These match the Rust SDK defaults in program-libs/compressible/src/rent/config.rs
  */
-declare function selectSplInterfaceInfosForDecompression(
-    infos: SplInterfaceInfo[],
-    decompressAmount: number | BN,
-): SplInterfaceInfo[];
+/** 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;
 /**
- * @deprecated Use {@link SplInterfaceActivity} instead.
+ * Compressible ctoken account size in bytes.
+ * = 165 (base SPL token) + 1 (account_type) + 1 (Option) + 4 (Vec len) + 1 (ext disc) + 4 (ext header) + 96 (CompressionInfo) = 272
+ * Source: program-libs/token-interface/src/state/token/top_up.rs MIN_SIZE_WITH_COMPRESSIBLE
  */
-type TokenPoolActivity = SplInterfaceActivity;
+declare const COMPRESSIBLE_CTOKEN_ACCOUNT_SIZE = 272;
 /**
- * @deprecated Use {@link deriveSplInterfaceInfo} instead.
+ * Calculate rent per epoch for a given account size.
+ * Formula: base_rent + (bytes * lamports_per_byte_per_epoch)
  */
-declare function deriveTokenPoolInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): TokenPoolInfo;
+declare function rentPerEpoch(bytes: number): number;
 /**
- * @deprecated Use {@link checkSplInterfaceInfo} instead.
+ * Default rent per epoch for a compressible ctoken account (272 bytes).
+ * = 128 + 272 = 400 lamports
  */
-declare function checkTokenPoolInfo(
-    tokenPoolInfo: TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare const COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH: number;
+/** Default prepaid epochs (24 hours = 16 epochs * 1.5h) */
+declare const DEFAULT_PREPAY_EPOCHS = 16;
+/** Default write top-up (lamports) - ~2 epochs rent */
+declare const DEFAULT_WRITE_TOP_UP = 766;
 /**
- * @deprecated Use {@link getSplInterfaceInfos} instead.
+ * Calculate fee payer cost at ATA creation.
+ * = compression_cost (11K) + (prepay_epochs * rent_per_epoch)
  */
-declare function getTokenPoolInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<TokenPoolInfo[]>;
+declare function calculateFeePayerCostAtCreation(prepayEpochs?: number, accountBytes?: number): number;
+
 /**
- * @deprecated Use {@link selectSplInterfaceInfo} instead.
+ * 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 selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+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;
+
 /**
- * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
+ * Create mint-to instruction for SPL, Token-2022, or CToken mints.
+ * This instruction ONLY mints to decompressed/onchain token accounts.
+ *
+ * For CToken mints, the mint must be decompressed first (CMint account must exist on-chain).
+ *
+ * @param mintInterface   Mint interface (SPL, Token-2022, or CToken).
+ * @param destination     Destination onchain token account address.
+ * @param authority       Mint authority public key.
+ * @param payer           Fee payer public key.
+ * @param amount          Amount to mint.
+ * @param validityProof   Not used (legacy parameter, kept for compatibility).
+ * @param multiSigners    Multi-signature signer public keys (SPL/T22 only).
+ */
+declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
+
+/**
+ * Create a Light token transfer instruction.
+ *
+ * For c-token accounts with compressible extension, the program needs
+ * system_program and fee_payer to handle rent top-ups.
+ *
+ * @param source        Source c-token account
+ * @param destination   Destination c-token account
+ * @param owner         Owner of the source account (signer, also pays for compressible extension top-ups)
+ * @param amount        Amount to transfer
+ * @param feePayer      Optional fee payer for top-ups (defaults to owner)
+ * @returns Transaction instruction for Light token transfer
  */
-declare function selectTokenPoolInfosForDecompression(
-    infos: TokenPoolInfo[],
-    decompressAmount: number | BN,
-): TokenPoolInfo[];
+declare function createLightTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
 
 /**
  * Create decompressInterface instruction using Transfer2.
@@ -1962,23 +1825,7 @@ declare function selectTokenPoolInfosForDecompression(
  * @param decimals                     Mint decimals (required for SPL destinations)
  * @returns TransactionInstruction
  */
-declare function createDecompressInterfaceInstruction(
-    payer: PublicKey,
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    toAddress: PublicKey,
-    amount: bigint,
-    validityProof: ValidityProofWithContext,
-    splInterfaceInfo: SplInterfaceInfo | undefined,
-    decimals: number,
-): TransactionInstruction;
-
-/**
- * Options for interface operations (load, transfer)
- */
-interface InterfaceOptions {
-    /** SPL interface infos (fetched if not provided) */
-    splInterfaceInfos?: SplInterfaceInfo[];
-}
+declare function createDecompressInterfaceInstruction(payer: PublicKey, inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: bigint, validityProof: ValidityProofWithContext, splInterfaceInfo: SplInterfaceInfo | undefined, decimals: number): TransactionInstruction;
 
 /**
  * Account info interface for compressible accounts.
@@ -2070,7 +1917,7 @@ interface LoadResult {
  * ```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 vault0Info = await getAtaInterface(rpc, vault0Ata, poolAddress, token0Mint, undefined, LIGHT_TOKEN_PROGRAM_ID);
  * const userAta = getAssociatedTokenAddressInterface(tokenMint, userWallet);
  * const userAtaInfo = await getAtaInterface(rpc, userAta, userWallet, tokenMint);
  *
@@ -2099,21 +1946,11 @@ interface LoadResult {
  * }
  * ```
  */
-declare function createLoadAccountsParams(
-    rpc: Rpc,
-    payer: PublicKey,
-    programId: PublicKey,
-    programAccounts?: CompressibleAccountInput[],
-    atas?: AccountInterface[],
-    options?: InterfaceOptions,
-): Promise<LoadResult>;
+declare function createLoadAccountsParams(rpc: Rpc, payer: PublicKey, programId: PublicKey, programAccounts?: CompressibleAccountInput[], atas?: AccountInterface[], options?: InterfaceOptions): Promise<LoadResult>;
 /**
  * Calculate compute units for compressible load operation
  */
-declare function calculateCompressibleLoadComputeUnits(
-    compressedAccountCount: number,
-    hasValidityProof: boolean,
-): number;
+declare function calculateCompressibleLoadComputeUnits(compressedAccountCount: number, hasValidityProof: boolean): number;
 
 /**
  * Create a wrap instruction that moves tokens from an SPL/T22 account to a
@@ -2129,16 +1966,7 @@ declare function calculateCompressibleLoadComputeUnits(
  * @param payer             Fee payer (defaults to owner)
  * @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): TransactionInstruction;
 
 /**
  * Create an unwrap instruction that moves tokens from a c-token account to an
@@ -2154,16 +1982,7 @@ declare function createWrapInstruction(
  * @param payer            Fee payer (defaults to owner if not provided)
  * @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): TransactionInstruction;
 
 /**
  * Create and initialize a new mint for SPL/T22/c-token.
@@ -2175,32 +1994,21 @@ declare function createUnwrapInstruction(
  * @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 programId             Token program ID (defaults to LIGHT_TOKEN_PROGRAM_ID)
  * @param tokenMetadata         Optional token metadata (c-token mints only)
  * @param outputStateTreeInfo   Optional output state tree info (c-token mints only)
  * @param addressTreeInfo       Optional address tree info (c-token mints only)
  *
  * @returns Object with mint address and transaction signature
  */
-declare function createMintInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mintAuthority: PublicKey | Signer,
-    freezeAuthority: PublicKey | Signer | null,
-    decimals: number,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    programId?: PublicKey,
-    tokenMetadata?: TokenMetadataInstructionData,
-    outputStateTreeInfo?: TreeInfo,
-    addressTreeInfo?: AddressTreeInfo,
-): Promise<{
+declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: PublicKey | Signer, freezeAuthority: PublicKey | Signer | null, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, programId?: PublicKey, tokenMetadata?: TokenMetadataInstructionData, outputStateTreeInfo?: TreeInfo, addressTreeInfo?: AddressTreeInfo): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
 
 /**
  * Update the mint authority of a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc                    RPC connection
  * @param payer                  Fee payer (signer)
@@ -2209,16 +2017,10 @@ declare function createMintInterface(
  * @param newMintAuthority       New mint authority (or null to revoke)
  * @param confirmOptions         Optional confirm options
  */
-declare function updateMintAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentMintAuthority: Signer,
-    newMintAuthority: PublicKey | null,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentMintAuthority: Signer, newMintAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Update the freeze authority of a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc                      RPC connection
  * @param payer                    Fee payer (signer)
@@ -2227,17 +2029,11 @@ declare function updateMintAuthority(
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param confirmOptions           Optional confirm options
  */
-declare function updateFreezeAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentFreezeAuthority: Signer,
-    newFreezeAuthority: PublicKey | null,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentFreezeAuthority: Signer, newFreezeAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Update a metadata field on a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -2249,19 +2045,10 @@ declare function updateFreezeAuthority(
  * @param extensionIndex Extension index (default: 0)
  * @param confirmOptions Optional confirm options
  */
-declare function updateMetadataField(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    authority: Signer,
-    fieldType: 'name' | 'symbol' | 'uri' | 'custom',
-    value: string,
-    customKey?: string,
-    extensionIndex?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Update the metadata authority of a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc              RPC connection
  * @param payer            Fee payer (signer)
@@ -2271,17 +2058,10 @@ declare function updateMetadataField(
  * @param extensionIndex   Extension index (default: 0)
  * @param confirmOptions   Optional confirm options
  */
-declare function updateMetadataAuthority(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    currentAuthority: Signer,
-    newAuthority: PublicKey,
-    extensionIndex?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentAuthority: Signer, newAuthority: PublicKey, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Remove a metadata key from a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -2292,16 +2072,7 @@ declare function updateMetadataAuthority(
  * @param extensionIndex Extension index (default: 0)
  * @param confirmOptions Optional confirm options
  */
-declare function removeMetadataKey(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    authority: Signer,
-    key: string,
-    idempotent?: boolean,
-    extensionIndex?: number,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, key: string, idempotent?: boolean, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create an associated token account for SPL/T22/c-token. Defaults to c-token
@@ -2314,23 +2085,13 @@ declare function removeMetadataKey(
  * @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)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  ATA program ID (auto-derived if not
  *                                  provided)
  * @param ctokenConfig              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, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
 /**
  * Create an associated token account idempotently for SPL/T22/c-token. Defaults
  * to c-token program.
@@ -2344,35 +2105,32 @@ declare function createAtaInterface(
  * @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)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  ATA program ID (auto-derived if not
  *                                  provided)
  * @param ctokenConfig              Optional c-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 mintTo$1(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    recipientAccount: PublicKey,
-    authority: Signer,
-    amount: number | bigint,
-    outputQueue?: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function createAtaInterfaceIdempotent(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+
+/**
+ * Mint tokens to a CToken account.
+ *
+ * This is a simple mint instruction for minting to decompressed CToken accounts.
+ * The mint must be decompressed (CMint account must exist on-chain).
+ *
+ * @param rpc - RPC connection
+ * @param payer - Fee payer (signer)
+ * @param mint - Mint address (CMint account)
+ * @param destination - Destination CToken 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.
@@ -2386,50 +2144,33 @@ declare function mintTo$1(
  * @param tokenAccountVersion   Token account version (default: 3)
  * @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>;
+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>;
 
 /**
  * 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 CToken mints.
  *
  * This function ONLY mints to decompressed onchain token accounts, never to compressed accounts.
+ * For CToken mints, the mint must be decompressed first (CMint account must exist on-chain).
+ *
  * 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 CToken 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>;
+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.
@@ -2447,17 +2188,7 @@ declare function mintToInterface(
  * @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>;
+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.
@@ -2491,42 +2222,7 @@ declare function decompressInterface(
  *
  * @returns Transaction signature
  */
-declare function wrap(
-    rpc: Rpc,
-    payer: Signer,
-    source: PublicKey,
-    destination: PublicKey,
-    owner: Signer,
-    mint: PublicKey,
-    amount: bigint,
-    splInterfaceInfo?: SplInterfaceInfo,
-    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>;
+declare function wrap(rpc: Rpc, payer: Signer, source: PublicKey, destination: PublicKey, owner: Signer, mint: PublicKey, amount: bigint, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create instructions to load an ATA from its AccountInterface.
@@ -2544,14 +2240,7 @@ declare function unwrap(
  * @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 createLoadAtaInstructionsFromInterface(rpc: Rpc, payer: PublicKey, ata: AccountInterface, options?: InterfaceOptions, wrap?: boolean, targetAta?: PublicKey): Promise<TransactionInstruction[]>;
 
 /**
  * Input for creating off-chain metadata JSON.
@@ -2609,17 +2298,12 @@ interface OffChainTokenMetadataJson {
  * // Then use uri with createMint
  * await createMint(rpc, payer, { ...params, uri });
  */
-declare function toOffChainMetadataJson(
-    meta: OffChainTokenMetadata,
-): OffChainTokenMetadataJson;
+declare function toOffChainMetadataJson(meta: OffChainTokenMetadata): OffChainTokenMetadataJson;
 
 /**
  * Returns the compressed mint address as bytes.
  */
-declare function deriveCMintAddress(
-    mintSeed: PublicKey,
-    addressTreeInfo: TreeInfo,
-): number[];
+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.
@@ -2627,14 +2311,8 @@ declare const COMPRESSED_MINT_SEED: Buffer$1;
  * @returns [PDA, bump]
  */
 declare function findMintAddress(mintSigner: PublicKey): [PublicKey, number];
-declare function getAssociatedCTokenAddressAndBump(
-    owner: PublicKey,
-    mint: PublicKey,
-): [PublicKey, number];
-declare function getAssociatedCTokenAddress(
-    owner: PublicKey,
-    mint: PublicKey,
-): PublicKey;
+declare function getAssociatedCTokenAddressAndBump(owner: PublicKey, mint: PublicKey): [PublicKey, number];
+declare function getAssociatedCTokenAddress(owner: PublicKey, mint: PublicKey): PublicKey;
 
 /**
  * Approve a delegate to spend tokens
@@ -2649,15 +2327,7 @@ declare function getAssociatedCTokenAddress(
  *
  * @return Signature of the confirmed transaction
  */
-declare function approve(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    delegate: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function approve(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, delegate: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens to a solana address from an external mint authority
@@ -2676,17 +2346,7 @@ declare function approve(
  *
  * @return Signature of the confirmed transaction
  */
-declare function approveAndMintTo(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    toPubkey: PublicKey,
-    authority: Signer,
-    amount: number | BN,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Compress SPL tokens
@@ -2706,18 +2366,7 @@ declare function approveAndMintTo(
  *
  * @return Signature of the confirmed transaction
  */
-declare function compress(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN | number[] | BN[],
-    owner: Signer,
-    sourceTokenAccount: PublicKey,
-    toAddress: PublicKey | Array<PublicKey>,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN | number[] | BN[], owner: Signer, sourceTokenAccount: PublicKey, toAddress: PublicKey | Array<PublicKey>, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Compress SPL tokens into compressed token format
@@ -2737,17 +2386,7 @@ declare function compress(
  *
  * @return Signature of the confirmed transaction
  */
-declare function compressSplTokenAccount(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    owner: Signer,
-    tokenAccount: PublicKey,
-    remainingAmount?: BN,
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, tokenAccount: PublicKey, remainingAmount?: BN, outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Create and initialize a new SPL token mint
@@ -2767,16 +2406,7 @@ declare function compressSplTokenAccount(
  *
  * @return Object with mint address and transaction signature
  */
-declare function createMint(
-    rpc: Rpc,
-    payer: Signer,
-    mintAuthority: PublicKey | Signer,
-    decimals: number,
-    keypair?: Keypair,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey | boolean,
-    freezeAuthority?: PublicKey | Signer | null,
-): Promise<{
+declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey | Signer, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey | boolean, freezeAuthority?: PublicKey | Signer | null): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
@@ -2793,13 +2423,7 @@ declare function createMint(
  *
  * @return transaction signature
  */
-declare function createSplInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey,
-): Promise<TransactionSignature>;
+declare function createSplInterface(rpc: Rpc, payer: Signer, mint: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
 /**
  * @deprecated Use {@link createSplInterface} instead.
  */
@@ -2818,14 +2442,7 @@ declare const createTokenPool: typeof createSplInterface;
  *
  * @return transaction signature
  */
-declare function addSplInterfaces(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    numMaxAdditionalPools: number,
-    confirmOptions?: ConfirmOptions,
-    tokenProgramId?: PublicKey,
-): Promise<string>;
+declare function addSplInterfaces(rpc: Rpc, payer: Signer, mint: PublicKey, numMaxAdditionalPools: number, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<string>;
 /**
  * @deprecated Use {@link addSplInterfaces} instead.
  */
@@ -2845,13 +2462,7 @@ declare const addTokenPools: typeof addSplInterfaces;
  * @return Object with transaction signatures and the address of the created
  *         lookup table
  */
-declare function createTokenProgramLookupTable(
-    rpc: Rpc,
-    payer: Signer,
-    authority: Signer,
-    mints?: PublicKey[],
-    additionalAccounts?: PublicKey[],
-): Promise<{
+declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
     txIds: TransactionSignature[];
     address: PublicKey;
 }>;
@@ -2871,16 +2482,7 @@ declare function createTokenProgramLookupTable(
  *
  * @return confirmed transaction signature
  */
-declare function decompress(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    splInterfaceInfos?: SplInterfaceInfo[],
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, splInterfaceInfos?: SplInterfaceInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Merge multiple compressed token accounts for a given mint into fewer
@@ -2900,13 +2502,7 @@ declare function decompress(
  *
  * @return confirmed transaction signature
  */
-declare function mergeTokenAccounts(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    owner: Signer,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens to a solana address
@@ -2928,17 +2524,7 @@ declare function mergeTokenAccounts(
  *
  * @return Signature of the confirmed transaction
  */
-declare function mintTo(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    toPubkey: PublicKey | PublicKey[],
-    authority: Signer,
-    amount: number | BN | number[] | BN[],
-    outputStateTreeInfo?: TreeInfo,
-    splInterfaceInfo?: SplInterfaceInfo,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey | PublicKey[], authority: Signer, amount: number | BN | number[] | BN[], outputStateTreeInfo?: TreeInfo, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Revoke one or more delegated token accounts
@@ -2952,13 +2538,7 @@ declare function mintTo(
  *
  * @return Signature of the confirmed transaction
  */
-declare function revoke(
-    rpc: Rpc,
-    payer: Signer,
-    accounts: ParsedTokenAccount[],
-    owner: Signer,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[], owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer compressed tokens from one owner to another.
@@ -2976,15 +2556,7 @@ declare function revoke(
  *
  * @return confirmed transaction signature
  */
-declare function transfer(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer delegated compressed tokens to another owner
@@ -2999,15 +2571,7 @@ declare function transfer(
  *
  * @return confirmed transaction signature
  */
-declare function transferDelegated(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Decompress delegated compressed tokens. Remaining compressed tokens are
@@ -3025,21 +2589,10 @@ declare function transferDelegated(
  *
  * @return Signature of the confirmed transaction
  */
-declare function decompressDelegated(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    toAddress: PublicKey,
-    splInterfaceInfos?: SplInterfaceInfo[],
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
-
-declare const ERROR_NO_ACCOUNTS_FOUND =
-    'Could not find accounts to select for transfer.';
-declare const ERROR_MIXED_TREE_TYPES =
-    'Cannot select accounts from different tree types (V1/V2) in the same batch. Filter accounts by tree type first.';
+declare function decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, splInterfaceInfos?: SplInterfaceInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
+declare const ERROR_MIXED_TREE_TYPES = "Cannot select accounts from different tree types (V1/V2) in the same batch. Filter accounts by tree type first.";
 /**
  * Options for input account selection
  */
@@ -3054,9 +2607,7 @@ interface SelectInputAccountsOptions {
 /**
  * Groups accounts by tree type for separate processing
  */
-declare function groupAccountsByTreeType(
-    accounts: ParsedTokenAccount[],
-): Map<TreeType, ParsedTokenAccount[]>;
+declare function groupAccountsByTreeType(accounts: ParsedTokenAccount[]): Map<TreeType, ParsedTokenAccount[]>;
 /**
  * Result of selectAccountsByPreferredTreeType
  */
@@ -3081,10 +2632,7 @@ interface SelectedAccountsResult {
  * @param requiredAmount Minimum amount needed (optional - if not provided, returns all from preferred type)
  * @returns Selected accounts from a single tree type
  */
-declare function selectAccountsByPreferredTreeType(
-    accounts: ParsedTokenAccount[],
-    requiredAmount?: BN,
-): SelectedAccountsResult;
+declare function selectAccountsByPreferredTreeType(accounts: ParsedTokenAccount[], requiredAmount?: BN): SelectedAccountsResult;
 /**
  * Selects token accounts for approval, first trying to find an exact match, then falling back to minimum selection.
  *
@@ -3103,16 +2651,11 @@ declare function selectAccountsByPreferredTreeType(
  *   - totalLamports: Total lamports from selected accounts.
  *   - maxPossibleAmount: Max approvable amount given maxInputs.
  */
-declare function selectTokenAccountsForApprove(
-    accounts: ParsedTokenAccount[],
-    approveAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Selects the minimum number of compressed token accounts required for a
@@ -3126,12 +2669,7 @@ declare function selectTokenAccountsForApprove(
  *
  * @returns Returns selected accounts and their totals.
  */
-declare function selectMinCompressedTokenAccountsForDecompression(
-    accounts: ParsedTokenAccount[],
-    amount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): {
+declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): {
     selectedAccounts: ParsedTokenAccount[];
     total: BN;
     totalLamports: BN | null;
@@ -3155,31 +2693,22 @@ declare function selectMinCompressedTokenAccountsForDecompression(
  *   maxPossibleAmount: BN
  * ]
  */
-declare function selectMinCompressedTokenAccountsForTransfer(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
  * returns partial amounts if insufficient accounts are found instead of
  * throwing an error.
  */
-declare function selectMinCompressedTokenAccountsForTransferOrPartial(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-): [
+declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Selects compressed token accounts for a transfer, ensuring one extra account
@@ -3222,31 +2751,22 @@ declare function selectMinCompressedTokenAccountsForTransferOrPartial(
  * console.log(totalLamports!.toString()); // '15'
  * console.log(maxPossibleAmount.toString()); // '150'
  */
-declare function selectSmartCompressedTokenAccountsForTransfer(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-    options?: SelectInputAccountsOptions,
-): [
+declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number, options?: SelectInputAccountsOptions): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 /**
  * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
  * returns partial amounts if insufficient accounts are found instead of
  * throwing an error.
  */
-declare function selectSmartCompressedTokenAccountsForTransferOrPartial(
-    accounts: ParsedTokenAccount[],
-    transferAmount: BN,
-    maxInputs?: number,
-): [
+declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
     totalLamports: BN | null,
-    maxPossibleAmount: BN,
+    maxPossibleAmount: BN
 ];
 
 type TokenTransferOutputData = {
@@ -3319,9 +2839,7 @@ type CompressSplTokenAccountInstructionData = {
     remainingAmount: BN | null;
     cpiContext: CompressedCpiContext | null;
 };
-declare function isSingleSplInterfaceInfo(
-    splInterfaceInfos: SplInterfaceInfo | SplInterfaceInfo[],
-): splInterfaceInfos is SplInterfaceInfo;
+declare function isSingleSplInterfaceInfo(splInterfaceInfos: SplInterfaceInfo | SplInterfaceInfo[]): splInterfaceInfos is SplInterfaceInfo;
 /**
  * @deprecated Use {@link isSingleSplInterfaceInfo} instead.
  */
@@ -3432,9 +2950,7 @@ type PackCompressedTokenAccountsParams = {
 /**
  * Packs Compressed Token Accounts.
  */
-declare function packCompressedTokenAccounts(
-    params: PackCompressedTokenAccountsParams,
-): {
+declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
     inputTokenDataWithContext: InputTokenDataWithContext$1[];
     remainingAccountMetas: AccountMeta[];
     packedOutputTokenData: PackedTokenTransferOutputData[];
@@ -3447,10 +2963,7 @@ declare function packCompressedTokenAccounts(
  * @param mint                      The mint of the token pool
  * @returns True if all input accounts belong to the same mint
  */
-declare function checkMint(
-    compressedTokenAccounts: ParsedTokenAccount[],
-    mint: PublicKey,
-): boolean;
+declare function checkMint(compressedTokenAccounts: ParsedTokenAccount[], mint: PublicKey): boolean;
 
 type LightCompressedToken = {
     version: '1.2.0';
@@ -3462,7 +2975,7 @@ type LightCompressedToken = {
                 'This instruction creates a token pool for a given mint. Every spl mint',
                 'can have one token pool. When a token is compressed the tokens are',
                 'transferrred to the token pool, and their compressed equivalent is',
-                'minted into a Merkle tree.',
+                'minted into a Merkle tree.'
             ];
             accounts: [
                 {
@@ -3495,7 +3008,7 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [];
         },
@@ -3503,7 +3016,7 @@ type LightCompressedToken = {
             name: 'addTokenPool';
             docs: [
                 'This instruction creates an additional token pool for a given mint.',
-                'The maximum number of token pools per mint is 5.',
+                'The maximum number of token pools per mint is 5.'
             ];
             accounts: [
                 {
@@ -3541,13 +3054,13 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'tokenPoolIndex';
                     type: 'u8';
-                },
+                }
             ];
         },
         {
@@ -3559,7 +3072,7 @@ type LightCompressedToken = {
                 'every amount and pubkey input pair. A constant amount of lamports can be',
                 'transferred to each output account to enable. A use case to add lamports',
                 'to a compressed token account is to prevent spam. This is the only way',
-                'to add lamports to a compressed token account.',
+                'to add lamports to a compressed token account.'
             ];
             accounts: [
                 {
@@ -3639,7 +3152,7 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                },
+                }
             ];
             args: [
                 {
@@ -3659,7 +3172,7 @@ type LightCompressedToken = {
                     type: {
                         option: 'u64';
                     };
-                },
+                }
             ];
         },
         {
@@ -3667,7 +3180,7 @@ type LightCompressedToken = {
             docs: [
                 'Compresses the balance of an spl token account sub an optional remaining',
                 'amount. This instruction does not close the spl token account. To close',
-                'the account bundle a close spl account instruction in your transaction.',
+                'the account bundle a close spl account instruction in your transaction.'
             ];
             accounts: [
                 {
@@ -3683,7 +3196,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -3744,7 +3257,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -3764,7 +3277,7 @@ type LightCompressedToken = {
                             defined: 'CompressedCpiContext';
                         };
                     };
-                },
+                }
             ];
         },
         {
@@ -3777,7 +3290,7 @@ type LightCompressedToken = {
                 'accounts specify less lamports than inputs the remaining lamports are',
                 'transferred to an output compressed account. Signer must be owner or',
                 'delegate. If a delegated token account is transferred the delegate is',
-                'not preserved.',
+                'not preserved.'
             ];
             accounts: [
                 {
@@ -3793,7 +3306,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -3854,13 +3367,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -3871,7 +3384,7 @@ type LightCompressedToken = {
                 'be called by a delegate.',
                 'The instruction creates two output accounts:',
                 '1. one account with delegated amount',
-                '2. one account with remaining(change) amount',
+                '2. one account with remaining(change) amount'
             ];
             accounts: [
                 {
@@ -3887,7 +3400,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -3930,20 +3443,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'revoke';
             docs: [
                 'Revokes a delegation. The instruction merges all inputs into one output',
-                'account. Cannot be called by a delegate. Delegates are not preserved.',
+                'account. Cannot be called by a delegate. Delegates are not preserved.'
             ];
             accounts: [
                 {
@@ -3959,7 +3472,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4002,20 +3515,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'freeze';
             docs: [
                 'Freezes compressed token accounts. Inputs must not be frozen. Creates as',
-                'many outputs as inputs. Balances and delegates are preserved.',
+                'many outputs as inputs. Balances and delegates are preserved.'
             ];
             accounts: [
                 {
@@ -4074,20 +3587,20 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
             name: 'thaw';
             docs: [
                 'Thaws frozen compressed token accounts. Inputs must be frozen. Creates',
-                'as many outputs as inputs. Balances and delegates are preserved.',
+                'as many outputs as inputs. Balances and delegates are preserved.'
             ];
             accounts: [
                 {
@@ -4146,13 +3659,13 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4160,7 +3673,7 @@ type LightCompressedToken = {
             docs: [
                 'Burns compressed tokens and spl tokens from the pool account. Delegates',
                 'can burn tokens. The output compressed token account remains delegated.',
-                'Creates one output compressed token account.',
+                'Creates one output compressed token account.'
             ];
             accounts: [
                 {
@@ -4176,7 +3689,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4233,13 +3746,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4247,7 +3760,7 @@ type LightCompressedToken = {
             docs: [
                 'This function is a stub to allow Anchor to include the input types in',
                 'the IDL. It should not be included in production builds nor be called in',
-                'practice.',
+                'practice.'
             ];
             accounts: [
                 {
@@ -4263,7 +3776,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
+                        'validity proof.'
                     ];
                 },
                 {
@@ -4324,7 +3837,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -4338,9 +3851,9 @@ type LightCompressedToken = {
                     type: {
                         defined: 'TokenData';
                     };
-                },
+                }
             ];
-        },
+        }
     ];
     types: [
         {
@@ -4353,7 +3866,7 @@ type LightCompressedToken = {
                     },
                     {
                         name: 'Frozen';
-                    },
+                    }
                 ];
             };
         },
@@ -4385,7 +3898,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedAccountData';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4409,7 +3922,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4422,7 +3935,7 @@ type LightCompressedToken = {
                         name: 'setContext';
                         docs: [
                             'Is set by the program that is invoking the CPI to signal that is should',
-                            'set the cpi context.',
+                            'set the cpi context.'
                         ];
                         type: 'bool';
                     },
@@ -4430,17 +3943,17 @@ type LightCompressedToken = {
                         name: 'firstSetContext';
                         docs: [
                             'Is set to wipe the cpi context since someone could have set it before',
-                            'with unrelated data.',
+                            'with unrelated data.'
                         ];
                         type: 'bool';
                     },
                     {
                         name: 'cpiContextAccountIndex';
                         docs: [
-                            'Index of cpi context account in remaining accounts.',
+                            'Index of cpi context account in remaining accounts.'
                         ];
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4466,7 +3979,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4492,7 +4005,7 @@ type LightCompressedToken = {
                         docs: [
                             'Is required if the signer is delegate,',
                             '-> delegate is authority account,',
-                            'owner = Some(owner) is the owner of the token account.',
+                            'owner = Some(owner) is the owner of the token account.'
                         ];
                         type: {
                             option: {
@@ -4539,7 +4052,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'u8';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4579,7 +4092,7 @@ type LightCompressedToken = {
                     {
                         name: 'outputAccountMerkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4637,14 +4150,14 @@ type LightCompressedToken = {
                         type: {
                             option: 'u64';
                         };
-                    },
+                    }
                 ];
             };
         },
         {
             name: 'DelegatedTransfer';
             docs: [
-                'Struct to provide the owner when the delegate is signer of the transaction.',
+                'Struct to provide the owner when the delegate is signer of the transaction.'
             ];
             type: {
                 kind: 'struct';
@@ -4659,12 +4172,12 @@ type LightCompressedToken = {
                             'Index of change compressed account in output compressed accounts. In',
                             "case that the delegate didn't spend the complete delegated compressed",
                             'account balance the change compressed account will be delegated to her',
-                            'as well.',
+                            'as well.'
                         ];
                         type: {
                             option: 'u8';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4702,12 +4215,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4763,7 +4276,7 @@ type LightCompressedToken = {
                     {
                         name: 'isCompress';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4827,7 +4340,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4843,7 +4356,7 @@ type LightCompressedToken = {
                     {
                         name: 'seq';
                         type: 'u64';
-                    },
+                    }
                 ];
             };
         },
@@ -4869,7 +4382,7 @@ type LightCompressedToken = {
                     {
                         name: 'addressMerkleTreeRootIndex';
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -4887,7 +4400,7 @@ type LightCompressedToken = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4911,17 +4424,17 @@ type LightCompressedToken = {
                     {
                         name: 'rootIndex';
                         docs: [
-                            'Index of root used in inclusion validity proof.',
+                            'Index of root used in inclusion validity proof.'
                         ];
                         type: 'u16';
                     },
                     {
                         name: 'readOnly';
                         docs: [
-                            'Placeholder to mark accounts read-only unimplemented set to false.',
+                            'Placeholder to mark accounts read-only unimplemented set to false.'
                         ];
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4945,7 +4458,7 @@ type LightCompressedToken = {
                     {
                         name: 'proveByIndex';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4975,12 +4488,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5054,7 +4567,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5072,7 +4585,7 @@ type LightCompressedToken = {
                         name: 'index';
                         docs: ['Index of compressed account hash in queue.'];
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -5100,7 +4613,7 @@ type LightCompressedToken = {
                         name: 'delegate';
                         docs: [
                             'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
+                            'the amount authorized by the delegate'
                         ];
                         type: {
                             option: 'publicKey';
@@ -5116,15 +4629,15 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
-        },
+        }
     ];
     errors: [
         {
@@ -5281,7 +4794,7 @@ type LightCompressedToken = {
         {
             code: 6032;
             name: 'NoMatchingBumpFound';
-        },
+        }
     ];
 };
 declare const IDL: LightCompressedToken;
@@ -5292,30 +4805,14 @@ declare const CompressedTokenInstructionDataTransferLayout: Layout<unknown>;
 declare const mintToLayout: Layout<unknown>;
 declare const batchCompressLayout: Layout<unknown>;
 declare const compressSplTokenAccountInstructionDataLayout: Layout<unknown>;
-declare function encodeMintToInstructionData(
-    data: MintToInstructionData,
-): Buffer$1;
-declare function decodeMintToInstructionData(
-    buffer: Buffer$1,
-): MintToInstructionData;
-declare function encodeBatchCompressInstructionData(
-    data: BatchCompressInstructionData,
-): Buffer$1;
-declare function decodeBatchCompressInstructionData(
-    buffer: Buffer$1,
-): BatchCompressInstructionData;
-declare function encodeCompressSplTokenAccountInstructionData(
-    data: CompressSplTokenAccountInstructionData,
-): Buffer$1;
-declare function decodeCompressSplTokenAccountInstructionData(
-    buffer: Buffer$1,
-): CompressSplTokenAccountInstructionData;
-declare function encodeTransferInstructionData(
-    data: CompressedTokenInstructionDataTransfer,
-): Buffer$1;
-declare function decodeTransferInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataTransfer;
+declare function encodeMintToInstructionData(data: MintToInstructionData): Buffer$1;
+declare function decodeMintToInstructionData(buffer: Buffer$1): MintToInstructionData;
+declare function encodeBatchCompressInstructionData(data: BatchCompressInstructionData): Buffer$1;
+declare function decodeBatchCompressInstructionData(buffer: Buffer$1): BatchCompressInstructionData;
+declare function encodeCompressSplTokenAccountInstructionData(data: CompressSplTokenAccountInstructionData): Buffer$1;
+declare function decodeCompressSplTokenAccountInstructionData(buffer: Buffer$1): CompressSplTokenAccountInstructionData;
+declare function encodeTransferInstructionData(data: CompressedTokenInstructionDataTransfer): Buffer$1;
+declare function decodeTransferInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataTransfer;
 interface BaseAccountsLayoutParams {
     feePayer: PublicKey;
     authority: PublicKey;
@@ -5357,44 +4854,20 @@ type freezeAccountsLayoutParams = BaseAccountsLayoutParams & {
     mint: PublicKey;
 };
 type thawAccountsLayoutParams = freezeAccountsLayoutParams;
-declare const createTokenPoolAccountsLayout: (
-    accounts: createTokenPoolAccountsLayoutParams,
-) => AccountMeta[];
-declare const addTokenPoolAccountsLayout: (
-    accounts: addTokenPoolAccountsLayoutParams,
-) => AccountMeta[];
-declare const mintToAccountsLayout: (
-    accounts: mintToAccountsLayoutParams,
-) => AccountMeta[];
-declare const transferAccountsLayout: (
-    accounts: transferAccountsLayoutParams,
-) => AccountMeta[];
-declare const approveAccountsLayout: (
-    accounts: approveAccountsLayoutParams,
-) => AccountMeta[];
-declare const revokeAccountsLayout: (
-    accounts: approveAccountsLayoutParams,
-) => AccountMeta[];
-declare const freezeAccountsLayout: (
-    accounts: freezeAccountsLayoutParams,
-) => AccountMeta[];
-declare const thawAccountsLayout: (
-    accounts: freezeAccountsLayoutParams,
-) => AccountMeta[];
+declare const createTokenPoolAccountsLayout: (accounts: createTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const addTokenPoolAccountsLayout: (accounts: addTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const mintToAccountsLayout: (accounts: mintToAccountsLayoutParams) => AccountMeta[];
+declare const transferAccountsLayout: (accounts: transferAccountsLayoutParams) => AccountMeta[];
+declare const approveAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const revokeAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const freezeAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
+declare const thawAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
 declare const CompressedTokenInstructionDataApproveLayout: Layout<unknown>;
 declare const CompressedTokenInstructionDataRevokeLayout: Layout<unknown>;
-declare function encodeApproveInstructionData(
-    data: CompressedTokenInstructionDataApprove,
-): Buffer$1;
-declare function decodeApproveInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataApprove;
-declare function encodeRevokeInstructionData(
-    data: CompressedTokenInstructionDataRevoke,
-): Buffer$1;
-declare function decodeRevokeInstructionData(
-    buffer: Buffer$1,
-): CompressedTokenInstructionDataRevoke;
+declare function encodeApproveInstructionData(data: CompressedTokenInstructionDataApprove): Buffer$1;
+declare function decodeApproveInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataApprove;
+declare function encodeRevokeInstructionData(data: CompressedTokenInstructionDataRevoke): Buffer$1;
+declare function decodeRevokeInstructionData(buffer: Buffer$1): CompressedTokenInstructionDataRevoke;
 
 type CompressParams = {
     /**
@@ -5488,11 +4961,7 @@ type DecompressParams = {
     /**
      * Token pool(s)
      */
-    tokenPoolInfos:
-        | TokenPoolInfo
-        | TokenPoolInfo[]
-        | SplInterfaceInfo
-        | SplInterfaceInfo[];
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[] | SplInterfaceInfo | SplInterfaceInfo[];
 };
 type TransferParams = {
     /**
@@ -5777,17 +5246,12 @@ declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
 /**
  * Parse compressed token accounts to get the mint, current owner and delegate.
  */
-declare const parseTokenData: (
-    compressedTokenAccounts: ParsedTokenAccount[],
-) => {
+declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
     mint: PublicKey;
     currentOwner: PublicKey;
     delegate: PublicKey | null;
 };
-declare const parseMaybeDelegatedTransfer: (
-    inputs: ParsedTokenAccount[],
-    outputs: TokenTransferOutputData[],
-) => {
+declare const parseMaybeDelegatedTransfer: (inputs: ParsedTokenAccount[], outputs: TokenTransferOutputData[]) => {
     delegatedTransfer: DelegatedTransfer | null;
     authority: PublicKey;
 };
@@ -5799,11 +5263,7 @@ declare const parseMaybeDelegatedTransfer: (
  * @returns                             Output token data for the transfer
  *                                      instruction
  */
-declare function createTransferOutputState(
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    toAddress: PublicKey,
-    amount: number | BN,
-): TokenTransferOutputData[];
+declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData[];
 /**
  * Create the output state for a compress transaction.
  * @param inputCompressedTokenAccounts  Input state
@@ -5811,10 +5271,7 @@ declare function createTransferOutputState(
  * @returns                             Output token data for the compress
  *                                      instruction
  */
-declare function createDecompressOutputState(
-    inputCompressedTokenAccounts: ParsedTokenAccount[],
-    amount: number | BN,
-): TokenTransferOutputData[];
+declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData[];
 declare class CompressedTokenProgram {
     /**
      * @internal
@@ -5852,17 +5309,11 @@ declare class CompressedTokenProgram {
      *
      * @returns The index and bump number.
      */
-    static findSplInterfaceIndexAndBump(
-        poolPda: PublicKey,
-        mint: PublicKey,
-    ): [number, number];
+    static findSplInterfaceIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
     /**
      * @deprecated Use {@link findSplInterfaceIndexAndBump} instead.
      */
-    static findTokenPoolIndexAndBump(
-        poolPda: PublicKey,
-        mint: PublicKey,
-    ): [number, number];
+    static findTokenPoolIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
     /**
      * Derive the SPL interface PDA with index.
      *
@@ -5872,17 +5323,11 @@ declare class CompressedTokenProgram {
      *
      * @returns The SPL interface PDA and bump.
      */
-    static deriveSplInterfacePdaWithIndex(
-        mint: PublicKey,
-        index: number,
-    ): [PublicKey, number];
+    static deriveSplInterfacePdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /**
      * @deprecated Use {@link deriveSplInterfacePdaWithIndex} instead.
      */
-    static deriveTokenPoolPdaWithIndex(
-        mint: PublicKey,
-        index: number,
-    ): [PublicKey, number];
+    static deriveTokenPoolPdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
     /**
@@ -5898,23 +5343,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.
+    static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
+    /**
+     * Create SPL interface (omnibus account) for an existing SPL mint.
      * For new mints, use `CompressedTokenProgram.createMint`.
      *
      * @param feePayer              Fee payer.
@@ -5922,16 +5358,16 @@ declare class CompressedTokenProgram {
      * @param tokenProgramId        Optional: Token program ID. Default: SPL
      *                              Token Program ID
      *
-     * @returns The createTokenPool instruction
+     * @returns The createSplInterface instruction
+     */
+    static createSplInterface({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    /**
+     * @deprecated Use {@link createSplInterface} instead.
      */
-    static createTokenPool({
-        feePayer,
-        mint,
-        tokenProgramId,
-    }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    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.
@@ -5941,12 +5377,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The addTokenPool instruction
      */
-    static addTokenPool({
-        feePayer,
-        mint,
-        poolIndex,
-        tokenProgramId,
-    }: AddSplInterfaceParams): Promise<TransactionInstruction>;
+    static addTokenPool({ feePayer, mint, poolIndex, tokenProgramId, }: AddSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Construct mintTo instruction for compressed tokens
      *
@@ -5960,15 +5391,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The mintTo instruction
      */
-    static mintTo({
-        feePayer,
-        mint,
-        authority,
-        toPubkey,
-        amount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: MintToParams): Promise<TransactionInstruction>;
+    static mintTo({ feePayer, mint, authority, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: MintToParams): Promise<TransactionInstruction>;
     /**
      * Mint tokens from registered SPL mint account to a compressed account
      *
@@ -5984,16 +5407,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The mintTo instruction
      */
-    static approveAndMintTo({
-        feePayer,
-        mint,
-        authority,
-        authorityTokenAccount,
-        toPubkey,
-        amount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    static approveAndMintTo({ feePayer, mint, authority, authorityTokenAccount, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
     /**
      * Construct transfer instruction for compressed tokens.
      *
@@ -6008,14 +5422,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The transfer instruction
      */
-    static transfer({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: TransferParams): Promise<TransactionInstruction>;
+    static transfer({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: TransferParams): Promise<TransactionInstruction>;
     /**
      * Create lookup table instructions for the token program's default
      * accounts.
@@ -6028,13 +5435,7 @@ declare class CompressedTokenProgram {
      *
      * @returns [createInstruction, extendInstruction, option(extendInstruction2)]
      */
-    static createTokenProgramLookupTable({
-        payer,
-        authority,
-        mints,
-        recentSlot,
-        remainingAccounts,
-    }: CreateTokenProgramLookupTableParams): Promise<{
+    static createTokenProgramLookupTable({ payer, authority, mints, recentSlot, remainingAccounts, }: CreateTokenProgramLookupTableParams): Promise<{
         instructions: TransactionInstruction[];
         address: PublicKey;
     }>;
@@ -6052,16 +5453,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The compress instruction
      */
-    static compress({
-        payer,
-        owner,
-        source,
-        toAddress,
-        amount,
-        mint,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: CompressParams): Promise<TransactionInstruction>;
+    static compress({ payer, owner, source, toAddress, amount, mint, outputStateTreeInfo, tokenPoolInfo, }: CompressParams): Promise<TransactionInstruction>;
     /**
      * Construct decompress instruction
      *
@@ -6076,15 +5468,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The decompress instruction
      */
-    static decompress({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-        tokenPoolInfos,
-    }: DecompressParams): Promise<TransactionInstruction>;
+    static decompress({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, tokenPoolInfos, }: DecompressParams): Promise<TransactionInstruction>;
     /**
      * Create `mergeTokenAccounts` instruction.
      *
@@ -6097,14 +5481,7 @@ declare class CompressedTokenProgram {
      * @param recentInputStateRootIndices   Recent state root indices.
      * @returns instruction
      */
-    static mergeTokenAccounts({
-        payer,
-        owner,
-        inputCompressedTokenAccounts,
-        mint,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
+    static mergeTokenAccounts({ payer, owner, inputCompressedTokenAccounts, mint, recentValidityProof, recentInputStateRootIndices, }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
     /**
      * Create `compressSplTokenAccount` instruction
      *
@@ -6118,15 +5495,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static compressSplTokenAccount({
-        feePayer,
-        authority,
-        tokenAccount,
-        mint,
-        remainingAmount,
-        outputStateTreeInfo,
-        tokenPoolInfo,
-    }: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
+    static compressSplTokenAccount({ feePayer, authority, tokenAccount, mint, remainingAmount, outputStateTreeInfo, tokenPoolInfo, }: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
     /**
      * Get the program ID for a mint
      *
@@ -6135,10 +5504,7 @@ declare class CompressedTokenProgram {
      *
      * @returns program ID
      */
-    static getMintProgramId(
-        mint: PublicKey,
-        connection: Connection,
-    ): Promise<PublicKey | undefined>;
+    static getMintProgramId(mint: PublicKey, connection: Connection): Promise<PublicKey | undefined>;
     /**
      * Create `approve` instruction to delegate compressed tokens.
      *
@@ -6151,14 +5517,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static approve({
-        payer,
-        inputCompressedTokenAccounts,
-        toAddress,
-        amount,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: ApproveParams): Promise<TransactionInstruction>;
+    static approve({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: ApproveParams): Promise<TransactionInstruction>;
     /**
      * Create `revoke` instruction to revoke delegation of compressed tokens.
      *
@@ -6169,14 +5528,16 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static revoke({
-        payer,
-        inputCompressedTokenAccounts,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: RevokeParams): Promise<TransactionInstruction>;
+    static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
+/**
+ * Exports for @lightprotocol/compressed-token/unified
+ *
+ * Import from `/unified` to get a single unified ATA for SPL/T22 and c-token
+ * mints.
+ */
+
 /**
  * Get associated token account with unified balance
  *
@@ -6188,18 +5549,11 @@ declare class CompressedTokenProgram {
  * @param programId   Optional program ID (omit for unified behavior)
  * @returns AccountInterface with aggregated balance from all sources
  */
-declare function getAtaInterface(
-    rpc: Rpc,
-    ata: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<AccountInterface>;
+declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
  * Derive the canonical token ATA for SPL/T22/c-token in the unified path.
  *
- * Enforces CTOKEN_PROGRAM_ID.
+ * Enforces LIGHT_TOKEN_PROGRAM_ID.
  *
  * @param mint                      Mint public key
  * @param owner                     Owner public key
@@ -6209,15 +5563,9 @@ declare function getAtaInterface(
  *                                  auto-detected.
  * @returns                         Associated token address.
  */
-declare function getAssociatedTokenAddressInterface(
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve?: boolean,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-): PublicKey;
+declare function getAssociatedTokenAddressInterface(mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, programId?: PublicKey, associatedTokenProgramId?: PublicKey): PublicKey;
 /**
- * Create instructions to load ALL token balances into a c-token ATA.
+ * Create instruction batches for loading ALL token balances into a c-token ATA.
  *
  * @param rpc     RPC connection
  * @param ata     Associated token address
@@ -6225,16 +5573,9 @@ declare function getAssociatedTokenAddressInterface(
  * @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.
  *
@@ -6251,19 +5592,11 @@ declare function createLoadAtaInstructions(
  * @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): Promise<string | null>;
 /**
  * Transfer tokens using the unified ata interface.
  *
- * Matches SPL Token's transferChecked signature order. Destination must exist.
+ * Destination ATA must exist. Automatically wraps SPL/T22 to c-token ATA.
  *
  * @param rpc             RPC connection
  * @param payer           Fee payer (signer)
@@ -6272,27 +5605,15 @@ declare function loadAta(
  * @param destination     Destination c-token ATA address (must exist)
  * @param owner           Source owner (signer)
  * @param amount          Amount to transfer
- * @param programId       Token program ID (default: CTOKEN_PROGRAM_ID)
  * @param confirmOptions  Optional confirm options
  * @param options         Optional interface options
  * @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, destination: PublicKey, owner: Signer, amount: number | bigint | BN, confirmOptions?: ConfirmOptions, options?: InterfaceOptions): Promise<string>;
 /**
  * Get or create c-token ATA with unified balance detection and auto-loading.
  *
- * Enforces CTOKEN_PROGRAM_ID. Aggregates balances from:
+ * Enforces LIGHT_TOKEN_PROGRAM_ID. Aggregates balances from:
  * - c-token hot (on-chain) account
  * - c-token cold (compressed) accounts
  * - SPL token accounts (for unified wrapping)
@@ -6317,232 +5638,54 @@ declare function transferInterface(
  * @param confirmOptions  Optional confirm options
  * @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>;
-
-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,
-};
+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 c-token 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[][]>;
+/**
+ * Build instruction batches for unwrapping c-tokens to SPL/T22.
+ *
+ * Unified variant: uses wrap=true for loading, so SPL/T22 balances are
+ * consolidated before unwrapping.
+ *
+ * Returns `TransactionInstruction[][]`. Load batches (if any) come first,
+ * followed by one final unwrap transaction.
+ *
+ * @param rpc               RPC connection
+ * @param destination       Destination SPL/T22 token account (must exist)
+ * @param owner             Owner of the c-token
+ * @param mint              Mint address
+ * @param amount            Amount to unwrap (defaults to full balance)
+ * @param payer             Fee payer (defaults to owner)
+ * @param splInterfaceInfo  Optional: SPL interface info
+ * @param 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 c-tokens to SPL tokens.
+ *
+ * Unified variant: loads all cold + SPL/T22 balances to c-token ATA first,
+ * then unwraps to the destination SPL/T22 account.
+ *
+ * @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 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): Promise<string>;
+
+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_CTOKEN_ACCOUNT_SIZE, COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH, COMPRESSION_COST, COMPRESSION_INCENTIVE, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CTokenConfig, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleAccountInput, type CompressibleConfig, type CompressibleLoadParams, CpiContextLayout, type CreateAssociatedCTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR, DEFAULT_COMPRESSIBLE_CONFIG, DEFAULT_PREPAY_EPOCHS, DEFAULT_WRITE_TOP_UP, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_MIXED_TREE_TYPES, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR, type LightCompressedToken, 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, 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, addSplInterfaces, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, calculateCompressibleLoadComputeUnits, calculateFeePayerCostAtCreation, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createAssociatedCTokenAccountIdempotentInstruction, createAssociatedCTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createDecompressInterfaceInstruction, createDecompressOutputState, createLightTokenTransferInstruction, createLoadAccountsParams, createLoadAtaInstructions, createLoadAtaInstructionsFromInterface, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstructions, createTransferOutputState, createUnwrapInstruction, createUnwrapInstructions, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, decompressInterface, 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, rentPerEpoch, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, 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, unpackMintData, unpackMintInterface, unwrap, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };