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

package/dist/types/index.d.ts

@@ -1,84 +1,23 @@
 /// <reference types="node" />
-import {
-    PublicKey,
-    TransactionInstruction,
-    Commitment,
-    AccountInfo,
-    Signer,
-    ConfirmOptions,
-    TransactionSignature,
-    AccountMeta,
-    Keypair,
-    Connection,
-} from '@solana/web3.js';
-import {
-    ValidityProofWithContext,
-    AddressTreeInfo,
-    TreeInfo,
-    MerkleContext,
-    Rpc,
-    ParsedTokenAccount,
-    CompressedAccountWithMerkleContext,
-    ValidityProof,
-    TreeType,
-    PackedMerkleContextLegacy,
-    CompressedCpiContext,
-    InputTokenDataWithContext as InputTokenDataWithContext$1,
-    CompressedProof,
-} from '@lightprotocol/stateless.js';
+import { PublicKey, TransactionInstruction, Commitment, AccountInfo, Signer, ConfirmOptions, TransactionSignature, AccountMeta, Keypair, Connection } from '@solana/web3.js';
+import { ValidityProofWithContext, AddressTreeInfo, TreeInfo, MerkleContext, Rpc, ParsedTokenAccount, CompressedAccountWithMerkleContext, ValidityProof, TreeType, PackedMerkleContextLegacy, CompressedCpiContext, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
 export { ParsedTokenAccount as ParsedTokenAccountInterface } from '@lightprotocol/stateless.js';
 import { Mint, Account } from '@solana/spl-token';
 export { Account, AccountState } from '@solana/spl-token';
 
 declare class Buffer$1 extends Uint8Array {
-    length: number;
-    write(
-        string: string,
-        offset?: number,
-        length?: number,
-        encoding?: string,
-    ): number;
+    length: number
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
     toString(encoding?: string, start?: number, end?: number): string;
-    toJSON(): { type: 'Buffer'; data: any[] };
+    toJSON(): { type: 'Buffer', data: any[] };
     equals(otherBuffer: Buffer$1): boolean;
-    compare(
-        otherBuffer: Uint8Array,
-        targetStart?: number,
-        targetEnd?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
-    copy(
-        targetBuffer: Buffer$1,
-        targetStart?: number,
-        sourceStart?: number,
-        sourceEnd?: number,
-    ): number;
+    compare(otherBuffer: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+    copy(targetBuffer: Buffer$1, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
     slice(start?: number, end?: number): Buffer$1;
-    writeUIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeUIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntLE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
-    writeIntBE(
-        value: number,
-        offset: number,
-        byteLength: number,
-        noAssert?: boolean,
-    ): number;
+    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
     readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
     readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
@@ -124,21 +63,9 @@ declare class Buffer$1 extends Uint8Array {
     writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
     writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
     fill(value: any, offset?: number, end?: number): this;
-    indexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    lastIndexOf(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): number;
-    includes(
-        value: string | number | Buffer$1,
-        byteOffset?: number,
-        encoding?: string,
-    ): boolean;
+    indexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): number;
+    includes(value: string | number | Buffer$1, byteOffset?: number, encoding?: string): boolean;
 
     /**
      * Allocates a new buffer containing the given {str}.
@@ -146,19 +73,19 @@ declare class Buffer$1 extends Uint8Array {
      * @param str String to store in buffer.
      * @param encoding encoding to use, optional.  Default is 'utf8'
      */
-    constructor(str: string, encoding?: string);
+    constructor (str: string, encoding?: string);
     /**
      * Allocates a new buffer of {size} octets.
      *
      * @param size count of octets to allocate.
      */
-    constructor(size: number);
+    constructor (size: number);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: Uint8Array);
+    constructor (array: Uint8Array);
     /**
      * Produces a Buffer backed by the same allocated memory as
      * the given {ArrayBuffer}.
@@ -166,19 +93,19 @@ declare class Buffer$1 extends Uint8Array {
      *
      * @param arrayBuffer The ArrayBuffer with which to share memory.
      */
-    constructor(arrayBuffer: ArrayBuffer);
+    constructor (arrayBuffer: ArrayBuffer);
     /**
      * Allocates a new buffer containing the given {array} of octets.
      *
      * @param array The octets to store.
      */
-    constructor(array: any[]);
+    constructor (array: any[]);
     /**
      * Copies the passed {buffer} data onto a new {Buffer} instance.
      *
      * @param buffer The buffer to copy.
      */
-    constructor(buffer: Buffer$1);
+    constructor (buffer: Buffer$1);
     prototype: Buffer$1;
     /**
      * Allocates a new Buffer using an {array} of octets.
@@ -196,11 +123,7 @@ declare class Buffer$1 extends Uint8Array {
      * @param byteOffset
      * @param length
      */
-    static from(
-        arrayBuffer: ArrayBuffer,
-        byteOffset?: number,
-        length?: number,
-    ): Buffer$1;
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer$1;
     /**
      * Copies the passed {buffer} data onto a new Buffer instance.
      *
@@ -260,11 +183,7 @@ declare class Buffer$1 extends Uint8Array {
      *    If parameter is omitted, buffer will be filled with zeros.
      * @param encoding encoding used for call to buf.fill while initializing
      */
-    static alloc(
-        size: number,
-        fill?: string | Buffer$1 | number,
-        encoding?: string,
-    ): Buffer$1;
+    static alloc(size: number, fill?: string | Buffer$1 | number, encoding?: string): Buffer$1;
     /**
      * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
      * of the newly created Buffer are unknown and may contain sensitive data.
@@ -429,13 +348,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.
  *
@@ -449,17 +362,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
@@ -593,7 +496,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
@@ -611,9 +514,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
@@ -664,12 +565,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.
  *
@@ -678,11 +574,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
  *
@@ -704,13 +596,7 @@ declare function unpackMintData(data: Buffer$1 | Uint8Array): {
  * @param payer                  Fee payer public key
  * @param validityProof          Validity proof for the compressed mint
  */
-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): TransactionInstruction;
 /**
  * Create instruction for updating a compressed mint's freeze authority.
  *
@@ -723,13 +609,7 @@ declare function createUpdateMintAuthorityInstruction(
  * @param payer                    Fee payer public key
  * @param validityProof            Validity proof for the compressed mint
  */
-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): TransactionInstruction;
 
 /**
  * Create instruction for updating a compressed mint's metadata field.
@@ -746,16 +626,7 @@ declare function createUpdateFreezeAuthorityInstruction(
  * @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, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number): TransactionInstruction;
 /**
  * Create instruction for updating a compressed mint's metadata authority.
  *
@@ -769,14 +640,7 @@ declare function createUpdateMetadataFieldInstruction(
  * @param validityProof    Validity proof for the compressed mint
  * @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, extensionIndex?: number): TransactionInstruction;
 /**
  * Create instruction for removing a metadata key from a compressed mint.
  *
@@ -791,15 +655,7 @@ declare function createUpdateMetadataAuthorityInstruction(
  * @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, key: string, idempotent?: boolean, extensionIndex?: number): TransactionInstruction;
 
 interface CompressToPubkey {
     bump: number;
@@ -809,7 +665,6 @@ interface CompressToPubkey {
 interface CompressibleConfig {
     tokenAccountVersion: number;
     rentPayment: number;
-    hasTopUp: number;
     compressionOnly: number;
     writeTopUp: number;
     compressToAccountPubkey?: CompressToPubkey | null;
@@ -818,42 +673,62 @@ interface CreateAssociatedCTokenAccountParams {
     bump: number;
     compressibleConfig?: CompressibleConfig;
 }
+/**
+ * Default compressible config for c-token ATAs - matches Rust SDK defaults.
+ *
+ * - tokenAccountVersion: 3 (ShaFlat) - latest hashing scheme
+ * - rentPayment: 16 - prepay 16 epochs (~24 hours rent)
+ * - compressionOnly: 1 - required for ATAs
+ * - writeTopUp: 766 - per-write top-up (~2 epochs rent) when rent < 2 epochs
+ * - compressToAccountPubkey: null - required for ATAs
+ *
+ * Cost breakdown at 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
+ *
+ * Per-write top-up (transfers):
+ * - When account rent is below 2 epochs, fee payer pays 766 lamports top-up
+ * - This keeps the account perpetually funded when actively used
+ *
+ * Rent calculation (272-byte compressible 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)
+ *
+ * Account size breakdown (272 bytes):
+ * - 165 bytes: SPL token base layout
+ * - 1 byte: account_type discriminator
+ * - 1 byte: Option discriminator for extensions
+ * - 4 bytes: Vec length prefix
+ * - 1 byte: extension type discriminant
+ * - 4 bytes: CompressibleExtension header (decimals_option, decimals, compression_only, is_ata)
+ * - 96 bytes: CompressionInfo struct
+ */
+declare const DEFAULT_COMPRESSIBLE_CONFIG: CompressibleConfig;
 /**
  * Create instruction for creating an associated compressed token account.
+ * Uses the default rent sponsor PDA by default.
  *
  * @param feePayer          Fee payer public key.
  * @param owner             Owner of the associated token account.
  * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
- */
-declare function createAssociatedCTokenAccountInstruction(
-    feePayer: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    compressibleConfig?: CompressibleConfig,
-    configAccount?: PublicKey,
-    rentPayerPda?: PublicKey,
-): TransactionInstruction;
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
+ */
+declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 /**
  * Create idempotent instruction for creating an associated compressed token account.
+ * Uses the default rent sponsor PDA by default.
  *
  * @param feePayer          Fee payer public key.
  * @param owner             Owner of the associated token account.
  * @param mint              Mint address.
- * @param compressibleConfig Optional compressible configuration.
- * @param configAccount     Optional config account.
- * @param rentPayerPda      Optional rent payer PDA.
+ * @param compressibleConfig Compressible configuration (defaults to rent sponsor config).
+ * @param configAccount     Config account (defaults to LIGHT_TOKEN_CONFIG).
+ * @param rentPayerPda      Rent payer PDA (defaults to LIGHT_TOKEN_RENT_SPONSOR).
  */
-declare function createAssociatedCTokenAccountIdempotentInstruction(
-    feePayer: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    compressibleConfig?: CompressibleConfig,
-    configAccount?: PublicKey,
-    rentPayerPda?: PublicKey,
-): TransactionInstruction;
+declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
 
 /**
  * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
@@ -876,15 +751,7 @@ interface CTokenConfig {
  * @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;
+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
@@ -898,15 +765,7 @@ declare function createAssociatedTokenAccountInterfaceInstruction(
  * @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;
+declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
 /**
  * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
  */
@@ -924,17 +783,12 @@ declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTo
  * @param recipientAccount    Recipient onchain token account address.
  * @param amount              Amount to mint.
  */
-declare function createMintToInstruction(
-    authority: PublicKey,
-    payer: PublicKey,
-    validityProof: ValidityProofWithContext,
-    merkleContext: MerkleContext,
-    mintData: MintInstructionData,
-    outputStateTreeInfo: TreeInfo,
-    recipientAccount: PublicKey,
-    amount: number | bigint,
-): TransactionInstruction;
+declare function createMintToInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, outputStateTreeInfo: TreeInfo, recipientAccount: PublicKey, amount: number | bigint): TransactionInstruction;
 
+/** Default compressible config PDA (V1) */
+declare const LIGHT_TOKEN_CONFIG: PublicKey;
+/** Default rent sponsor PDA (V1) */
+declare const LIGHT_TOKEN_RENT_SPONSOR: PublicKey;
 /**
  * Token data version enum - mirrors Rust TokenDataVersion
  * Used for compressed token account hashing strategy
@@ -945,7 +799,7 @@ declare enum TokenDataVersion {
     /** 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,
+    ShaFlat = 3
 }
 declare const POOL_SEED: Buffer$1<ArrayBuffer>;
 declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
@@ -959,6 +813,47 @@ 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
+ */
+/** Base rent per epoch (lamports) */
+declare const BASE_RENT_PER_EPOCH = 128;
+/** Rent per byte per epoch (lamports) */
+declare const RENT_PER_BYTE_PER_EPOCH = 1;
+/** Slots per rent epoch (1.5 hours) */
+declare const SLOTS_PER_RENT_EPOCH = 13500;
+/** Compression cost (lamports) - paid at account creation */
+declare const COMPRESSION_COST = 10000;
+/** Compression incentive (lamports) - paid at account creation */
+declare const COMPRESSION_INCENTIVE = 1000;
+/** Total compression cost (COMPRESSION_COST + COMPRESSION_INCENTIVE) */
+declare const TOTAL_COMPRESSION_COST: number;
+/**
+ * Compressible ctoken account size in bytes.
+ * = 165 (base SPL token) + 1 (account_type) + 1 (Option) + 4 (Vec len) + 1 (ext disc) + 4 (ext header) + 96 (CompressionInfo) = 272
+ * Source: program-libs/token-interface/src/state/token/top_up.rs MIN_SIZE_WITH_COMPRESSIBLE
+ */
+declare const COMPRESSIBLE_CTOKEN_ACCOUNT_SIZE = 272;
+/**
+ * Calculate rent per epoch for a given account size.
+ * Formula: base_rent + (bytes * lamports_per_byte_per_epoch)
+ */
+declare function rentPerEpoch(bytes: number): number;
+/**
+ * Default rent per epoch for a compressible ctoken account (272 bytes).
+ * = 128 + 272 = 400 lamports
+ */
+declare const COMPRESSIBLE_CTOKEN_RENT_PER_EPOCH: number;
+/** Default prepaid epochs (24 hours = 16 epochs * 1.5h) */
+declare const DEFAULT_PREPAY_EPOCHS = 16;
+/** Default write top-up (lamports) - ~2 epochs rent */
+declare const DEFAULT_WRITE_TOP_UP = 766;
+/**
+ * Calculate fee payer cost at ATA creation.
+ * = compression_cost (11K) + (prepay_epochs * rent_per_epoch)
+ */
+declare function calculateFeePayerCostAtCreation(prepayEpochs?: number, accountBytes?: number): number;
 
 /**
  * Create instruction for minting tokens from a c-mint to compressed accounts.
@@ -976,19 +871,10 @@ declare const DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR: Buffer$1<ArrayBuffer
  * @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;
+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.
@@ -1002,31 +888,22 @@ declare function createMintToCompressedInstruction(
  * @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;
+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.
  *
+ * 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 c-token transfer
  */
-declare function createCTokenTransferInstruction(
-    source: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-): TransactionInstruction;
+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`.
@@ -1037,18 +914,11 @@ declare function createCTokenTransferInstruction(
  * @param amount        Amount to transfer
  * @returns instruction for c-token transfer
  */
-declare function createTransferInterfaceInstruction(
-    source: PublicKey,
-    destination: PublicKey,
-    owner: PublicKey,
-    amount: number | bigint,
-    multiSigners?: (Signer | PublicKey)[],
-    programId?: PublicKey,
-): TransactionInstruction;
+declare function createTransferInterfaceInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, multiSigners?: (Signer | PublicKey)[], programId?: PublicKey): TransactionInstruction;
 
 declare namespace BN {
-    type Endianness = 'le' | 'be';
-    type IPrimeName = 'k256' | 'p224' | 'p192' | 'p25519';
+    type Endianness = "le" | "be";
+    type IPrimeName = "k256" | "p224" | "p192" | "p25519";
 
     interface MPrime {
         name: string;
@@ -1070,7 +940,7 @@ declare class BN {
 
     constructor(
         number: bigint | number | string | number[] | Uint8Array | Buffer | BN,
-        base?: number | 'hex',
+        base?: number | "hex",
         endian?: BN.Endianness,
     );
     constructor(
@@ -1116,7 +986,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)
@@ -1376,11 +1246,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
@@ -1748,21 +1614,14 @@ declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
  *
  * @returns SplInterfaceInfo for the to-be-initialized interface
  */
-declare function deriveSplInterfaceInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): SplInterfaceInfo;
+declare function deriveSplInterfaceInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): SplInterfaceInfo;
 /**
  * Check if the SPL interface info is initialized and has a balance.
  * @param mint The mint of the SPL interface
  * @param splInterfaceInfo The SPL interface info (or TokenPoolInfo for backward compatibility)
  * @returns True if the SPL interface info is initialized and has a balance
  */
-declare function checkSplInterfaceInfo(
-    splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare function checkSplInterfaceInfo(splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo, mint: PublicKey): boolean;
 /**
  * Get the SPL interface infos for a given mint.
  * @param rpc         The RPC client
@@ -1771,11 +1630,7 @@ declare function checkSplInterfaceInfo(
  *
  * @returns The SPL interface infos
  */
-declare function getSplInterfaceInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<SplInterfaceInfo[]>;
+declare function getSplInterfaceInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<SplInterfaceInfo[]>;
 type SplInterfaceActivity = {
     signature: string;
     amount: BN;
@@ -1787,7 +1642,7 @@ type SplInterfaceActivity = {
 declare enum Action {
     Compress = 1,
     Decompress = 2,
-    Transfer = 3,
+    Transfer = 3
 }
 /**
  * For `compress` and `mintTo` instructions only.
@@ -1799,9 +1654,7 @@ declare enum Action {
  *
  * @returns A random SPL interface info
  */
-declare function selectSplInterfaceInfo(
-    infos: SplInterfaceInfo[],
-): SplInterfaceInfo;
+declare function selectSplInterfaceInfo(infos: SplInterfaceInfo[]): SplInterfaceInfo;
 /**
  * Select one or multiple SPL interface infos from the SPL interface infos.
  *
@@ -1814,10 +1667,7 @@ declare function selectSplInterfaceInfo(
  *
  * @returns Array with one or more SPL interface infos.
  */
-declare function selectSplInterfaceInfosForDecompression(
-    infos: SplInterfaceInfo[],
-    decompressAmount: number | BN,
-): SplInterfaceInfo[];
+declare function selectSplInterfaceInfosForDecompression(infos: SplInterfaceInfo[], decompressAmount: number | BN): SplInterfaceInfo[];
 /**
  * @deprecated Use {@link SplInterfaceActivity} instead.
  */
@@ -1825,26 +1675,15 @@ type TokenPoolActivity = SplInterfaceActivity;
 /**
  * @deprecated Use {@link deriveSplInterfaceInfo} instead.
  */
-declare function deriveTokenPoolInfo(
-    mint: PublicKey,
-    tokenProgramId: PublicKey,
-    poolIndex?: number,
-): TokenPoolInfo;
+declare function deriveTokenPoolInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): TokenPoolInfo;
 /**
  * @deprecated Use {@link checkSplInterfaceInfo} instead.
  */
-declare function checkTokenPoolInfo(
-    tokenPoolInfo: TokenPoolInfo,
-    mint: PublicKey,
-): boolean;
+declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
 /**
  * @deprecated Use {@link getSplInterfaceInfos} instead.
  */
-declare function getTokenPoolInfos(
-    rpc: Rpc,
-    mint: PublicKey,
-    commitment?: Commitment,
-): Promise<TokenPoolInfo[]>;
+declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
 /**
  * @deprecated Use {@link selectSplInterfaceInfo} instead.
  */
@@ -1852,10 +1691,7 @@ declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
 /**
  * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
  */
-declare function selectTokenPoolInfosForDecompression(
-    infos: TokenPoolInfo[],
-    decompressAmount: number | BN,
-): TokenPoolInfo[];
+declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
 
 /**
  * Create decompressInterface instruction using Transfer2.
@@ -1873,26 +1709,17 @@ 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;
+declare function createDecompressInterfaceInstruction(payer: PublicKey, inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: bigint, validityProof: ValidityProofWithContext, splInterfaceInfo: SplInterfaceInfo | undefined, decimals: number): TransactionInstruction;
 
 declare const TokenAccountSourceType: {
-    readonly Spl: 'spl';
-    readonly Token2022: 'token2022';
-    readonly SplCold: 'spl-cold';
-    readonly Token2022Cold: 'token2022-cold';
-    readonly CTokenHot: 'ctoken-hot';
-    readonly CTokenCold: 'ctoken-cold';
+    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;
@@ -1919,36 +1746,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;
@@ -1964,12 +1780,7 @@ 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>;
 
 /**
  * Options for interface operations (load, transfer)
@@ -1996,19 +1807,7 @@ interface InterfaceOptions {
  * @param wrap            Include SPL/T22 wrapping (default: false)
  * @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,
-    wrap?: boolean,
-): Promise<TransactionSignature>;
+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>;
 
 /**
  * Account info interface for compressible accounts.
@@ -2129,21 +1928,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
@@ -2159,16 +1948,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 and initialize a new mint for SPL/T22/c-token.
@@ -2187,19 +1967,7 @@ declare function createWrapInstruction(
  *
  * @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;
 }>;
@@ -2214,14 +1982,7 @@ 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.
  *
@@ -2232,14 +1993,7 @@ 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.
@@ -2254,17 +2008,7 @@ 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.
  *
@@ -2276,15 +2020,7 @@ 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.
  *
@@ -2297,16 +2033,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
@@ -2325,17 +2052,7 @@ declare function removeMetadataKey(
  * @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.
@@ -2356,28 +2073,9 @@ declare function createAtaInterface(
  *
  * @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>;
+
+declare function mintTo$1(rpc: Rpc, payer: Signer, mint: PublicKey, recipientAccount: PublicKey, authority: Signer, amount: number | bigint, outputQueue?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens directly to compressed accounts.
@@ -2391,19 +2089,10 @@ 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.
@@ -2424,17 +2113,7 @@ declare function mintToCompressed(
  *
  * @returns Transaction signature
  */
-declare function mintToInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    destination: PublicKey,
-    authority: Signer | PublicKey,
-    amount: number | bigint,
-    multiSigners?: Signer[],
-    confirmOptions?: ConfirmOptions,
-    programId?: PublicKey,
-): Promise<TransactionSignature>;
+declare function mintToInterface(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer | PublicKey, amount: number | bigint, multiSigners?: Signer[], confirmOptions?: ConfirmOptions, programId?: PublicKey): Promise<TransactionSignature>;
 
 /**
  * Retrieve the associated token account, or create it if it doesn't exist.
@@ -2459,17 +2138,7 @@ declare function mintToInterface(
  *
  * @returns AccountInterface with aggregated balance and source breakdown
  */
-declare function getOrCreateAtaInterface(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    owner: PublicKey | Signer,
-    allowOwnerOffCurve?: boolean,
-    commitment?: Commitment,
-    confirmOptions?: ConfirmOptions,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-): Promise<AccountInterface>;
+declare function getOrCreateAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey | Signer, allowOwnerOffCurve?: boolean, commitment?: Commitment, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey): Promise<AccountInterface>;
 
 /**
  * Decompress compressed (cold) tokens to an on-chain token account.
@@ -2487,17 +2156,7 @@ declare function getOrCreateAtaInterface(
  * @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.
@@ -2531,17 +2190,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>;
+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.
@@ -2559,14 +2208,7 @@ declare function wrap(
  * @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[]>;
 
 /**
  * Derive the canonical associated token address for any of SPL/T22/c-token.
@@ -2581,13 +2223,7 @@ declare function createLoadAtaInstructionsFromInterface(
  *                                  auto-detected.
  * @returns                         Associated token address.
  */
-declare function getAssociatedTokenAddressInterface(
-    mint: PublicKey,
-    owner: PublicKey,
-    allowOwnerOffCurve?: boolean,
-    programId?: PublicKey,
-    associatedTokenProgramId?: PublicKey,
-): PublicKey;
+declare function getAssociatedTokenAddressInterface(mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, programId?: PublicKey, associatedTokenProgramId?: PublicKey): PublicKey;
 
 /**
  * Input for creating off-chain metadata JSON.
@@ -2645,9 +2281,7 @@ interface OffChainTokenMetadataJson {
  * // Then use uri with createMint
  * await createMint(rpc, payer, { ...params, uri });
  */
-declare function toOffChainMetadataJson(
-    meta: OffChainTokenMetadata,
-): OffChainTokenMetadataJson;
+declare function toOffChainMetadataJson(meta: OffChainTokenMetadata): OffChainTokenMetadataJson;
 
 /**
  * Approve a delegate to spend tokens
@@ -2662,15 +2296,7 @@ declare function toOffChainMetadataJson(
  *
  * @return Signature of the confirmed transaction
  */
-declare function approve(
-    rpc: Rpc,
-    payer: Signer,
-    mint: PublicKey,
-    amount: number | BN,
-    owner: Signer,
-    delegate: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+declare function approve(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, delegate: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Mint compressed tokens to a solana address from an external mint authority
@@ -2689,17 +2315,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
@@ -2719,18 +2335,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
@@ -2750,17 +2355,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
@@ -2780,16 +2375,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;
 }>;
@@ -2806,13 +2392,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.
  */
@@ -2831,14 +2411,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.
  */
@@ -2858,13 +2431,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;
 }>;
@@ -2884,16 +2451,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
@@ -2913,13 +2471,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
@@ -2941,17 +2493,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
@@ -2965,13 +2507,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.
@@ -2989,15 +2525,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
@@ -3012,15 +2540,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
@@ -3038,21 +2558,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
  */
@@ -3067,9 +2576,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
  */
@@ -3094,10 +2601,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.
  *
@@ -3116,16 +2620,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
@@ -3139,12 +2638,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;
@@ -3168,31 +2662,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
@@ -3235,31 +2720,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 = {
@@ -3332,9 +2808,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.
  */
@@ -3445,9 +2919,7 @@ type PackCompressedTokenAccountsParams = {
 /**
  * Packs Compressed Token Accounts.
  */
-declare function packCompressedTokenAccounts(
-    params: PackCompressedTokenAccountsParams,
-): {
+declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
     inputTokenDataWithContext: InputTokenDataWithContext$1[];
     remainingAccountMetas: AccountMeta[];
     packedOutputTokenData: PackedTokenTransferOutputData[];
@@ -3460,10 +2932,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';
@@ -3475,7 +2944,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: [
                 {
@@ -3508,7 +2977,7 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [];
         },
@@ -3516,7 +2985,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: [
                 {
@@ -3554,13 +3023,13 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'tokenPoolIndex';
                     type: 'u8';
-                },
+                }
             ];
         },
         {
@@ -3572,7 +3041,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: [
                 {
@@ -3652,7 +3121,7 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                },
+                }
             ];
             args: [
                 {
@@ -3672,7 +3141,7 @@ type LightCompressedToken = {
                     type: {
                         option: 'u64';
                     };
-                },
+                }
             ];
         },
         {
@@ -3680,7 +3149,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: [
                 {
@@ -3696,7 +3165,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.'
                     ];
                 },
                 {
@@ -3757,7 +3226,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -3777,7 +3246,7 @@ type LightCompressedToken = {
                             defined: 'CompressedCpiContext';
                         };
                     };
-                },
+                }
             ];
         },
         {
@@ -3790,7 +3259,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: [
                 {
@@ -3806,7 +3275,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.'
                     ];
                 },
                 {
@@ -3867,13 +3336,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -3884,7 +3353,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: [
                 {
@@ -3900,7 +3369,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.'
                     ];
                 },
                 {
@@ -3943,20 +3412,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: [
                 {
@@ -3972,7 +3441,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.'
                     ];
                 },
                 {
@@ -4015,20 +3484,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: [
                 {
@@ -4087,20 +3556,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: [
                 {
@@ -4159,13 +3628,13 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4173,7 +3642,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: [
                 {
@@ -4189,7 +3658,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.'
                     ];
                 },
                 {
@@ -4246,13 +3715,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                },
+                }
             ];
         },
         {
@@ -4260,7 +3729,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: [
                 {
@@ -4276,7 +3745,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.'
                     ];
                 },
                 {
@@ -4337,7 +3806,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                },
+                }
             ];
             args: [
                 {
@@ -4351,9 +3820,9 @@ type LightCompressedToken = {
                     type: {
                         defined: 'TokenData';
                     };
-                },
+                }
             ];
-        },
+        }
     ];
     types: [
         {
@@ -4366,7 +3835,7 @@ type LightCompressedToken = {
                     },
                     {
                         name: 'Frozen';
-                    },
+                    }
                 ];
             };
         },
@@ -4398,7 +3867,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedAccountData';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4422,7 +3891,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4435,7 +3904,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';
                     },
@@ -4443,17 +3912,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';
-                    },
+                    }
                 ];
             };
         },
@@ -4479,7 +3948,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4505,7 +3974,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: {
@@ -4552,7 +4021,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'u8';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4592,7 +4061,7 @@ type LightCompressedToken = {
                     {
                         name: 'outputAccountMerkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4650,14 +4119,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';
@@ -4672,12 +4141,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';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4715,12 +4184,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4776,7 +4245,7 @@ type LightCompressedToken = {
                     {
                         name: 'isCompress';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4840,7 +4309,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -4856,7 +4325,7 @@ type LightCompressedToken = {
                     {
                         name: 'seq';
                         type: 'u64';
-                    },
+                    }
                 ];
             };
         },
@@ -4882,7 +4351,7 @@ type LightCompressedToken = {
                     {
                         name: 'addressMerkleTreeRootIndex';
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -4900,7 +4369,7 @@ type LightCompressedToken = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
-                    },
+                    }
                 ];
             };
         },
@@ -4924,17 +4393,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';
-                    },
+                    }
                 ];
             };
         },
@@ -4958,7 +4427,7 @@ type LightCompressedToken = {
                     {
                         name: 'proveByIndex';
                         type: 'bool';
-                    },
+                    }
                 ];
             };
         },
@@ -4988,12 +4457,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5067,7 +4536,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
         },
@@ -5085,7 +4554,7 @@ type LightCompressedToken = {
                         name: 'index';
                         docs: ['Index of compressed account hash in queue.'];
                         type: 'u16';
-                    },
+                    }
                 ];
             };
         },
@@ -5113,7 +4582,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';
@@ -5129,15 +4598,15 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    },
+                    }
                 ];
             };
-        },
+        }
     ];
     errors: [
         {
@@ -5294,7 +4763,7 @@ type LightCompressedToken = {
         {
             code: 6032;
             name: 'NoMatchingBumpFound';
-        },
+        }
     ];
 };
 declare const IDL: LightCompressedToken;
@@ -5305,30 +4774,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;
@@ -5370,44 +4823,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 = {
     /**
@@ -5501,11 +4930,7 @@ type DecompressParams = {
     /**
      * Token pool(s)
      */
-    tokenPoolInfos:
-        | TokenPoolInfo
-        | TokenPoolInfo[]
-        | SplInterfaceInfo
-        | SplInterfaceInfo[];
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[] | SplInterfaceInfo | SplInterfaceInfo[];
 };
 type TransferParams = {
     /**
@@ -5790,17 +5215,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;
 };
@@ -5812,11 +5232,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
@@ -5824,10 +5240,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
@@ -5865,17 +5278,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.
      *
@@ -5885,17 +5292,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;
     /**
@@ -5916,16 +5317,7 @@ declare class CompressedTokenProgram {
      * Note that `createTokenPoolInstruction` must be executed after
      * `initializeMintInstruction`.
      */
-    static createMint({
-        feePayer,
-        mint,
-        authority,
-        freezeAuthority,
-        decimals,
-        rentExemptBalance,
-        tokenProgramId,
-        mintSize,
-    }: CreateMintParams): Promise<TransactionInstruction[]>;
+    static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
      * Enable compression for an existing SPL mint, creating an omnibus account.
      * For new mints, use `CompressedTokenProgram.createMint`.
@@ -5937,11 +5329,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The createTokenPool instruction
      */
-    static createTokenPool({
-        feePayer,
-        mint,
-        tokenProgramId,
-    }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
+    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Add a token pool to an existing SPL mint.  For new mints, use
      * {@link createTokenPool}.
@@ -5954,12 +5342,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
      *
@@ -5973,15 +5356,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
      *
@@ -5997,16 +5372,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.
      *
@@ -6021,14 +5387,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.
@@ -6041,13 +5400,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;
     }>;
@@ -6065,16 +5418,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
      *
@@ -6089,15 +5433,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.
      *
@@ -6110,14 +5446,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
      *
@@ -6131,15 +5460,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
      *
@@ -6148,10 +5469,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.
      *
@@ -6164,14 +5482,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.
      *
@@ -6182,12 +5493,7 @@ declare class CompressedTokenProgram {
      *
      * @returns instruction
      */
-    static revoke({
-        payer,
-        inputCompressedTokenAccounts,
-        recentValidityProof,
-        recentInputStateRootIndices,
-    }: RevokeParams): Promise<TransactionInstruction>;
+    static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
 /**
@@ -6201,14 +5507,7 @@ declare class CompressedTokenProgram {
  * @param programId   Optional program ID
  * @returns AccountInterface with ATA metadata
  */
-declare function getAtaInterface(
-    rpc: Rpc,
-    ata: PublicKey,
-    owner: PublicKey,
-    mint: PublicKey,
-    commitment?: Commitment,
-    programId?: PublicKey,
-): Promise<AccountInterface>;
+declare function getAtaInterface(rpc: Rpc, ata: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
 /**
  * Create instructions to load token balances into a c-token ATA.
  *
@@ -6220,14 +5519,7 @@ declare function getAtaInterface(
  * @param options Optional load options
  * @returns       Array of instructions (empty if nothing to load)
  */
-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.
  *
@@ -6240,225 +5532,6 @@ declare function createLoadAtaInstructions(
  * @param interfaceOptions  Optional interface options
  * @returns Transaction signature, or null if nothing to load
  */
-declare function loadAta(
-    rpc: Rpc,
-    ata: PublicKey,
-    owner: Signer,
-    mint: PublicKey,
-    payer?: Signer,
-    confirmOptions?: ConfirmOptions,
-    interfaceOptions?: InterfaceOptions,
-): Promise<TransactionSignature | null>;
-
-export {
-    ADD_TOKEN_POOL_DISCRIMINATOR,
-    APPROVE_DISCRIMINATOR,
-    type AccountInterface,
-    Action,
-    type AddSplInterfaceParams,
-    type AddTokenPoolParams,
-    type ApproveAndMintToParams,
-    type ApproveParams,
-    BATCH_COMPRESS_DISCRIMINATOR,
-    type BaseMint,
-    type BatchCompressInstructionData,
-    COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR,
-    CPI_AUTHORITY_SEED,
-    CREATE_TOKEN_POOL_DISCRIMINATOR,
-    type CTokenConfig,
-    type CompressParams,
-    type CompressSplTokenAccountInstructionData,
-    type CompressSplTokenAccountParams,
-    type CompressedMint,
-    type CompressedTokenInstructionDataApprove,
-    CompressedTokenInstructionDataApproveLayout,
-    type CompressedTokenInstructionDataRevoke,
-    CompressedTokenInstructionDataRevokeLayout,
-    type CompressedTokenInstructionDataTransfer,
-    CompressedTokenInstructionDataTransferLayout,
-    CompressedTokenProgram,
-    type CompressibleAccountInput,
-    type CompressibleConfig,
-    type CompressibleLoadParams,
-    CpiContextLayout,
-    type CreateAssociatedCTokenAccountParams,
-    type CreateMintParams,
-    type CreateSplInterfaceParams,
-    type CreateTokenPoolParams,
-    type CreateTokenProgramLookupTableParams,
-    DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR,
-    type DecompressParams,
-    type DelegatedTransfer,
-    DelegatedTransferLayout,
-    ERROR_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,
-    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,
-    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,
-};
+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 };