@lightprotocol/compressed-token 0.23.0-beta.5 → 0.23.0-beta.7

package/dist/types/index.d.ts

@@ -589,16 +589,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).
@@ -607,9 +609,9 @@ declare function createUpdateMintAuthorityInstruction(mintInterface: MintInterfa
  * @param currentFreezeAuthority   Current freeze authority public key (must sign)
  * @param newFreezeAuthority       New freeze authority (or null to revoke)
  * @param payer                    Fee payer public key
- * @param validityProof            Validity proof for the compressed mint
+ * @param validityProof            Validity proof for the compressed 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.
@@ -620,13 +622,13 @@ declare function createUpdateFreezeAuthorityInstruction(mintInterface: MintInter
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the 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.
  *
@@ -637,10 +639,10 @@ declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterfa
  * @param currentAuthority Current metadata update authority public key (must sign)
  * @param newAuthority     New metadata update authority public key
  * @param payer            Fee payer public key
- * @param validityProof    Validity proof for the compressed mint
+ * @param validityProof    Validity proof for the 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.
  *
@@ -650,12 +652,12 @@ declare function createUpdateMetadataAuthorityInstruction(mintInterface: MintInt
  * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
  * @param authority      Metadata update authority public key (must sign)
  * @param payer          Fee payer public key
- * @param validityProof  Validity proof for the compressed mint
+ * @param validityProof  Validity proof for the 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;
@@ -670,8 +672,7 @@ interface CompressibleConfig {
     compressToAccountPubkey?: CompressToPubkey | null;
 }
 interface CreateAssociatedCTokenAccountParams {
-    bump: number;
-    compressibleConfig?: CompressibleConfig;
+    compressibleConfig?: CompressibleConfig | null;
 }
 /**
  * Default compressible config for c-token ATAs - matches Rust SDK defaults.
@@ -716,7 +717,7 @@ declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
  * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
  * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 /**
  * Create idempotent instruction for creating an associated compressed token account.
  * Uses the default rent sponsor PDA by default.
@@ -728,13 +729,13 @@ declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, o
  * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
  * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig | null, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 
 /**
  * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
  */
 interface CTokenConfig {
-    compressibleConfig?: CompressibleConfig;
+    compressibleConfig?: CompressibleConfig | null;
     configAccount?: PublicKey;
     rentPayerPda?: PublicKey;
 }
@@ -772,18 +773,32 @@ declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(paye
 declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
 
 /**
- * Create instruction for minting compressed tokens to an onchain token account.
+ * Parameters for creating a MintTo instruction.
+ */
+interface CreateMintToInstructionParams {
+    /** Mint account (CMint - decompressed compressed mint) */
+    mint: PublicKey;
+    /** Destination CToken account to mint to */
+    destination: PublicKey;
+    /** Amount of tokens to mint */
+    amount: number | bigint;
+    /** Mint authority (must be signer) */
+    authority: PublicKey;
+    /** Maximum lamports for rent and top-up combined. Transaction fails if exceeded. (0 = no limit) */
+    maxTopUp?: number;
+    /** Optional fee payer for rent top-ups. If not provided, authority pays. */
+    feePayer?: PublicKey;
+}
+/**
+ * Create instruction for minting tokens to a CToken account.
  *
- * @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.
+ * This is a simple 3-4 account instruction for minting to decompressed CToken accounts.
+ * Uses discriminator 7 (CTokenMintTo).
+ *
+ * @param params - Mint instruction parameters
+ * @returns TransactionInstruction for minting tokens
  */
-declare function createMintToInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, outputStateTreeInfo: TreeInfo, recipientAccount: PublicKey, amount: number | bigint): TransactionInstruction;
+declare function createMintToInstruction(params: CreateMintToInstructionParams): TransactionInstruction;
 
 /** Default compressible config PDA (V1) */
 declare const LIGHT_TOKEN_CONFIG: PublicKey;
@@ -877,21 +892,23 @@ declare function createMintToCompressedInstruction(authority: PublicKey, payer:
 }>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion): TransactionInstruction;
 
 /**
- * Create mint-to instruction for SPL, Token-2022, or compressed token mints.
+ * Create mint-to instruction for SPL, Token-2022, or CToken mints.
  * This instruction ONLY mints to decompressed/onchain token accounts.
  *
- * @param mintInterface   Mint interface (SPL, Token-2022, or compressed).
+ * 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   Validity proof (required for compressed mints).
- * @param multiSigners    Multi-signature signer public keys.
+ * @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 c-token transfer instruction.
+ * 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.
@@ -901,20 +918,9 @@ declare function createMintToInterfaceInstruction(mintInterface: MintInterface,
  * @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 c-token transfer
- */
-declare function createCTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: 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`.
- *
- * @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
+ * @returns Transaction instruction for Light token transfer
  */
-declare function createTransferInterfaceInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, multiSigners?: (Signer | PublicKey)[], programId?: PublicKey): TransactionInstruction;
+declare function createLightTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, feePayer?: PublicKey): TransactionInstruction;
 
 declare namespace BN {
     type Endianness = "le" | "be";
@@ -1792,22 +1798,95 @@ interface InterfaceOptions {
 /**
  * Transfer tokens using the c-token interface.
  *
- * Matches SPL Token's transferChecked signature order. Destination must exist.
+ * High-level action: resolves balances, builds all instructions (load +
+ * transfer), signs, and sends. Creates the recipient ATA if it does not exist.
+ *
+ * For instruction-level control, use `createTransferInterfaceInstructions`.
  *
  * @param rpc             RPC connection
  * @param payer           Fee payer (signer)
  * @param source          Source c-token ATA address
  * @param mint            Mint address
- * @param destination     Destination c-token ATA address (must exist)
+ * @param destination     Recipient wallet public key
  * @param owner           Source owner (signer)
  * @param amount          Amount to transfer
- * @param programId       Token program ID (default: CTOKEN_PROGRAM_ID)
+ * @param programId       Token program ID (default: LIGHT_TOKEN_PROGRAM_ID)
  * @param confirmOptions  Optional confirm options
  * @param options         Optional interface options
  * @param wrap            Include SPL/T22 wrapping (default: false)
- * @returns Transaction signature
+ * @returns Transaction signature of the transfer transaction
  */
 declare function transferInterface(rpc: Rpc, payer: Signer, source: PublicKey, mint: PublicKey, destination: PublicKey, owner: Signer, amount: number | bigint | BN, programId?: PublicKey, confirmOptions?: ConfirmOptions, options?: InterfaceOptions, wrap?: boolean): Promise<TransactionSignature>;
+/**
+ * Options for createTransferInterfaceInstructions.
+ */
+interface TransferOptions extends InterfaceOptions {
+    /** Include SPL/T22 wrapping to c-token ATA (unified path). Default: false. */
+    wrap?: boolean;
+    /** Token program ID. Default: LIGHT_TOKEN_PROGRAM_ID. */
+    programId?: PublicKey;
+    /**
+     * Include an idempotent recipient ATA creation instruction in the
+     * transfer transaction. No extra RPC fetch -- uses
+     * createAssociatedTokenAccountInterfaceIdempotentInstruction which is
+     * a no-op on-chain if the ATA already exists (~200 CU overhead).
+     * Default: true.
+     */
+    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;
+};
+/**
+ * Create instructions for a c-token transfer.
+ *
+ * Returns `TransactionInstruction[][]` -- an array of transaction instruction
+ * arrays. Each inner array is one transaction to sign and send.
+ *
+ * - All transactions except the last can be sent in parallel (load/decompress).
+ * - The last transaction is the transfer and must be sent after all others
+ *   confirm.
+ * - For a hot sender or <=8 cold inputs, the result is a single-element array.
+ *
+ * Use `sliceLast` to separate the parallel prefix from the final transfer:
+ * ```
+ * const batches = await createTransferInterfaceInstructions(...);
+ * const { rest, last } = sliceLast(batches);
+ * ```
+ *
+ * When `ensureRecipientAta` is true (the default), an idempotent ATA creation
+ * instruction is included in the transfer (last) transaction. No extra RPC
+ * fetch -- the instruction is a no-op on-chain if the ATA already exists.
+ * Set `ensureRecipientAta: false` if you manage recipient ATAs yourself.
+ *
+ * All transactions require payer + sender as signers.
+ *
+ * Hash uniqueness guarantee: all compressed accounts for the sender are
+ * fetched once, then partitioned into non-overlapping chunks by tree version.
+ * Each hash appears in exactly one batch. This is enforced at runtime by
+ * `assertUniqueInputHashes` inside `_buildLoadBatches`.
+ *
+ * @param rpc       RPC connection
+ * @param payer     Fee payer public key
+ * @param mint      Mint address
+ * @param amount    Amount to transfer
+ * @param sender    Sender public key (must sign all transactions)
+ * @param recipient Recipient public key
+ * @param options   Optional configuration
+ * @returns TransactionInstruction[][] -- send [0..n-2] in parallel, then [n-1]
+ */
+declare function createTransferInterfaceInstructions(rpc: Rpc, payer: PublicKey, mint: PublicKey, amount: number | bigint | BN, sender: PublicKey, recipient: PublicKey, options?: TransferOptions): Promise<TransactionInstruction[][]>;
 
 /**
  * Account info interface for compressible accounts.
@@ -1899,7 +1978,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);
  *
@@ -1950,6 +2029,22 @@ declare function calculateCompressibleLoadComputeUnits(compressedAccountCount: n
  */
 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
+ * SPL/T22 account.
+ *
+ * @param source           Source c-token account
+ * @param destination      Destination SPL/T22 token account
+ * @param owner            Owner of the source account (signer)
+ * @param mint             Mint address
+ * @param amount           Amount to unwrap,
+ * @param splInterfaceInfo SPL interface info for the decompression
+ * @param decimals         Mint decimals (required for transfer_checked)
+ * @param payer            Fee payer (defaults to owner if not provided)
+ * @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;
+
 /**
  * Create and initialize a new mint for SPL/T22/c-token.
  *
@@ -1960,7 +2055,7 @@ declare function createWrapInstruction(source: PublicKey, destination: PublicKey
  * @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)
@@ -1974,6 +2069,7 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
 
 /**
  * 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)
@@ -1985,6 +2081,7 @@ declare function createMintInterface(rpc: Rpc, payer: Signer, mintAuthority: Pub
 declare function updateMintAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentMintAuthority: Signer, newMintAuthority: PublicKey | null, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Update the freeze authority of a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc                      RPC connection
  * @param payer                    Fee payer (signer)
@@ -1997,6 +2094,7 @@ declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey,
 
 /**
  * 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)
@@ -2011,6 +2109,7 @@ declare function updateFreezeAuthority(rpc: Rpc, payer: Signer, mint: PublicKey,
 declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Update the metadata authority of a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc              RPC connection
  * @param payer            Fee payer (signer)
@@ -2023,6 +2122,7 @@ declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, a
 declare function updateMetadataAuthority(rpc: Rpc, payer: Signer, mint: PublicKey, currentAuthority: Signer, newAuthority: PublicKey, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Remove a metadata key from a compressed token mint.
+ * Works for both compressed and decompressed mints.
  *
  * @param rpc            RPC connection
  * @param payer          Fee payer (signer)
@@ -2046,7 +2146,7 @@ declare function removeMetadataKey(rpc: Rpc, payer: Signer, mint: PublicKey, aut
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  ATA program ID (auto-derived if not
  *                                  provided)
  * @param ctokenConfig              Optional rent config
@@ -2066,7 +2166,7 @@ declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, ow
  * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (default:
- *                                  CTOKEN_PROGRAM_ID)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  ATA program ID (auto-derived if not
  *                                  provided)
  * @param ctokenConfig              Optional c-token-specific configuration
@@ -2075,7 +2175,23 @@ declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, ow
  */
 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>;
+/**
+ * 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.
@@ -2096,20 +2212,22 @@ declare function mintToCompressed(rpc: Rpc, payer: Signer, mint: PublicKey, auth
 
 /**
  * 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
  */
@@ -2132,7 +2250,7 @@ declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, desti
  *                                  state.
  * @param confirmOptions            Options for confirming the transaction
  * @param programId                 Token program ID (defaults to
- *                                  CTOKEN_PROGRAM_ID)
+ *                                  LIGHT_TOKEN_PROGRAM_ID)
  * @param associatedTokenProgramId  Associated token program ID (auto-derived if
  *                                  not provided)
  *
@@ -2192,6 +2310,48 @@ declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, min
  */
 declare function wrap(rpc: Rpc, payer: Signer, source: PublicKey, destination: PublicKey, owner: Signer, mint: PublicKey, amount: bigint, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
+/**
+ * Build instruction batches for unwrapping c-tokens to SPL/T22 tokens.
+ *
+ * Returns `TransactionInstruction[][]` with the same shape as
+ * `createLoadAtaInstructions` and `createTransferInterfaceInstructions`:
+ * each inner array is one transaction. Load batches (if any) come first,
+ * followed by one final unwrap transaction.
+ *
+ * Uses amount-aware input selection: only loads the cold inputs needed to
+ * cover the unwrap amount (plus padding to fill a single proof batch).
+ *
+ * @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
+ * @param wrap              Whether to use unified (wrap) mode for loading.
+ *                          Default false.
+ * @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, wrap?: boolean): Promise<TransactionInstruction[][]>;
+
+/**
+ * Select compressed inputs for a target amount.
+ *
+ * Sorts by amount descending (largest first), accumulates until the target
+ * is met, then pads to {@link MAX_INPUT_ACCOUNTS} if possible within a
+ * single batch.
+ *
+ * - If the amount is covered by N <= 8 inputs, returns min(8, total) inputs.
+ * - If more than 8 inputs are needed, returns exactly as many as required
+ *   (no padding beyond the amount-needed count).
+ * - Returns [] when `neededAmount <= 0` or `accounts` is empty.
+ *
+ * @param accounts      Cold compressed token accounts available for loading.
+ * @param neededAmount  Amount that must be covered by selected inputs.
+ * @returns Subset of `accounts`, sorted largest-first.
+ */
+declare function selectInputsForAmount(accounts: ParsedTokenAccount[], neededAmount: bigint): ParsedTokenAccount[];
 /**
  * Create instructions to load an ATA from its AccountInterface.
  *
@@ -5312,14 +5472,14 @@ declare class CompressedTokenProgram {
      * @param mintSize              Optional: mint size. Default: MINT_SIZE
      *
      * @returns [createMintAccountInstruction, initializeMintInstruction,
-     * createTokenPoolInstruction]
+     * createSplInterfaceInstruction]
      *
-     * Note that `createTokenPoolInstruction` must be executed after
+     * Note that `createSplInterfaceInstruction` must be executed after
      * `initializeMintInstruction`.
      */
     static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * Create SPL interface (omnibus account) for an existing SPL mint.
      * For new mints, use `CompressedTokenProgram.createMint`.
      *
      * @param feePayer              Fee payer.
@@ -5327,12 +5487,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.
@@ -5496,6 +5660,36 @@ declare class CompressedTokenProgram {
     static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
+/** Solana maximum transaction size in bytes. */
+declare const MAX_TRANSACTION_SIZE = 1232;
+/**
+ * Conservative size budget for a combined batch (load + transfer + ATA).
+ * Leaves headroom below MAX_TRANSACTION_SIZE for edge-case key counts.
+ */
+declare const MAX_COMBINED_BATCH_BYTES = 900;
+/**
+ * Conservative size budget for a load-only or setup-only batch.
+ */
+declare const MAX_LOAD_ONLY_BATCH_BYTES = 1000;
+/**
+ * Estimate the serialized byte size of a V0 VersionedTransaction built from
+ * the given instructions and signer count.
+ *
+ * The estimate accounts for Solana's account-key deduplication: all unique
+ * pubkeys across every instruction (keys + programIds) are collected into a
+ * single set, matching the behaviour of
+ * `TransactionMessage.compileToV0Message`.
+ *
+ * This intentionally does NOT use address lookup tables, so the result is an
+ * upper bound. If lookup tables are used at send time the actual size will be
+ * smaller.
+ *
+ * @param instructions  The instructions that will be included in the tx.
+ * @param numSigners    Number of signers (determines signature count).
+ * @returns Estimated byte size of the serialized transaction.
+ */
+declare function estimateTransactionSize(instructions: TransactionInstruction[], numSigners: number): number;
+
 /**
  * Retrieve associated token account for a given owner and mint.
  *
@@ -5509,17 +5703,18 @@ declare class CompressedTokenProgram {
  */
 declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
- * Create instructions to load token balances into a c-token ATA.
+ * Create instruction batches for loading token balances into an ATA.
+ * Returns batches of instructions, each batch is one transaction.
  *
- * @param rpc     RPC connection
- * @param ata     Associated token address
- * @param owner   Owner public key
- * @param mint    Mint public key
- * @param payer   Fee payer (defaults to owner)
- * @param options Optional load options
- * @returns       Array of instructions (empty if nothing to load)
+ * @param rpc               RPC connection
+ * @param ata               Associated token address
+ * @param owner             Owner public key
+ * @param mint              Mint public key
+ * @param payer             Fee payer (defaults to owner)
+ * @param options           Optional load options
+ * @returns Instruction batches - each inner array is one transaction
  */
-declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, payer?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[]>;
+declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, payer?: PublicKey, options?: InterfaceOptions): Promise<TransactionInstruction[][]>;
 /**
  * Load token balances into a c-token ATA.
  *
@@ -5534,4 +5729,4 @@ declare function createLoadAtaInstructions(rpc: Rpc, ata: PublicKey, owner: Publ
  */
 declare function loadAta(rpc: Rpc, ata: PublicKey, owner: Signer, mint: PublicKey, payer?: Signer, confirmOptions?: ConfirmOptions, interfaceOptions?: InterfaceOptions): Promise<TransactionSignature | null>;
 
-export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BASE_RENT_PER_EPOCH, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESSIBLE_CTOKEN_ACCOUNT_SIZE, COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH, COMPRESSION_COST, COMPRESSION_INCENTIVE, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CTokenConfig, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleAccountInput, type CompressibleConfig, type CompressibleLoadParams, CpiContextLayout, type CreateAssociatedCTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR, DEFAULT_COMPRESSIBLE_CONFIG, DEFAULT_PREPAY_EPOCHS, DEFAULT_WRITE_TOP_UP, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_MIXED_TREE_TYPES, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR, type LightCompressedToken, 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 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, createCTokenTransferInstruction, createDecompressInterfaceInstruction, createDecompressOutputState, createLoadAccountsParams, createLoadAtaInstructions, createLoadAtaInstructionsFromInterface, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstruction, createTransferOutputState, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, decompressInterface, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, extractTokenMetadata, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedTokenAddressInterface, getAtaInterface, getMintInterface, getOrCreateAtaInterface, getSplInterfaceInfos, getTokenPoolInfos, 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, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, toAccountInfo, toOffChainMetadataJson, toTokenPoolInfo, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, transferInterface, unpackMintData, unpackMintInterface, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };
+export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, type AccountInterface, Action, type AddSplInterfaceParams, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BASE_RENT_PER_EPOCH, BATCH_COMPRESS_DISCRIMINATOR, type BaseMint, type BatchCompressInstructionData, COMPRESSIBLE_CTOKEN_ACCOUNT_SIZE, COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH, COMPRESSION_COST, COMPRESSION_INCENTIVE, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CTokenConfig, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedMint, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, type CompressibleAccountInput, type CompressibleConfig, type CompressibleLoadParams, CpiContextLayout, type CreateAssociatedCTokenAccountParams, type CreateMintParams, type CreateSplInterfaceParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR, DEFAULT_COMPRESSIBLE_CONFIG, DEFAULT_PREPAY_EPOCHS, DEFAULT_WRITE_TOP_UP, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_MIXED_TREE_TYPES, ERROR_NO_ACCOUNTS_FOUND, ExtensionType, IDL, type InputTokenDataWithContext, type InterfaceOptions, LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR, type LightCompressedToken, CompressedTokenProgram as LightTokenProgram, type LoadResult, MAX_COMBINED_BATCH_BYTES, MAX_LOAD_ONLY_BATCH_BYTES, MAX_TRANSACTION_SIZE, MINT_TO_DISCRIMINATOR, type MergeTokenAccountsParams, type MintContext, type MintExtension, type MintInterface, type MintToInstructionData, type MintToParams, type OffChainTokenMetadata, type OffChainTokenMetadataJson, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedCompressedAccount, type PackedTokenTransferOutputData, type ParsedAccountInfoInterface, RENT_PER_BYTE_PER_EPOCH, REVOKE_DISCRIMINATOR, type RevokeParams, SLOTS_PER_RENT_EPOCH, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type SelectInputAccountsOptions, type SelectedAccountsResult, type SplInterfaceActivity, type SplInterfaceInfo, TOTAL_COMPRESSION_COST, TRANSFER_DISCRIMINATOR, type TokenAccountSource, type TokenData, TokenDataVersion, type TokenMetadata, type TokenMetadataInstructionData, type TokenPoolActivity, type TokenPoolInfo, type TokenTransferOutputData, type TransferParams, addSplInterfaces, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, calculateCompressibleLoadComputeUnits, calculateFeePayerCostAtCreation, checkMint, checkSplInterfaceInfo, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, convertTokenDataToAccount, createAssociatedCTokenAccountIdempotentInstruction, createAssociatedCTokenAccountInstruction, createAssociatedTokenAccountInterfaceIdempotentInstruction, createAssociatedTokenAccountInterfaceInstruction, createAtaInterface, createAtaInterfaceIdempotent, createAtaInterfaceIdempotentInstruction, createDecompressInterfaceInstruction, createDecompressOutputState, createLightTokenTransferInstruction, createLoadAccountsParams, createLoadAtaInstructions, createLoadAtaInstructionsFromInterface, createMint, createMintInstruction, createMintInterface, createMintToCompressedInstruction, createMintToInstruction, createMintToInterfaceInstruction, createRemoveMetadataKeyInstruction, createSplInterface, createTokenMetadata, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferInterfaceInstructions, createTransferOutputState, createUnwrapInstruction, createUnwrapInstructions, createUpdateFreezeAuthorityInstruction, createUpdateMetadataAuthorityInstruction, createUpdateMetadataFieldInstruction, createUpdateMintAuthorityInstruction, createWrapInstruction, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTokenMetadata, decodeTransferInstructionData, decompress, decompressDelegated, decompressInterface, deriveSplInterfaceInfo, deriveTokenPoolInfo, deserializeMint, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTokenMetadata, encodeTransferInstructionData, estimateTransactionSize, extractTokenMetadata, freezeAccountsLayout, type freezeAccountsLayoutParams, getAccountInterface, getAssociatedTokenAddressInterface, getAtaInterface, getMintInterface, getOrCreateAtaInterface, getSplInterfaceInfos, getTokenPoolInfos, groupAccountsByTreeType, isSingleSplInterfaceInfo, isSingleTokenPoolInfo, loadAta, mergeTokenAccounts, mintTo, mintToAccountsLayout, type mintToAccountsLayoutParams, mintTo$1 as mintToCToken, mintToCompressed, mintToInterface, mintToLayout, packCompressedTokenAccounts, parseCTokenCold, parseCTokenHot, parseMaybeDelegatedTransfer, parseTokenData, removeMetadataKey, rentPerEpoch, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, selectAccountsByPreferredTreeType, selectInputsForAmount, selectMinCompressedTokenAccountsForDecompression, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, selectSplInterfaceInfo, selectSplInterfaceInfosForDecompression, selectTokenAccountsForApprove, selectTokenPoolInfo, selectTokenPoolInfosForDecompression, serializeMint, sliceLast, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, toAccountInfo, toOffChainMetadataJson, toTokenPoolInfo, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, transferInterface, unpackMintData, unpackMintInterface, updateFreezeAuthority, updateMetadataAuthority, updateMetadataField, updateMintAuthority, validateSameTokenOwner, wrap };