@lightprotocol/compressed-token 0.22.1-alpha.2 → 0.22.1-alpha.4

package/dist/types/index.d.ts

@@ -1,59 +1,1438 @@
-import { Signer, PublicKey, ConfirmOptions, TransactionSignature, Commitment, Keypair, AccountMeta, TransactionInstruction, Connection } from '@solana/web3.js';
-import { Rpc, TreeInfo, ParsedTokenAccount, PackedMerkleContextLegacy, CompressedCpiContext, ValidityProof, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof } from '@lightprotocol/stateless.js';
-import BN from 'bn.js';
-import { Buffer } from 'buffer';
-import * as buffer_layout from 'buffer-layout';
+/// <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, 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;
+    toString(encoding?: string, start?: number, end?: number): string;
+    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;
+    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;
+    readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUInt8(offset: number, noAssert?: boolean): number;
+    readUInt16LE(offset: number, noAssert?: boolean): number;
+    readUInt16BE(offset: number, noAssert?: boolean): number;
+    readUInt32LE(offset: number, noAssert?: boolean): number;
+    readUInt32BE(offset: number, noAssert?: boolean): number;
+    readBigUInt64LE(offset: number): BigInt;
+    readBigUInt64BE(offset: number): BigInt;
+    readInt8(offset: number, noAssert?: boolean): number;
+    readInt16LE(offset: number, noAssert?: boolean): number;
+    readInt16BE(offset: number, noAssert?: boolean): number;
+    readInt32LE(offset: number, noAssert?: boolean): number;
+    readInt32BE(offset: number, noAssert?: boolean): number;
+    readBigInt64LE(offset: number): BigInt;
+    readBigInt64BE(offset: number): BigInt;
+    readFloatLE(offset: number, noAssert?: boolean): number;
+    readFloatBE(offset: number, noAssert?: boolean): number;
+    readDoubleLE(offset: number, noAssert?: boolean): number;
+    readDoubleBE(offset: number, noAssert?: boolean): number;
+    reverse(): this;
+    swap16(): Buffer$1;
+    swap32(): Buffer$1;
+    swap64(): Buffer$1;
+    writeUInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeBigUInt64LE(value: number, offset: number): BigInt;
+    writeBigUInt64BE(value: number, offset: number): BigInt;
+    writeInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeBigInt64LE(value: number, offset: number): BigInt;
+    writeBigInt64BE(value: number, offset: number): BigInt;
+    writeFloatLE(value: number, offset: number, noAssert?: boolean): number;
+    writeFloatBE(value: number, offset: number, noAssert?: boolean): number;
+    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;
+
+    /**
+     * Allocates a new buffer containing the given {str}.
+     *
+     * @param str String to store in buffer.
+     * @param encoding encoding to use, optional.  Default is 'utf8'
+     */
+    constructor (str: string, encoding?: string);
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     */
+    constructor (size: number);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: Uint8Array);
+    /**
+     * Produces a Buffer backed by the same allocated memory as
+     * the given {ArrayBuffer}.
+     *
+     *
+     * @param arrayBuffer The ArrayBuffer with which to share memory.
+     */
+    constructor (arrayBuffer: ArrayBuffer);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: any[]);
+    /**
+     * Copies the passed {buffer} data onto a new {Buffer} instance.
+     *
+     * @param buffer The buffer to copy.
+     */
+    constructor (buffer: Buffer$1);
+    prototype: Buffer$1;
+    /**
+     * Allocates a new Buffer using an {array} of octets.
+     *
+     * @param array
+     */
+    static from(array: any[]): Buffer$1;
+    /**
+     * When passed a reference to the .buffer property of a TypedArray instance,
+     * the newly created Buffer will share the same allocated memory as the TypedArray.
+     * The optional {byteOffset} and {length} arguments specify a memory range
+     * within the {arrayBuffer} that will be shared by the Buffer.
+     *
+     * @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()
+     * @param byteOffset
+     * @param length
+     */
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer$1;
+    /**
+     * Copies the passed {buffer} data onto a new Buffer instance.
+     *
+     * @param buffer
+     */
+    static from(buffer: Buffer$1 | Uint8Array): Buffer$1;
+    /**
+     * Creates a new Buffer containing the given JavaScript string {str}.
+     * If provided, the {encoding} parameter identifies the character encoding.
+     * If not provided, {encoding} defaults to 'utf8'.
+     *
+     * @param str
+     */
+    static from(str: string, encoding?: string): Buffer$1;
+    /**
+     * Returns true if {obj} is a Buffer
+     *
+     * @param obj object to test.
+     */
+    static isBuffer(obj: any): obj is Buffer$1;
+    /**
+     * Returns true if {encoding} is a valid encoding argument.
+     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
+     *
+     * @param encoding string to test.
+     */
+    static isEncoding(encoding: string): boolean;
+    /**
+     * Gives the actual byte length of a string. encoding defaults to 'utf8'.
+     * This is not the same as String.prototype.length since that returns the number of characters in a string.
+     *
+     * @param string string to test.
+     * @param encoding encoding used to evaluate (defaults to 'utf8')
+     */
+    static byteLength(string: string, encoding?: string): number;
+    /**
+     * Returns a buffer which is the result of concatenating all the buffers in the list together.
+     *
+     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
+     * If the list has exactly one item, then the first item of the list is returned.
+     * If the list has more than one item, then a new Buffer is created.
+     *
+     * @param list An array of Buffer objects to concatenate
+     * @param totalLength Total length of the buffers when concatenated.
+     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
+     */
+    static concat(list: Uint8Array[], totalLength?: number): Buffer$1;
+    /**
+     * The same as buf1.compare(buf2).
+     */
+    static compare(buf1: Uint8Array, buf2: Uint8Array): number;
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
+     *    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;
+    /**
+     * 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.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafe(size: number): Buffer$1;
+    /**
+     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
+     * of the newly created Buffer are unknown and may contain sensitive data.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafeSlow(size: number): Buffer$1;
+}
+
+interface LayoutObject {
+    [key: string]: any;
+}
 /**
- * Approve a delegate to spend tokens
+ * Base class for layout objects.
  *
- * @param rpc                   Rpc to use
- * @param payer                 Fee payer
- * @param mint                  SPL Mint address
- * @param amount                Number of tokens to delegate
- * @param owner                 Owner of the SPL token account.
- * @param delegate              Address of the delegate
- * @param confirmOptions        Options for confirming the transaction
+ * **NOTE** This is an abstract base class; you can create instances
+ * if it amuses you, but they won't support the {@link
+ * Layout#encode|encode} or {@link Layout#decode|decode} functions.
  *
- * @return Signature of the confirmed transaction
+ * @param {Number} span - Initializer for {@link Layout#span|span}.  The
+ * parameter must be an integer; a negative value signifies that the
+ * span is {@link Layout#getSpan|value-specific}.
+ *
+ * @param {string} [property] - Initializer for {@link
+ * Layout#property|property}.
+ *
+ * @abstract
  */
-declare function approve(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, delegate: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare abstract class Layout<T> {
+    span: number;
+    property?: string;
+    boundConstructor_?: any;
+    constructor(span: number, property?: string);
+    /** Function to create an Object into which decoded properties will
+     * be written.
+     *
+     * Used only for layouts that {@link Layout#decode|decode} to Object
+     * instances, which means:
+     * * {@link Structure}
+     * * {@link Union}
+     * * {@link VariantLayout}
+     * * {@link BitStructure}
+     *
+     * If left undefined the JavaScript representation of these layouts
+     * will be Object instances.
+     *
+     * See {@link bindConstructorLayout}.
+     */
+    makeDestinationObject(): LayoutObject;
+    /**
+     * Decode from a Uint8Array into a JavaScript value.
+     *
+     * @param {Uint8Array} b - the buffer from which encoded data is read.
+     *
+     * @param {Number} [offset] - the offset at which the encoded data
+     * starts.  If absent a zero offset is inferred.
+     *
+     * @returns {(Number|Array|Object)} - the value of the decoded data.
+     *
+     * @abstract
+     */
+    abstract decode(b: Uint8Array, offset?: number): T;
+    /**
+     * Encode a JavaScript value into a Uint8Array.
+     *
+     * @param {(Number|Array|Object)} src - the value to be encoded into
+     * the buffer.  The type accepted depends on the (sub-)type of {@link
+     * Layout}.
+     *
+     * @param {Uint8Array} b - the buffer into which encoded data will be
+     * written.
+     *
+     * @param {Number} [offset] - the offset at which the encoded data
+     * starts.  If absent a zero offset is inferred.
+     *
+     * @returns {Number} - the number of bytes encoded, including the
+     * space skipped for internal padding, but excluding data such as
+     * {@link Sequence#count|lengths} when stored {@link
+     * ExternalLayout|externally}.  This is the adjustment to `offset`
+     * producing the offset where data for the next layout would be
+     * written.
+     *
+     * @abstract
+     */
+    abstract encode(src: T, b: Uint8Array, offset?: number): number;
+    /**
+     * Calculate the span of a specific instance of a layout.
+     *
+     * @param {Uint8Array} b - the buffer that contains an encoded instance.
+     *
+     * @param {Number} [offset] - the offset at which the encoded instance
+     * starts.  If absent a zero offset is inferred.
+     *
+     * @return {Number} - the number of bytes covered by the layout
+     * instance.  If this method is not overridden in a subclass the
+     * definition-time constant {@link Layout#span|span} will be
+     * returned.
+     *
+     * @throws {RangeError} - if the length of the value cannot be
+     * determined.
+     */
+    getSpan(b?: Uint8Array, offset?: number): number;
+    /**
+     * Replicate the layout using a new property.
+     *
+     * This function must be used to get a structurally-equivalent layout
+     * with a different name since all {@link Layout} instances are
+     * immutable.
+     *
+     * **NOTE** This is a shallow copy.  All fields except {@link
+     * Layout#property|property} are strictly equal to the origin layout.
+     *
+     * @param {String} property - the value for {@link
+     * Layout#property|property} in the replica.
+     *
+     * @returns {Layout} - the copy with {@link Layout#property|property}
+     * set to `property`.
+     */
+    replicate(property: string): this;
+    /**
+     * Create an object from layout properties and an array of values.
+     *
+     * **NOTE** This function returns `undefined` if invoked on a layout
+     * that does not return its value as an Object.  Objects are
+     * returned for things that are a {@link Structure}, which includes
+     * {@link VariantLayout|variant layouts} if they are structures, and
+     * excludes {@link Union}s.  If you want this feature for a union
+     * you must use {@link Union.getVariant|getVariant} to select the
+     * desired layout.
+     *
+     * @param {Array} values - an array of values that correspond to the
+     * default order for properties.  As with {@link Layout#decode|decode}
+     * layout elements that have no property name are skipped when
+     * iterating over the array values.  Only the top-level properties are
+     * assigned; arguments are not assigned to properties of contained
+     * layouts.  Any unused values are ignored.
+     *
+     * @return {(Object|undefined)}
+     */
+    fromArray(values: any[]): LayoutObject | undefined;
+}
+
+interface AdditionalMetadata {
+    key: Buffer$1;
+    value: Buffer$1;
+}
 
 /**
- * Check if the token pool info is initialized and has a balance.
- * @param mint The mint of the token pool
- * @param tokenPoolInfo The token pool info
- * @returns True if the token pool info is initialized and has a balance
+ * Token metadata for creating a c-token mint.
  */
-declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
+interface TokenMetadataInstructionData {
+    name: string;
+    symbol: string;
+    uri: string;
+    updateAuthority?: PublicKey | null;
+    additionalMetadata: AdditionalMetadata[] | null;
+}
+declare function createTokenMetadata(name: string, symbol: string, uri: string, updateAuthority?: PublicKey | null, additionalMetadata?: AdditionalMetadata[] | null): TokenMetadataInstructionData;
 /**
- * Get the token pool infos for a given mint.
- * @param rpc         The RPC client
- * @param mint        The mint of the token pool
- * @param commitment  The commitment to use
+ * Create instruction for initializing a c-token mint.
  *
- * @returns The token pool infos
+ * @param mintSigner          Mint signer keypair public key.
+ * @param decimals            Number of decimals for the mint.
+ * @param mintAuthority       Mint authority public key.
+ * @param freezeAuthority     Optional freeze authority public key.
+ * @param payer               Fee payer public key.
+ * @param validityProof       Validity proof for the mint account.
+ * @param addressTreeInfo     Address tree info for the mint.
+ * @param outputStateTreeInfo Output state tree info.
+ * @param metadata            Optional token metadata.
  */
-declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
-type TokenPoolActivity = {
-    signature: string;
-    amount: BN;
-    action: Action;
+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
+ */
+interface BaseMint {
+    /** Optional authority used to mint new tokens */
+    mintAuthority: PublicKey | null;
+    /** Total supply of tokens */
+    supply: bigint;
+    /** Number of base 10 digits to the right of the decimal place */
+    decimals: number;
+    /** Is initialized - for SPL compatibility */
+    isInitialized: boolean;
+    /** Optional authority to freeze token accounts */
+    freezeAuthority: PublicKey | null;
+}
+/**
+ * Compressed mint context (protocol version, SPL mint reference)
+ */
+interface MintContext {
+    /** Protocol version for upgradability */
+    version: number;
+    /** Whether the compressed mint is decompressed to a CMint Solana account */
+    cmintDecompressed: boolean;
+    /** PDA of the associated SPL mint */
+    splMint: PublicKey;
+}
+/**
+ * Raw extension data as stored on-chain
+ */
+interface MintExtension {
+    extensionType: number;
+    data: Uint8Array;
+}
+/**
+ * Parsed token metadata matching on-chain TokenMetadata extension.
+ * Fields: updateAuthority, mint, name, symbol, uri, additionalMetadata
+ */
+interface TokenMetadata {
+    /** Authority that can update metadata (None if zero pubkey) */
+    updateAuthority?: PublicKey | null;
+    /** Associated mint pubkey */
+    mint: PublicKey;
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** URI pointing to off-chain metadata JSON */
+    uri: string;
+    /** Additional key-value metadata pairs */
+    additionalMetadata?: {
+        key: string;
+        value: string;
+    }[];
+}
+/**
+ * Complete compressed mint structure (raw format)
+ */
+interface CompressedMint {
+    base: BaseMint;
+    mintContext: MintContext;
+    extensions: MintExtension[] | null;
+}
+/**
+ * Deserialize a compressed mint from buffer
+ * Uses SPL's MintLayout for BaseMint and buffer-layout struct for context
+ *
+ * @param data - The raw account data buffer
+ * @returns The deserialized CompressedMint
+ */
+declare function deserializeMint(data: Buffer$1 | Uint8Array): CompressedMint;
+/**
+ * Serialize a CompressedMint to buffer
+ * Uses SPL's MintLayout for BaseMint, helper functions for context/metadata
+ *
+ * @param mint - The CompressedMint to serialize
+ * @returns The serialized buffer
+ */
+declare function serializeMint(mint: CompressedMint): Buffer$1;
+/**
+ * Extension type constants
+ */
+declare enum ExtensionType {
+    TokenMetadata = 19
+}
+/**
+ * Decode TokenMetadata from raw extension data using Borsh layout
+ * Extension format: updateAuthority (32) + mint (32) + name (Vec) + symbol (Vec) + uri (Vec) + additional (Vec)
+ */
+declare function decodeTokenMetadata(data: Uint8Array): TokenMetadata | null;
+/**
+ * Encode TokenMetadata to raw bytes using Borsh layout
+ * @param metadata - TokenMetadata to encode
+ * @returns Encoded buffer
+ */
+declare function encodeTokenMetadata(metadata: TokenMetadata): Buffer$1;
+/**
+ * Extract and parse TokenMetadata from extensions array
+ * @param extensions - Array of raw extensions
+ * @returns Parsed TokenMetadata or null if not found
+ */
+declare function extractTokenMetadata(extensions: MintExtension[] | null): TokenMetadata | null;
+/**
+ * Metadata portion of MintInstructionData
+ * Used for instruction encoding when metadata extension is present
+ */
+interface MintMetadataField {
+    updateAuthority: PublicKey | null;
+    name: string;
+    symbol: string;
+    uri: string;
+}
+/**
+ * Flattened mint data structure for instruction encoding
+ * This is the format expected by mint action instructions
+ */
+interface MintInstructionData {
+    supply: bigint;
+    decimals: number;
+    mintAuthority: PublicKey | null;
+    freezeAuthority: PublicKey | null;
+    splMint: PublicKey;
+    cmintDecompressed: boolean;
+    version: number;
+    metadata?: MintMetadataField;
+}
+
+interface MintInterface {
+    mint: Mint;
+    programId: PublicKey;
+    merkleContext?: MerkleContext;
+    mintContext?: MintContext;
+    tokenMetadata?: TokenMetadata;
+    extensions?: MintExtension[];
+}
+/**
+ * Get unified mint info for SPL/T22/c-token mints.
+ *
+ * @param rpc           RPC connection
+ * @param address       The mint address
+ * @param commitment    Optional commitment level
+ * @param programId     Token program ID. If not provided, tries all programs to
+ *                      auto-detect.
+ * @returns Object with mint, optional merkleContext, mintContext, and
+ * tokenMetadata
+ */
+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.
+ *
+ * @param address       The mint pubkey
+ * @param data          The raw account data or AccountInfo
+ * @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'>;
+/**
+ * Unpack c-token mint context and metadata from raw account data
+ *
+ * @param data  The raw account data
+ * @returns     Object with mintContext, tokenMetadata, and extensions
+ */
+declare function unpackMintData(data: Buffer$1 | Uint8Array): {
+    mintContext: MintContext;
+    tokenMetadata?: TokenMetadata;
+    extensions?: MintExtension[];
+};
+
+/**
+ * Create instruction for updating a compressed mint's mint authority.
+ *
+ * @param mintInterface          MintInterface from getMintInterface() - must have merkleContext
+ * @param currentMintAuthority   Current mint authority public key (must sign)
+ * @param newMintAuthority       New mint authority (or null to revoke)
+ * @param payer                  Fee payer public key
+ * @param validityProof          Validity proof for the compressed mint
+ */
+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.
+ *
+ * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
+ * (preferring nextTreeInfo.queue if available for rollover support).
+ *
+ * @param mintInterface            MintInterface from getMintInterface() - must have merkleContext
+ * @param currentFreezeAuthority   Current freeze authority public key (must sign)
+ * @param newFreezeAuthority       New freeze authority (or null to revoke)
+ * @param payer                    Fee payer public key
+ * @param validityProof            Validity proof for the compressed mint
+ */
+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.
+ *
+ * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
+ * (preferring nextTreeInfo.queue if available for rollover support).
+ *
+ * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
+ * @param authority      Metadata update authority public key (must sign)
+ * @param payer          Fee payer public key
+ * @param validityProof  Validity proof for the compressed mint
+ * @param fieldType      Field to update: 'name', 'symbol', 'uri', or 'custom'
+ * @param value          New value for the field
+ * @param customKey      Custom key name (required if fieldType is 'custom')
+ * @param extensionIndex Extension index (default: 0)
+ */
+declare function createUpdateMetadataFieldInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number): TransactionInstruction;
+/**
+ * Create instruction for updating a compressed mint's metadata authority.
+ *
+ * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
+ * (preferring nextTreeInfo.queue if available for rollover support).
+ *
+ * @param mintInterface    MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
+ * @param currentAuthority Current metadata update authority public key (must sign)
+ * @param newAuthority     New metadata update authority public key
+ * @param payer            Fee payer public key
+ * @param validityProof    Validity proof for the compressed mint
+ * @param extensionIndex   Extension index (default: 0)
+ */
+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.
+ *
+ * Output queue is automatically derived from mintInterface.merkleContext.treeInfo
+ * (preferring nextTreeInfo.queue if available for rollover support).
+ *
+ * @param mintInterface  MintInterface from getMintInterface() - must have merkleContext and tokenMetadata
+ * @param authority      Metadata update authority public key (must sign)
+ * @param payer          Fee payer public key
+ * @param validityProof  Validity proof for the compressed mint
+ * @param key            Metadata key to remove
+ * @param idempotent     If true, don't error if key doesn't exist (default: false)
+ * @param extensionIndex Extension index (default: 0)
+ */
+declare function createRemoveMetadataKeyInstruction(mintInterface: MintInterface, authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, key: string, idempotent?: boolean, extensionIndex?: number): TransactionInstruction;
+
+interface CompressToPubkey {
+    bump: number;
+    programId: number[];
+    seeds: number[][];
+}
+interface CompressibleConfig {
+    tokenAccountVersion: number;
+    rentPayment: number;
+    hasTopUp: number;
+    compressionOnly: number;
+    writeTopUp: number;
+    compressToAccountPubkey?: CompressToPubkey | null;
+}
+interface CreateAssociatedCTokenAccountParams {
+    bump: number;
+    compressibleConfig?: CompressibleConfig;
+}
+/**
+ * Create instruction for creating an associated compressed token account.
+ *
+ * @param feePayer          Fee payer public key.
+ * @param owner             Owner of the associated token account.
+ * @param mint              Mint address.
+ * @param compressibleConfig Optional compressible configuration.
+ * @param configAccount     Optional config account.
+ * @param rentPayerPda      Optional rent payer PDA.
+ */
+declare function createAssociatedCTokenAccountInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+/**
+ * Create idempotent instruction for creating an associated compressed token account.
+ *
+ * @param feePayer          Fee payer public key.
+ * @param owner             Owner of the associated token account.
+ * @param mint              Mint address.
+ * @param compressibleConfig Optional compressible configuration.
+ * @param configAccount     Optional config account.
+ * @param rentPayerPda      Optional rent payer PDA.
+ */
+declare function createAssociatedCTokenAccountIdempotentInstruction(feePayer: PublicKey, owner: PublicKey, mint: PublicKey, compressibleConfig?: CompressibleConfig, configAccount?: PublicKey, rentPayerPda?: PublicKey): TransactionInstruction;
+
+/**
+ * c-token-specific config for createAssociatedTokenAccountInterfaceInstruction
+ */
+interface CTokenConfig {
+    compressibleConfig?: CompressibleConfig;
+    configAccount?: PublicKey;
+    rentPayerPda?: PublicKey;
+}
+/**
+ * Create instruction for creating an associated token account (SPL, Token-2022,
+ * or c-token). Follows SPL Token API signature with optional c-token config at the
+ * end.
+ *
+ * @param payer                    Fee payer public key.
+ * @param associatedToken          Associated token account address.
+ * @param owner                    Owner of the associated token account.
+ * @param mint                     Mint address.
+ * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
+ * @param associatedTokenProgramId Associated token program ID.
+ * @param ctokenConfig             Optional c-token-specific configuration.
+ */
+declare function createAssociatedTokenAccountInterfaceInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
+/**
+ * Create idempotent instruction for creating an associated token account (SPL,
+ * Token-2022, or c-token). Follows SPL Token API signature with optional c-token
+ * config at the end.
+ *
+ * @param payer                    Fee payer public key.
+ * @param associatedToken          Associated token account address.
+ * @param owner                    Owner of the associated token account.
+ * @param mint                     Mint address.
+ * @param programId                Token program ID (default: TOKEN_PROGRAM_ID).
+ * @param associatedTokenProgramId Associated token program ID.
+ * @param ctokenConfig             Optional c-token-specific configuration.
+ */
+declare function createAssociatedTokenAccountInterfaceIdempotentInstruction(payer: PublicKey, associatedToken: PublicKey, owner: PublicKey, mint: PublicKey, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): TransactionInstruction;
+/**
+ * Short alias for createAssociatedTokenAccountInterfaceIdempotentInstruction.
+ */
+declare const createAtaInterfaceIdempotentInstruction: typeof createAssociatedTokenAccountInterfaceIdempotentInstruction;
+
+/**
+ * Create instruction for minting compressed tokens to an onchain token account.
+ *
+ * @param authority           Mint authority public key.
+ * @param payer               Fee payer public key.
+ * @param validityProof       Validity proof for the compressed mint.
+ * @param merkleContext       Merkle context of the compressed mint.
+ * @param mintData            Mint instruction data.
+ * @param outputStateTreeInfo Output state tree info.
+ * @param recipientAccount    Recipient onchain token account address.
+ * @param amount              Amount to mint.
+ */
+declare function createMintToInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, outputStateTreeInfo: TreeInfo, recipientAccount: PublicKey, amount: number | bigint): TransactionInstruction;
+
+/**
+ * Token data version enum - mirrors Rust TokenDataVersion
+ * Used for compressed token account hashing strategy
+ */
+declare enum TokenDataVersion {
+    /** V1: Poseidon hash with little-endian amount, discriminator [2,0,0,0,0,0,0,0] */
+    V1 = 1,
+    /** V2: Poseidon hash with big-endian amount, discriminator [0,0,0,0,0,0,0,3] */
+    V2 = 2,
+    /** ShaFlat: SHA256 hash of borsh-serialized data, discriminator [0,0,0,0,0,0,0,4] */
+    ShaFlat = 3
+}
+declare const POOL_SEED: Buffer$1<ArrayBuffer>;
+declare const CPI_AUTHORITY_SEED: Buffer$1<ArrayBuffer>;
+declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
+declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const MINT_TO_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const TRANSFER_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const APPROVE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const REVOKE_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+declare const DECOMPRESS_ACCOUNTS_IDEMPOTENT_DISCRIMINATOR: Buffer$1<ArrayBuffer>;
+
+/**
+ * Create instruction for minting tokens from a c-mint to compressed accounts.
+ * To mint to onchain token accounts across SPL/T22/c-mints, use
+ * {@link createMintToInterfaceInstruction} instead.
+ *
+ * @param authority             Mint authority public key.
+ * @param payer                 Fee payer public key.
+ * @param validityProof         Validity proof for the compressed mint.
+ * @param merkleContext         Merkle context of the compressed mint.
+ * @param mintData              Mint instruction data.
+ * @param recipients            Array of recipients with amounts.
+ * @param outputStateTreeInfo   Optional output state tree info. Uses merkle
+ * context queue if not provided.
+ * @param tokenAccountVersion   Token account version (default:
+ * TokenDataVersion.ShaFlat).
+ */
+declare function createMintToCompressedInstruction(authority: PublicKey, payer: PublicKey, validityProof: ValidityProofWithContext, merkleContext: MerkleContext, mintData: MintInstructionData, recipients: Array<{
+    recipient: PublicKey;
+    amount: number | bigint;
+}>, outputStateTreeInfo?: TreeInfo, tokenAccountVersion?: TokenDataVersion): TransactionInstruction;
+
+/**
+ * Create mint-to instruction for SPL, Token-2022, or compressed token mints.
+ * This instruction ONLY mints to decompressed/onchain token accounts.
+ *
+ * @param mintInterface   Mint interface (SPL, Token-2022, or compressed).
+ * @param destination     Destination onchain token account address.
+ * @param authority       Mint authority public key.
+ * @param payer           Fee payer public key.
+ * @param amount          Amount to mint.
+ * @param validityProof   Validity proof (required for compressed mints).
+ * @param multiSigners    Multi-signature signer public keys.
+ */
+declare function createMintToInterfaceInstruction(mintInterface: MintInterface, destination: PublicKey, authority: PublicKey, payer: PublicKey, amount: number | bigint, validityProof?: ValidityProofWithContext, multiSigners?: PublicKey[]): TransactionInstruction;
+
+/**
+ * Create a c-token transfer instruction.
+ *
+ * @param source        Source c-token account
+ * @param destination   Destination c-token account
+ * @param owner         Owner of the source account (signer, also pays for compressible extension top-ups)
+ * @param amount        Amount to transfer
+ * @returns Transaction instruction for c-token transfer
+ */
+declare function createCTokenTransferInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint): TransactionInstruction;
+/**
+ * Construct a transfer instruction for SPL/T22/c-token. Defaults to c-token
+ * program. For cross-program transfers (SPL <> c-token), use `wrap`/`unwrap`.
+ *
+ * @param source        Source token account
+ * @param destination   Destination token account
+ * @param owner         Owner of the source account (signer)
+ * @param amount        Amount to transfer
+ * @returns instruction for c-token transfer
+ */
+declare function createTransferInterfaceInstruction(source: PublicKey, destination: PublicKey, owner: PublicKey, amount: number | bigint, multiSigners?: (Signer | PublicKey)[], programId?: PublicKey): TransactionInstruction;
+
+declare namespace BN {
+    type Endianness = "le" | "be";
+    type IPrimeName = "k256" | "p224" | "p192" | "p25519";
+
+    interface MPrime {
+        name: string;
+        p: BN;
+        n: number;
+        k: BN;
+    }
+
+    interface ReductionContext {
+        m: number;
+        prime: MPrime;
+        [key: string]: any;
+    }
+}
+
+declare class BN {
+    static BN: typeof BN;
+    static wordSize: 26;
+
+    constructor(
+        number: bigint | number | string | number[] | Uint8Array | Buffer | BN,
+        base?: number | "hex",
+        endian?: BN.Endianness,
+    );
+    constructor(
+        number: bigint | number | string | number[] | Uint8Array | Buffer | BN,
+        endian?: BN.Endianness,
+    );
+
+    /**
+     * @description  create a reduction context
+     */
+    static red(reductionContext: BN | BN.IPrimeName): BN.ReductionContext;
+
+    /**
+     * @description  create a reduction context  with the Montgomery trick.
+     */
+    static mont(num: BN): BN.ReductionContext;
+
+    /**
+     * @description returns true if the supplied object is a BN.js instance
+     */
+    static isBN(b: any): b is BN;
+
+    /**
+     * @description returns the maximum of 2 BN instances.
+     */
+    static max(left: BN, right: BN): BN;
+
+    /**
+     * @description returns the minimum of 2 BN instances.
+     */
+    static min(left: BN, right: BN): BN;
+
+    /**
+     * @description  Copy to dest number
+     */
+    copy(dest: BN): void;
+
+    /**
+     * @description  clone number
+     */
+    clone(): BN;
+
+    /**
+     * @description  convert to base-string and pad with zeroes
+     */
+    toString(base?: number | "hex", length?: number): string;
+
+    /**
+     * @description convert to Javascript Number (limited to 53 bits)
+     */
+    toNumber(): number;
+
+    /**
+     * @description convert to JSON compatible hex string (alias of toString(16))
+     */
+    toJSON(): string;
+
+    /**
+     * @description  convert to byte Array, and optionally zero pad to length, throwing if already exceeding
+     */
+    toArray(endian?: BN.Endianness, length?: number): number[];
+
+    /**
+     * @description convert to an instance of `type`, which must behave like an Array
+     */
+    toArrayLike(
+        ArrayType: typeof Buffer,
+        endian?: BN.Endianness,
+        length?: number,
+    ): Buffer;
+
+    toArrayLike(
+        ArrayType: any[],
+        endian?: BN.Endianness,
+        length?: number,
+    ): any[];
+
+    /**
+     * @description  convert to Node.js Buffer (if available). For compatibility with browserify and similar tools, use this instead: a.toArrayLike(Buffer, endian, length)
+     */
+    toBuffer(endian?: BN.Endianness, length?: number): Buffer;
+
+    /**
+     * @description get number of bits occupied
+     */
+    bitLength(): number;
+
+    /**
+     * @description return number of less-significant consequent zero bits (example: 1010000 has 4 zero bits)
+     */
+    zeroBits(): number;
+
+    /**
+     * @description return number of bytes occupied
+     */
+    byteLength(): number;
+
+    /**
+     * @description  true if the number is negative
+     */
+    isNeg(): boolean;
+
+    /**
+     * @description  check if value is even
+     */
+    isEven(): boolean;
+
+    /**
+     * @description   check if value is odd
+     */
+    isOdd(): boolean;
+
+    /**
+     * @description  check if value is zero
+     */
+    isZero(): boolean;
+
+    /**
+     * @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
+     */
+    cmp(b: BN): -1 | 0 | 1;
+
+    /**
+     * @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
+     */
+    ucmp(b: BN): -1 | 0 | 1;
+
+    /**
+     * @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
+     */
+    cmpn(b: number): -1 | 0 | 1;
+
+    /**
+     * @description a less than b
+     */
+    lt(b: BN): boolean;
+
+    /**
+     * @description a less than b
+     */
+    ltn(b: number): boolean;
+
+    /**
+     * @description a less than or equals b
+     */
+    lte(b: BN): boolean;
+
+    /**
+     * @description a less than or equals b
+     */
+    lten(b: number): boolean;
+
+    /**
+     * @description a greater than b
+     */
+    gt(b: BN): boolean;
+
+    /**
+     * @description a greater than b
+     */
+    gtn(b: number): boolean;
+
+    /**
+     * @description a greater than or equals b
+     */
+    gte(b: BN): boolean;
+
+    /**
+     * @description a greater than or equals b
+     */
+    gten(b: number): boolean;
+
+    /**
+     * @description a equals b
+     */
+    eq(b: BN): boolean;
+
+    /**
+     * @description a equals b
+     */
+    eqn(b: number): boolean;
+
+    /**
+     * @description convert to two's complement representation, where width is bit width
+     */
+    toTwos(width: number): BN;
+
+    /**
+     * @description  convert from two's complement representation, where width is the bit width
+     */
+    fromTwos(width: number): BN;
+
+    /**
+     * @description negate sign
+     */
+    neg(): BN;
+
+    /**
+     * @description negate sign
+     */
+    ineg(): BN;
+
+    /**
+     * @description absolute value
+     */
+    abs(): BN;
+
+    /**
+     * @description absolute value
+     */
+    iabs(): BN;
+
+    /**
+     * @description addition
+     */
+    add(b: BN): BN;
+
+    /**
+     * @description  addition
+     */
+    iadd(b: BN): BN;
+
+    /**
+     * @description addition
+     */
+    addn(b: number): BN;
+
+    /**
+     * @description addition
+     */
+    iaddn(b: number): BN;
+
+    /**
+     * @description subtraction
+     */
+    sub(b: BN): BN;
+
+    /**
+     * @description subtraction
+     */
+    isub(b: BN): BN;
+
+    /**
+     * @description subtraction
+     */
+    subn(b: number): BN;
+
+    /**
+     * @description subtraction
+     */
+    isubn(b: number): BN;
+
+    /**
+     * @description multiply
+     */
+    mul(b: BN): BN;
+
+    /**
+     * @description multiply
+     */
+    imul(b: BN): BN;
+
+    /**
+     * @description multiply
+     */
+    muln(b: number): BN;
+
+    /**
+     * @description multiply
+     */
+    imuln(b: number): BN;
+
+    /**
+     * @description square
+     */
+    sqr(): BN;
+
+    /**
+     * @description square
+     */
+    isqr(): BN;
+
+    /**
+     * @description raise `a` to the power of `b`
+     */
+    pow(b: BN): BN;
+
+    /**
+     * @description divide
+     */
+    div(b: BN): BN;
+
+    /**
+     * @description divide
+     */
+    divn(b: number): BN;
+
+    /**
+     * @description divide
+     */
+    idivn(b: number): BN;
+
+    /**
+     * @description division with remainder
+     */
+    divmod(b: BN, mode?: "div" | "mod", positive?: boolean): { div: BN; mod: BN };
+
+    /**
+     * @description reduct
+     */
+    mod(b: BN): BN;
+
+    /**
+     * @description reduct
+     */
+    umod(b: BN): BN;
+
+    /**
+     * @deprecated
+     * @description reduct
+     */
+    modn(b: number): number;
+
+    /**
+     * @description reduct
+     */
+    modrn(b: number): number;
+
+    /**
+     * @description  rounded division
+     */
+    divRound(b: BN): BN;
+
+    /**
+     * @description or
+     */
+    or(b: BN): BN;
+
+    /**
+     * @description or
+     */
+    ior(b: BN): BN;
+
+    /**
+     * @description or
+     */
+    uor(b: BN): BN;
+
+    /**
+     * @description or
+     */
+    iuor(b: BN): BN;
+
+    /**
+     * @description and
+     */
+    and(b: BN): BN;
+
+    /**
+     * @description and
+     */
+    iand(b: BN): BN;
+
+    /**
+     * @description and
+     */
+    uand(b: BN): BN;
+
+    /**
+     * @description and
+     */
+    iuand(b: BN): BN;
+
+    /**
+     * @description and (NOTE: `andln` is going to be replaced with `andn` in future)
+     */
+    andln(b: number): BN;
+
+    /**
+     * @description xor
+     */
+    xor(b: BN): BN;
+
+    /**
+     * @description xor
+     */
+    ixor(b: BN): BN;
+
+    /**
+     * @description xor
+     */
+    uxor(b: BN): BN;
+
+    /**
+     * @description xor
+     */
+    iuxor(b: BN): BN;
+
+    /**
+     * @description set specified bit to value
+     */
+    setn(b: number, value: boolean | 0 | 1): BN;
+
+    /**
+     * @description shift left
+     */
+    shln(b: number): BN;
+
+    /**
+     * @description shift left
+     */
+    ishln(b: number): BN;
+
+    /**
+     * @description shift left
+     */
+    ushln(b: number): BN;
+
+    /**
+     * @description shift left
+     */
+    iushln(b: number): BN;
+
+    /**
+     * @description shift right
+     */
+    shrn(b: number): BN;
+
+    /**
+     * @description shift right (unimplemented https://github.com/indutny/bn.js/blob/master/lib/bn.js#L2086)
+     */
+    ishrn(b: number): BN;
+
+    /**
+     * @description shift right
+     */
+    ushrn(b: number): BN;
+    /**
+     * @description shift right
+     */
+
+    iushrn(b: number): BN;
+    /**
+     * @description  test if specified bit is set
+     */
+
+    testn(b: number): boolean;
+    /**
+     * @description clear bits with indexes higher or equal to `b`
+     */
+
+    maskn(b: number): BN;
+    /**
+     * @description clear bits with indexes higher or equal to `b`
+     */
+
+    imaskn(b: number): BN;
+    /**
+     * @description add `1 << b` to the number
+     */
+    bincn(b: number): BN;
+
+    /**
+     * @description not (for the width specified by `w`)
+     */
+    notn(w: number): BN;
+
+    /**
+     * @description not (for the width specified by `w`)
+     */
+    inotn(w: number): BN;
+
+    /**
+     * @description GCD
+     */
+    gcd(b: BN): BN;
+
+    /**
+     * @description Extended GCD results `({ a: ..., b: ..., gcd: ... })`
+     */
+    egcd(b: BN): { a: BN; b: BN; gcd: BN };
+
+    /**
+     * @description inverse `a` modulo `b`
+     */
+    invm(b: BN): BN;
+
+    /**
+     * @description Convert number to red
+     */
+    toRed(reductionContext: BN.ReductionContext): RedBN;
+}
+
+/**
+ * BN operations in a reduction context.
+ */
+declare class RedBN extends BN {
+    /**
+     * @description Convert back a number using a reduction context
+     */
+    fromRed(): BN;
+
+    /**
+     * @description modular addition
+     */
+    redAdd(b: RedBN): RedBN;
+
+    /**
+     * @description in-place modular addition
+     */
+    redIAdd(b: RedBN): RedBN;
+
+    /**
+     * @description modular subtraction
+     */
+    redSub(b: RedBN): RedBN;
+
+    /**
+     * @description in-place modular subtraction
+     */
+    redISub(b: RedBN): RedBN;
+
+    /**
+     * @description modular shift left
+     */
+    redShl(num: number): RedBN;
+
+    /**
+     * @description modular multiplication
+     */
+    redMul(b: RedBN): RedBN;
+
+    /**
+     * @description in-place modular multiplication
+     */
+    redIMul(b: RedBN): RedBN;
+
+    /**
+     * @description modular square
+     */
+    redSqr(): RedBN;
+
+    /**
+     * @description in-place modular square
+     */
+    redISqr(): RedBN;
+
+    /**
+     * @description modular square root
+     */
+    redSqrt(): RedBN;
+
+    /**
+     * @description modular inverse of the number
+     */
+    redInvm(): RedBN;
+
+    /**
+     * @description modular negation
+     */
+    redNeg(): RedBN;
+
+    /**
+     * @description modular exponentiation
+     */
+    redPow(b: BN): RedBN;
+}
+
+/**
+ * SPL interface PDA info.
+ */
+type SplInterfaceInfo = {
+    /**
+     * The mint of the SPL interface
+     */
+    mint: PublicKey;
+    /**
+     * The SPL interface address
+     */
+    splInterfacePda: PublicKey;
+    /**
+     * The token program of the SPL interface
+     */
+    tokenProgram: PublicKey;
+    /**
+     * count of txs and volume in the past 60 seconds.
+     */
+    activity?: {
+        txs: number;
+        amountAdded: BN;
+        amountRemoved: BN;
+    };
+    /**
+     * Whether the SPL interface is initialized
+     */
+    isInitialized: boolean;
+    /**
+     * The balance of the SPL interface
+     */
+    balance: BN;
+    /**
+     * The index of the SPL interface
+     */
+    poolIndex: number;
+    /**
+     * The bump used to derive the SPL interface PDA
+     */
+    bump: number;
 };
 /**
- * Token pool pda info.
+ * @deprecated Use {@link SplInterfaceInfo} instead.
+ * This type maintains backward compatibility by including both tokenPoolPda and splInterfacePda.
+ * Both properties point to the same PublicKey value.
  */
 type TokenPoolInfo = {
     /**
-     * The mint of the token pool
+     * The mint of the SPL interface
      */
     mint: PublicKey;
     /**
-     * The token pool address
+     * @deprecated Use splInterfacePda instead.
      */
     tokenPoolPda: PublicKey;
     /**
-     * The token program of the token pool
+     * The SPL interface address (new name).
+     * For backward compatibility, tokenPoolPda is also available.
+     */
+    splInterfacePda: PublicKey;
+    /**
+     * The token program of the SPL interface
      */
     tokenProgram: PublicKey;
     /**
@@ -65,22 +1444,60 @@ type TokenPoolInfo = {
         amountRemoved: BN;
     };
     /**
-     * Whether the token pool is initialized
+     * Whether the SPL interface is initialized
      */
     isInitialized: boolean;
     /**
-     * The balance of the token pool
+     * The balance of the SPL interface
      */
     balance: BN;
     /**
-     * The index of the token pool
+     * The index of the SPL interface
      */
     poolIndex: number;
     /**
-     * The bump used to derive the token pool pda
+     * The bump used to derive the SPL interface PDA
      */
     bump: number;
 };
+/**
+ * Convert SplInterfaceInfo to TokenPoolInfo for backward compatibility.
+ * @internal
+ */
+declare function toTokenPoolInfo(info: SplInterfaceInfo): TokenPoolInfo;
+/**
+ * Derive SplInterfaceInfo for an SPL interface that will be initialized in the
+ * same transaction. Use this when you need to create an SPL interface and
+ * compress in a single transaction.
+ *
+ * @param mint           The mint of the SPL interface
+ * @param tokenProgramId The token program (TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID)
+ * @param poolIndex      The pool index. Default 0.
+ *
+ * @returns SplInterfaceInfo for the to-be-initialized interface
+ */
+declare function deriveSplInterfaceInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): SplInterfaceInfo;
+/**
+ * Check if the SPL interface info is initialized and has a balance.
+ * @param mint The mint of the SPL interface
+ * @param splInterfaceInfo The SPL interface info (or TokenPoolInfo for backward compatibility)
+ * @returns True if the SPL interface info is initialized and has a balance
+ */
+declare function checkSplInterfaceInfo(splInterfaceInfo: SplInterfaceInfo | TokenPoolInfo, mint: PublicKey): boolean;
+/**
+ * Get the SPL interface infos for a given mint.
+ * @param rpc         The RPC client
+ * @param mint        The mint of the SPL interface
+ * @param commitment  The commitment to use
+ *
+ * @returns The SPL interface infos
+ */
+declare function getSplInterfaceInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<SplInterfaceInfo[]>;
+type SplInterfaceActivity = {
+    signature: string;
+    amount: BN;
+    action: Action;
+};
 /**
  * @internal
  */
@@ -91,29 +1508,656 @@ declare enum Action {
 }
 /**
  * For `compress` and `mintTo` instructions only.
- * Select a random token pool info from the token pool infos.
+ * Select a random SPL interface info from the SPL interface infos.
  *
- * For `decompress`, use {@link selectTokenPoolInfosForDecompression} instead.
+ * For `decompress`, use {@link selectSplInterfaceInfosForDecompression} instead.
  *
- * @param infos The token pool infos
+ * @param infos The SPL interface infos
  *
- * @returns A random token pool info
+ * @returns A random SPL interface info
  */
-declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+declare function selectSplInterfaceInfo(infos: SplInterfaceInfo[]): SplInterfaceInfo;
 /**
- * Select one or multiple token pool infos from the token pool infos.
+ * Select one or multiple SPL interface infos from the SPL interface infos.
  *
  * Use this function for `decompress`.
  *
- * For `compress`, `mintTo` use {@link selectTokenPoolInfo} instead.
+ * For `compress`, `mintTo` use {@link selectSplInterfaceInfo} instead.
  *
- * @param infos             The token pool infos
+ * @param infos             The SPL interface infos
  * @param decompressAmount  The amount of tokens to withdraw
  *
- * @returns Array with one or more token pool infos.
+ * @returns Array with one or more SPL interface infos.
+ */
+declare function selectSplInterfaceInfosForDecompression(infos: SplInterfaceInfo[], decompressAmount: number | BN): SplInterfaceInfo[];
+/**
+ * @deprecated Use {@link SplInterfaceActivity} instead.
+ */
+type TokenPoolActivity = SplInterfaceActivity;
+/**
+ * @deprecated Use {@link deriveSplInterfaceInfo} instead.
+ */
+declare function deriveTokenPoolInfo(mint: PublicKey, tokenProgramId: PublicKey, poolIndex?: number): TokenPoolInfo;
+/**
+ * @deprecated Use {@link checkSplInterfaceInfo} instead.
+ */
+declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
+/**
+ * @deprecated Use {@link getSplInterfaceInfos} instead.
+ */
+declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
+/**
+ * @deprecated Use {@link selectSplInterfaceInfo} instead.
+ */
+declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+/**
+ * @deprecated Use {@link selectSplInterfaceInfosForDecompression} instead.
  */
 declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
 
+/**
+ * Create decompressInterface instruction using Transfer2.
+ *
+ * Supports decompressing to both c-token accounts and SPL token accounts:
+ * - For c-token destinations: No splInterfaceInfo needed
+ * - For SPL destinations: Provide splInterfaceInfo (token pool info)
+ *
+ * @param payer                        Fee payer public key
+ * @param inputCompressedTokenAccounts Input compressed token accounts
+ * @param toAddress                    Destination token account address (c-token or SPL ATA)
+ * @param amount                       Amount to decompress
+ * @param validityProof                Validity proof (contains compressedProof and rootIndices)
+ * @param splInterfaceInfo             Optional: SPL interface info for SPL destinations
+ * @returns TransactionInstruction
+ */
+declare function createDecompressInterfaceInstruction(payer: PublicKey, inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: bigint, validityProof: ValidityProofWithContext, splInterfaceInfo?: SplInterfaceInfo): TransactionInstruction;
+
+declare const TokenAccountSourceType: {
+    readonly Spl: "spl";
+    readonly Token2022: "token2022";
+    readonly SplCold: "spl-cold";
+    readonly Token2022Cold: "token2022-cold";
+    readonly CTokenHot: "ctoken-hot";
+    readonly CTokenCold: "ctoken-cold";
+};
+type TokenAccountSourceTypeValue = (typeof TokenAccountSourceType)[keyof typeof TokenAccountSourceType];
+/** @internal */
+interface TokenAccountSource {
+    type: TokenAccountSourceTypeValue;
+    address: PublicKey;
+    amount: bigint;
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext?: MerkleContext;
+    parsed: Account;
+}
+interface AccountInterface {
+    accountInfo: AccountInfo<Buffer$1>;
+    parsed: Account;
+    isCold: boolean;
+    loadContext?: MerkleContext;
+    _sources?: TokenAccountSource[];
+    _needsConsolidation?: boolean;
+    _hasDelegate?: boolean;
+    _anyFrozen?: boolean;
+    /** True when fetched via getAtaInterface */
+    _isAta?: boolean;
+    /** ATA owner - set by getAtaInterface */
+    _owner?: PublicKey;
+    /** ATA mint - set by getAtaInterface */
+    _mint?: PublicKey;
+}
+/** @internal */
+declare function convertTokenDataToAccount(address: PublicKey, tokenData: {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: number;
+    tlv: Buffer$1 | null;
+}): Account;
+/** Convert compressed account to AccountInfo */
+declare function toAccountInfo(compressedAccount: CompressedAccountWithMerkleContext): AccountInfo<Buffer$1>;
+/** @internal */
+declare function parseCTokenHot(address: PublicKey, accountInfo: AccountInfo<Buffer$1>): {
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext: undefined;
+    parsed: Account;
+    isCold: false;
+};
+/** @internal */
+declare function parseCTokenCold(address: PublicKey, compressedAccount: CompressedAccountWithMerkleContext): {
+    accountInfo: AccountInfo<Buffer$1>;
+    loadContext: MerkleContext;
+    parsed: Account;
+    isCold: true;
+};
+/**
+ * Retrieve information about a token account of SPL/T22/c-token.
+ *
+ * @param rpc        RPC connection to use
+ * @param address    Token account address
+ * @param commitment Desired level of commitment for querying the state
+ * @param programId  Token program ID. If not provided, tries all programs concurrently.
+ *
+ * @return Token account information with compression context if applicable
+ */
+declare function getAccountInterface(rpc: Rpc, address: PublicKey, commitment?: Commitment, programId?: PublicKey): Promise<AccountInterface>;
+
+/**
+ * Options for interface operations (load, transfer)
+ */
+interface InterfaceOptions {
+    /** SPL interface infos (fetched if not provided) */
+    splInterfaceInfos?: SplInterfaceInfo[];
+}
+/**
+ * Transfer tokens using the c-token interface.
+ *
+ * Matches SPL Token's transferChecked signature order. Destination must exist.
+ *
+ * @param rpc             RPC connection
+ * @param payer           Fee payer (signer)
+ * @param source          Source c-token ATA address
+ * @param mint            Mint address
+ * @param destination     Destination c-token ATA address (must exist)
+ * @param owner           Source owner (signer)
+ * @param amount          Amount to transfer
+ * @param programId       Token program ID (default: CTOKEN_PROGRAM_ID)
+ * @param confirmOptions  Optional confirm options
+ * @param options         Optional interface options
+ * @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>;
+
+/**
+ * Account info interface for compressible accounts.
+ * Matches return structure of getAccountInterface/getAtaInterface.
+ *
+ * Integrating programs provide their own fetch/parse - this is just the data shape.
+ */
+interface ParsedAccountInfoInterface<T = unknown> {
+    /** Parsed account data (program-specific) */
+    parsed: T;
+    /** Load context - present if account is compressed (cold), undefined if hot */
+    loadContext?: MerkleContext;
+}
+/**
+ * Input for createLoadAccountsParams.
+ * Supports both program PDAs and c-token vaults.
+ *
+ * The integrating program is responsible for fetching and parsing their accounts.
+ * This helper just packs them for the decompressAccountsIdempotent instruction.
+ */
+interface CompressibleAccountInput<T = unknown> {
+    /** Account address */
+    address: PublicKey;
+    /**
+     * Account type key for packing:
+     * - For PDAs: program-specific type name (e.g., "poolState", "observationState")
+     * - For c-token vaults: "cTokenData"
+     */
+    accountType: string;
+    /**
+     * Token variant - required when accountType is "cTokenData".
+     * Examples: "lpVault", "token0Vault", "token1Vault"
+     */
+    tokenVariant?: string;
+    /** Parsed account info (from program-specific fetch) */
+    info: ParsedAccountInfoInterface<T>;
+}
+/**
+ * Packed compressed account for decompressAccountsIdempotent instruction
+ */
+interface PackedCompressedAccount {
+    [key: string]: unknown;
+    merkleContext: {
+        merkleTreePubkeyIndex: number;
+        queuePubkeyIndex: number;
+    };
+}
+/**
+ * Result from building load params
+ */
+interface CompressibleLoadParams {
+    /** Validity proof wrapped in option (null if all proveByIndex) */
+    proofOption: {
+        0: ValidityProof | null;
+    };
+    /** Packed compressed accounts data for instruction */
+    compressedAccounts: PackedCompressedAccount[];
+    /** Offset to system accounts in remainingAccounts */
+    systemAccountsOffset: number;
+    /** Account metas for remaining accounts */
+    remainingAccounts: AccountMeta[];
+}
+/**
+ * Result from createLoadAccountsParams
+ */
+interface LoadResult {
+    /** Params for decompressAccountsIdempotent (null if no program accounts need decompressing) */
+    decompressParams: CompressibleLoadParams | null;
+    /** Instructions to load ATAs (create ATA, wrap SPL/T22, decompressInterface) */
+    ataInstructions: TransactionInstruction[];
+}
+/**
+ * Create params for loading program accounts and ATAs.
+ *
+ * Returns:
+ * - decompressParams: for a caller program's standardized
+ *   decompressAccountsIdempotent instruction
+ * - ataInstructions: for loading user ATAs
+ *
+ * @param rpc              RPC connection
+ * @param payer            Fee payer (needed for ATA instructions)
+ * @param programId        Program ID for decompressAccountsIdempotent
+ * @param programAccounts  PDAs and vaults (caller pre-fetches)
+ * @param atas             User ATAs (fetched via getAtaInterface)
+ * @param options          Optional load options
+ * @returns                LoadResult with decompressParams and ataInstructions
+ *
+ * @example
+ * ```typescript
+ * const poolInfo = await myProgram.fetchPoolState(rpc, poolAddress);
+ * const vault0Ata = getAssociatedTokenAddressInterface(token0Mint, poolAddress);
+ * const vault0Info = await getAtaInterface(rpc, vault0Ata, poolAddress, token0Mint, undefined, CTOKEN_PROGRAM_ID);
+ * const userAta = getAssociatedTokenAddressInterface(tokenMint, userWallet);
+ * const userAtaInfo = await getAtaInterface(rpc, userAta, userWallet, tokenMint);
+ *
+ * const result = await createLoadAccountsParams(
+ *     rpc,
+ *     payer.publicKey,
+ *     programId,
+ *     [
+ *         { address: poolAddress, accountType: 'poolState', info: poolInfo },
+ *         { address: vault0, accountType: 'cTokenData', tokenVariant: 'token0Vault', info: vault0Info },
+ *     ],
+ *     [userAta],
+ * );
+ *
+ * // Build transaction with both program decompress and ATA load
+ * const instructions = [...result.ataInstructions];
+ * if (result.decompressParams) {
+ *     instructions.push(await program.methods
+ *         .decompressAccountsIdempotent(
+ *             result.decompressParams.proofOption,
+ *             result.decompressParams.compressedAccounts,
+ *             result.decompressParams.systemAccountsOffset,
+ *         )
+ *         .remainingAccounts(result.decompressParams.remainingAccounts)
+ *         .instruction());
+ * }
+ * ```
+ */
+declare function createLoadAccountsParams(rpc: Rpc, payer: PublicKey, programId: PublicKey, programAccounts?: CompressibleAccountInput[], atas?: AccountInterface[], options?: InterfaceOptions): Promise<LoadResult>;
+/**
+ * Calculate compute units for compressible load operation
+ */
+declare function calculateCompressibleLoadComputeUnits(compressedAccountCount: number, hasValidityProof: boolean): number;
+
+/**
+ * Create a wrap instruction that moves tokens from an SPL/T22 account to a
+ * c-token account.
+ *
+ * @param source            Source SPL/T22 token account
+ * @param destination       Destination c-token account
+ * @param owner             Owner of the source account (signer)
+ * @param mint              Mint address
+ * @param amount            Amount to wrap,
+ * @param splInterfaceInfo  SPL interface info for the compression
+ * @param 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, payer?: PublicKey): TransactionInstruction;
+
+/**
+ * Create and initialize a new mint for SPL/T22/c-token.
+ *
+ * @param rpc                   RPC connection to use
+ * @param payer                 Fee payer
+ * @param mintAuthority         Account that will control minting (signer for c-token mints)
+ * @param freezeAuthority       Account that will control freeze and thaw (optional)
+ * @param decimals              Location of the decimal place
+ * @param keypair               Mint keypair (defaults to a random keypair)
+ * @param confirmOptions        Confirm options
+ * @param programId             Token program ID (defaults to CTOKEN_PROGRAM_ID)
+ * @param tokenMetadata         Optional token metadata (c-token mints only)
+ * @param outputStateTreeInfo   Optional output state tree info (c-token mints only)
+ * @param addressTreeInfo       Optional address tree info (c-token mints only)
+ *
+ * @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<{
+    mint: PublicKey;
+    transactionSignature: TransactionSignature;
+}>;
+
+/**
+ * Update the mint authority of a compressed token mint.
+ *
+ * @param rpc                    RPC connection
+ * @param payer                  Fee payer (signer)
+ * @param mint                   Mint address
+ * @param currentMintAuthority   Current mint authority (signer)
+ * @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>;
+/**
+ * Update the freeze authority of a compressed token mint.
+ *
+ * @param rpc                      RPC connection
+ * @param payer                    Fee payer (signer)
+ * @param mint                     Mint address
+ * @param currentFreezeAuthority   Current freeze authority (signer)
+ * @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>;
+
+/**
+ * Update a metadata field on a compressed token mint.
+ *
+ * @param rpc            RPC connection
+ * @param payer          Fee payer (signer)
+ * @param mint           Mint address
+ * @param authority      Metadata update authority (signer)
+ * @param fieldType      Field to update: 'name', 'symbol', 'uri', or 'custom'
+ * @param value          New value for the field
+ * @param customKey      Custom key name (required if fieldType is 'custom')
+ * @param extensionIndex Extension index (default: 0)
+ * @param confirmOptions Optional confirm options
+ */
+declare function updateMetadataField(rpc: Rpc, payer: Signer, mint: PublicKey, authority: Signer, fieldType: 'name' | 'symbol' | 'uri' | 'custom', value: string, customKey?: string, extensionIndex?: number, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/**
+ * Update the metadata authority of a compressed token mint.
+ *
+ * @param rpc              RPC connection
+ * @param payer            Fee payer (signer)
+ * @param mint             Mint address
+ * @param currentAuthority Current metadata update authority (signer)
+ * @param newAuthority     New metadata update authority
+ * @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>;
+/**
+ * Remove a metadata key from a compressed token mint.
+ *
+ * @param rpc            RPC connection
+ * @param payer          Fee payer (signer)
+ * @param mint           Mint address
+ * @param authority      Metadata update authority (signer)
+ * @param key            Metadata key to remove
+ * @param idempotent     If true, don't error if key doesn't exist (default: false)
+ * @param extensionIndex Extension index (default: 0)
+ * @param 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>;
+
+/**
+ * Create an associated token account for SPL/T22/c-token. Defaults to c-token
+ * program.
+ *
+ * @param rpc                       RPC connection
+ * @param payer                     Fee payer and transaction signer
+ * @param mint                      Mint address
+ * @param owner                     Owner of the associated token account
+ * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
+ * @param confirmOptions            Options for confirming the transaction
+ * @param programId                 Token program ID (default:
+ *                                  CTOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  ATA program ID (auto-derived if not
+ *                                  provided)
+ * @param ctokenConfig              Optional rent config
+ * @returns Address of the new associated token account
+ */
+declare function createAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey, ctokenConfig?: CTokenConfig): Promise<PublicKey>;
+/**
+ * Create an associated token account idempotently for SPL/T22/c-token. Defaults
+ * to c-token program.
+ *
+ * If the account already exists, the instruction succeeds without error.
+ *
+ * @param rpc                       RPC connection
+ * @param payer                     Fee payer and transaction signer
+ * @param mint                      Mint address
+ * @param owner                     Owner of the associated token account
+ * @param allowOwnerOffCurve        Allow owner to be a PDA (default: false)
+ * @param confirmOptions            Options for confirming the transaction
+ * @param programId                 Token program ID (default:
+ *                                  CTOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  ATA program ID (auto-derived if not
+ *                                  provided)
+ * @param ctokenConfig              Optional c-token-specific configuration
+ *
+ * @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>;
+
+/**
+ * Mint compressed tokens directly to compressed accounts.
+ *
+ * @param rpc                   RPC connection
+ * @param payer                 Fee payer
+ * @param mint                  Mint address
+ * @param authority             Mint authority (must sign)
+ * @param recipients            Array of recipients with amounts
+ * @param outputStateTreeInfo   Optional output state tree info (auto-fetched if not provided)
+ * @param tokenAccountVersion   Token account version (default: 3)
+ * @param 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>;
+
+/**
+ * Mint tokens to a decompressed/onchain token account.
+ * Works with SPL, Token-2022, and compressed token (c-token) mints.
+ *
+ * This function ONLY mints to decompressed onchain token accounts, never to compressed accounts.
+ * The signature matches the standard SPL mintTo for simplicity and consistency.
+ *
+ * @param rpc - RPC connection to use
+ * @param payer - Transaction fee payer
+ * @param mint - Mint address (SPL, Token-2022, or compressed mint)
+ * @param destination - Destination token account address (must be an existing onchain token account)
+ * @param authority - Mint authority (can be Signer or PublicKey if multiSigners provided)
+ * @param amount - Amount to mint
+ * @param multiSigners - Optional: Multi-signature signers (default: [])
+ * @param confirmOptions - Optional: Transaction confirmation options
+ * @param programId - Optional: Token program ID (TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, or CTOKEN_PROGRAM_ID). If undefined, auto-detects.
+ *
+ * @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>;
+
+/**
+ * Retrieve the associated token account, or create it if it doesn't exist.
+ *
+ * @param rpc                       Connection to use
+ * @param payer                     Payer of the transaction and initialization
+ *                                  fees.
+ * @param mint                      Mint associated with the account to set or
+ *                                  verify.
+ * @param owner                     Owner of the account. Pass Signer to
+ *                                  auto-load cold (compressed) tokens, or
+ *                                  PublicKey for read-only.
+ * @param allowOwnerOffCurve        Allow the owner account to be a PDA (Program
+ *                                  Derived Address).
+ * @param commitment                Desired level of commitment for querying the
+ *                                  state.
+ * @param confirmOptions            Options for confirming the transaction
+ * @param programId                 Token program ID (defaults to
+ *                                  CTOKEN_PROGRAM_ID)
+ * @param associatedTokenProgramId  Associated token program ID (auto-derived if
+ *                                  not provided)
+ *
+ * @returns AccountInterface with aggregated balance and source breakdown
+ */
+declare function getOrCreateAtaInterface(rpc: Rpc, payer: Signer, mint: PublicKey, owner: PublicKey | Signer, allowOwnerOffCurve?: boolean, commitment?: Commitment, confirmOptions?: ConfirmOptions, programId?: PublicKey, associatedTokenProgramId?: PublicKey): Promise<AccountInterface>;
+
+/**
+ * Decompress compressed (cold) tokens to an on-chain token account.
+ *
+ * For unified loading, use {@link loadAta} instead.
+ *
+ * @param rpc                  RPC connection
+ * @param payer                Fee payer (signer)
+ * @param owner                Owner of the compressed tokens (signer)
+ * @param mint                 Mint address
+ * @param amount               Amount to decompress (defaults to all)
+ * @param destinationAta       Destination token account address
+ * @param destinationOwner     Owner of the destination ATA
+ * @param splInterfaceInfo     SPL interface info for SPL/T22 destinations
+ * @param confirmOptions       Confirm options
+ * @returns Transaction signature, null if nothing to load.
+ */
+declare function decompressInterface(rpc: Rpc, payer: Signer, owner: Signer, mint: PublicKey, amount?: number | bigint | BN, destinationAta?: PublicKey, destinationOwner?: PublicKey, splInterfaceInfo?: SplInterfaceInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature | null>;
+
+/**
+ * Wrap tokens from an SPL/T22 account to a c-token account.
+ *
+ * This is an agnostic action that takes explicit account addresses (spl-token style).
+ * Use getAssociatedTokenAddressSync() to derive ATA addresses if needed.
+ *
+ * @param rpc             RPC connection
+ * @param payer           Fee payer
+ * @param source          Source SPL/T22 token account (any token account, not just ATA)
+ * @param destination     Destination c-token account
+ * @param owner           Owner/authority of the source account (must sign)
+ * @param mint            Mint address
+ * @param amount          Amount to wrap
+ * @param splInterfaceInfo Optional: SPL interface info (will be fetched if not provided)
+ * @param confirmOptions  Optional: Confirm options
+ *
+ * @example
+ * const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey, false, TOKEN_PROGRAM_ID);
+ * const ctokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey); // defaults to c-token
+ *
+ * await wrap(
+ *   rpc,
+ *   payer,
+ *   splAta,
+ *   ctokenAta,
+ *   owner,
+ *   mint,
+ *   1000n,
+ * );
+ *
+ * @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>;
+
+/**
+ * Create instructions to load an ATA from its AccountInterface.
+ *
+ * Behavior depends on `wrap` parameter:
+ * - wrap=false (standard): Decompress compressed tokens to the target ATA type
+ *   (SPL ATA via pool, T22 ATA via pool, or c-token ATA direct)
+ * - wrap=true (unified): Wrap SPL/T22 + decompress all to c-token ATA
+ *
+ * @param rpc         RPC connection
+ * @param payer       Fee payer
+ * @param ata         AccountInterface from getAtaInterface (must have _isAta, _owner, _mint)
+ * @param options     Optional load options
+ * @param wrap        Unified mode: wrap SPL/T22 to c-token (default: false)
+ * @param targetAta   Target ATA address (used for type detection in standard mode)
+ * @returns           Array of instructions (empty if nothing to load)
+ */
+declare function createLoadAtaInstructionsFromInterface(rpc: Rpc, payer: PublicKey, ata: AccountInterface, options?: InterfaceOptions, wrap?: boolean, targetAta?: PublicKey): Promise<TransactionInstruction[]>;
+
+/**
+ * Derive the canonical associated token address for any of SPL/T22/c-token.
+ * Defaults to using c-token as the canonical ATA.
+ *
+ * @param mint                      Mint public key
+ * @param owner                     Owner public key
+ * @param allowOwnerOffCurve        Allow owner to be a PDA. Default false.
+ * @param programId                 Token program ID. Default c-token.
+ *
+ * @param associatedTokenProgramId  Associated token program ID. Default
+ *                                  auto-detected.
+ * @returns                         Associated token address.
+ */
+declare function getAssociatedTokenAddressInterface(mint: PublicKey, owner: PublicKey, allowOwnerOffCurve?: boolean, programId?: PublicKey, associatedTokenProgramId?: PublicKey): PublicKey;
+
+/**
+ * Input for creating off-chain metadata JSON.
+ * Compatible with Token-2022 and Metaplex standards.
+ */
+interface OffChainTokenMetadata {
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Optional description */
+    description?: string;
+    /** Optional image URI */
+    image?: string;
+    /** Optional additional metadata key-value pairs */
+    additionalMetadata?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Off-chain JSON format for token metadata.
+ * Standard format compatible with Token-2022 and Metaplex tooling.
+ */
+interface OffChainTokenMetadataJson {
+    name: string;
+    symbol: string;
+    description?: string;
+    image?: string;
+    additionalMetadata?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Format metadata for off-chain storage.
+ *
+ * Returns a plain object ready to be uploaded using any storage provider
+ * (umi uploader, custom IPFS/Arweave/S3 solution, etc.).
+ *
+ * @example
+ * // With umi uploader
+ * import { toOffChainMetadataJson } from '@lightprotocol/compressed-token';
+ * import { irysUploader } from '@metaplex-foundation/umi-uploader-irys';
+ *
+ * const umi = createUmi(connection).use(irysUploader());
+ * const metadataJson = toOffChainMetadataJson({
+ *     name: 'My Token',
+ *     symbol: 'MTK',
+ *     description: 'A compressed token',
+ *     image: 'https://example.com/image.png',
+ * });
+ * const uri = await umi.uploader.uploadJson(metadataJson);
+ *
+ * // Then use uri with createMint
+ * await createMint(rpc, payer, { ...params, uri });
+ */
+declare function toOffChainMetadataJson(meta: OffChainTokenMetadata): OffChainTokenMetadataJson;
+
+/**
+ * Approve a delegate to spend tokens
+ *
+ * @param rpc                   Rpc to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to delegate
+ * @param owner                 Owner of the SPL token account.
+ * @param delegate              Address of the delegate
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @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>;
+
 /**
  * Mint compressed tokens to a solana address from an external mint authority
  *
@@ -126,12 +2170,12 @@ declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], de
  * @param outputStateTreeInfo   Optional: State tree account that the compressed
  *                              tokens should be inserted into. Defaults to a
  *                              shared state tree account.
- * @param tokenPoolInfo         Optional: Token pool info.
+ * @param splInterfaceInfo      Optional: SPL interface info.
  * @param confirmOptions        Options for confirming the transaction
  *
  * @return Signature of the confirmed transaction
  */
-declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: TreeInfo, tokenPoolInfo?: TokenPoolInfo, 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
@@ -146,12 +2190,12 @@ declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPu
  * @param outputStateTreeInfo   Optional: State tree account that the compressed
  *                              tokens should be inserted into. Defaults to a
  *                              shared state tree account.
- * @param tokenPoolInfo         Optional: Token pool info.
+ * @param splInterfaceInfo      Optional: SPL interface info.
  * @param confirmOptions        Options for confirming the transaction
  *
  * @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, tokenPoolInfo?: TokenPoolInfo, 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
@@ -165,16 +2209,18 @@ declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: numb
  *                              Default: 0
  * @param outputStateTreeInfo   Optional: State tree account that the compressed
  *                              account into
- * @param tokenPoolInfo         Optional: Token pool info.
+ * @param splInterfaceInfo      Optional: SPL interface info.
  * @param confirmOptions        Options for confirming the transaction
 
  *
  * @return Signature of the confirmed transaction
  */
-declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, tokenAccount: PublicKey, remainingAmount?: BN, outputStateTreeInfo?: TreeInfo, tokenPoolInfo?: TokenPoolInfo, 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 compressed token mint
+ * Create and initialize a new SPL token mint
+ *
+ * @deprecated Use {@link createMintInterface} instead, which supports both SPL and compressed mints.
  *
  * @param rpc               RPC connection to use
  * @param payer             Fee payer
@@ -186,11 +2232,10 @@ declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKe
  * @param tokenProgramId    Optional: Program ID for the token. Defaults to
  *                          TOKEN_PROGRAM_ID.
  * @param freezeAuthority   Optional: Account that will control freeze and thaw.
- *                          Defaults to none.
  *
  * @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): 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;
 }>;
@@ -207,14 +2252,18 @@ declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey |
  *
  * @return transaction signature
  */
-declare function createTokenPool(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>;
 /**
- * Create additional token pools for an existing mint
+ * @deprecated Use {@link createSplInterface} instead.
+ */
+declare const createTokenPool: typeof createSplInterface;
+/**
+ * Create additional SPL interfaces for an existing mint
  *
  * @param rpc                   RPC connection to use
  * @param payer                 Fee payer
  * @param mint                  SPL Mint address
- * @param numMaxAdditionalPools Number of additional token pools to create. Max
+ * @param numMaxAdditionalPools Number of additional SPL interfaces to create. Max
  *                              3.
  * @param confirmOptions        Optional: Options for confirming the transaction
  * @param tokenProgramId        Optional: Address of the token program. Default:
@@ -222,7 +2271,11 @@ declare function createTokenPool(rpc: Rpc, payer: Signer, mint: PublicKey, confi
  *
  * @return transaction signature
  */
-declare function addTokenPools(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.
+ */
+declare const addTokenPools: typeof addSplInterfaces;
 
 /**
  * Create a lookup table for the token program's default accounts
@@ -253,16 +2306,18 @@ declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authorit
  * @param owner                 Owner of the compressed tokens
  * @param toAddress             Destination **uncompressed** token account
  *                              address. (ATA)
- * @param tokenPoolInfos        Optional: Token pool infos.
+ * @param splInterfaceInfos     Optional: SPL interface infos.
  * @param confirmOptions        Options for confirming the transaction
  *
  * @return confirmed transaction signature
  */
-declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], 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 a single
- * account
+ * Merge multiple compressed token accounts for a given mint into fewer
+ * accounts. Each call merges up to 4 accounts (V1) or 8 accounts (V2) at a
+ * time. Call repeatedly until only 1 account remains if full consolidation
+ * is needed.
  *
  * @param rpc                   RPC connection to use
  * @param payer                 Fee payer
@@ -289,12 +2344,12 @@ declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, ow
  * @param outputStateTreeInfo   Optional: State tree account that the compressed
  *                              tokens should be part of. Defaults to the
  *                              default state tree account.
- * @param tokenPoolInfo         Optional: Token pool information
+ * @param splInterfaceInfo      Optional: SPL interface information
  * @param confirmOptions        Options for confirming the transaction
  *
  * @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, tokenPoolInfo?: TokenPoolInfo, 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
@@ -350,12 +2405,12 @@ declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amo
  * @param owner                 Owner of the compressed tokens
  * @param toAddress             Destination **uncompressed** token account
  *                              address. (ATA)
- * @param tokenPoolInfos        Optional: Token pool infos.
+ * @param splInterfaceInfos     Optional: SPL interface infos.
  * @param confirmOptions        Options for confirming the transaction
  *
  * @return Signature of the confirmed transaction
  */
-declare function decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+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.";
 /**
@@ -504,7 +2559,7 @@ type TokenTransferOutputData = {
     /**
      * TokenExtension tlv
      */
-    tlv: Buffer | null;
+    tlv: Buffer$1 | null;
 };
 type PackedTokenTransferOutputData = {
     /**
@@ -526,7 +2581,7 @@ type PackedTokenTransferOutputData = {
     /**
      * TokenExtension tlv
      */
-    tlv: Buffer | null;
+    tlv: Buffer$1 | null;
 };
 type InputTokenDataWithContext = {
     amount: BN;
@@ -534,7 +2589,7 @@ type InputTokenDataWithContext = {
     merkleContext: PackedMerkleContextLegacy;
     rootIndex: number;
     lamports: BN | null;
-    tlv: Buffer | null;
+    tlv: Buffer$1 | null;
 };
 type DelegatedTransfer = {
     owner: PublicKey;
@@ -558,7 +2613,11 @@ type CompressSplTokenAccountInstructionData = {
     remainingAmount: BN | null;
     cpiContext: CompressedCpiContext | null;
 };
-declare function isSingleTokenPoolInfo(tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[]): tokenPoolInfos is TokenPoolInfo;
+declare function isSingleSplInterfaceInfo(splInterfaceInfos: SplInterfaceInfo | SplInterfaceInfo[]): splInterfaceInfos is SplInterfaceInfo;
+/**
+ * @deprecated Use {@link isSingleSplInterfaceInfo} instead.
+ */
+declare const isSingleTokenPoolInfo: typeof isSingleSplInterfaceInfo;
 type CompressedTokenInstructionDataTransfer = {
     /**
      * Validity proof
@@ -623,7 +2682,7 @@ type TokenData = {
     /**
      * TokenExtension tlv
      */
-    tlv: Buffer | null;
+    tlv: Buffer$1 | null;
 };
 type CompressedTokenInstructionDataApprove = {
     proof: ValidityProof | null;
@@ -680,18 +2739,6 @@ declare function packCompressedTokenAccounts(params: PackCompressedTokenAccounts
  */
 declare function checkMint(compressedTokenAccounts: ParsedTokenAccount[], mint: PublicKey): boolean;
 
-declare const POOL_SEED: Buffer<ArrayBuffer>;
-declare const CPI_AUTHORITY_SEED: Buffer<ArrayBuffer>;
-declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const MINT_TO_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const TRANSFER_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const APPROVE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const REVOKE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer<ArrayBuffer>;
-
 type LightCompressedToken = {
     version: '1.2.0';
     name: 'light_compressed_token';
@@ -2526,20 +4573,20 @@ type LightCompressedToken = {
 };
 declare const IDL: LightCompressedToken;
 
-declare const DelegatedTransferLayout: buffer_layout.Layout<unknown>;
-declare const CpiContextLayout: buffer_layout.Layout<unknown>;
-declare const CompressedTokenInstructionDataTransferLayout: buffer_layout.Layout<unknown>;
-declare const mintToLayout: buffer_layout.Layout<unknown>;
-declare const batchCompressLayout: buffer_layout.Layout<unknown>;
-declare const compressSplTokenAccountInstructionDataLayout: buffer_layout.Layout<unknown>;
-declare function encodeMintToInstructionData(data: MintToInstructionData): Buffer;
-declare function decodeMintToInstructionData(buffer: Buffer): MintToInstructionData;
-declare function encodeBatchCompressInstructionData(data: BatchCompressInstructionData): Buffer;
-declare function decodeBatchCompressInstructionData(buffer: Buffer): BatchCompressInstructionData;
-declare function encodeCompressSplTokenAccountInstructionData(data: CompressSplTokenAccountInstructionData): Buffer;
-declare function decodeCompressSplTokenAccountInstructionData(buffer: Buffer): CompressSplTokenAccountInstructionData;
-declare function encodeTransferInstructionData(data: CompressedTokenInstructionDataTransfer): Buffer;
-declare function decodeTransferInstructionData(buffer: Buffer): CompressedTokenInstructionDataTransfer;
+declare const DelegatedTransferLayout: Layout<unknown>;
+declare const CpiContextLayout: Layout<unknown>;
+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;
 interface BaseAccountsLayoutParams {
     feePayer: PublicKey;
     authority: PublicKey;
@@ -2589,12 +4636,12 @@ declare const approveAccountsLayout: (accounts: approveAccountsLayoutParams) =>
 declare const revokeAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
 declare const freezeAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
 declare const thawAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
-declare const CompressedTokenInstructionDataApproveLayout: buffer_layout.Layout<unknown>;
-declare const CompressedTokenInstructionDataRevokeLayout: buffer_layout.Layout<unknown>;
-declare function encodeApproveInstructionData(data: CompressedTokenInstructionDataApprove): Buffer;
-declare function decodeApproveInstructionData(buffer: Buffer): CompressedTokenInstructionDataApprove;
-declare function encodeRevokeInstructionData(data: CompressedTokenInstructionDataRevoke): Buffer;
-declare function decodeRevokeInstructionData(buffer: Buffer): CompressedTokenInstructionDataRevoke;
+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;
 
 type CompressParams = {
     /**
@@ -2628,7 +4675,7 @@ type CompressParams = {
     /**
      * Token pool
      */
-    tokenPoolInfo: TokenPoolInfo;
+    tokenPoolInfo: TokenPoolInfo | SplInterfaceInfo;
 };
 type CompressSplTokenAccountParams = {
     /**
@@ -2658,7 +4705,7 @@ type CompressSplTokenAccountParams = {
     /**
      * Token pool
      */
-    tokenPoolInfo: TokenPoolInfo;
+    tokenPoolInfo: TokenPoolInfo | SplInterfaceInfo;
 };
 type DecompressParams = {
     /**
@@ -2688,7 +4735,7 @@ type DecompressParams = {
     /**
      * Token pool(s)
      */
-    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[];
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[] | SplInterfaceInfo | SplInterfaceInfo[];
 };
 type TransferParams = {
     /**
@@ -2857,13 +4904,13 @@ type MintToParams = {
     /**
      * Token pool
      */
-    tokenPoolInfo: TokenPoolInfo;
+    tokenPoolInfo: TokenPoolInfo | SplInterfaceInfo;
 };
 /**
- * Register an existing SPL mint account to the compressed token program
- * Creates an omnibus account for the mint
+ * Register an existing SPL mint account to the compressed token program.
+ * Creates an omnibus account (SPL interface) for the mint.
  */
-type CreateTokenPoolParams = {
+type CreateSplInterfaceParams = {
     /**
      * Fee payer
      */
@@ -2877,7 +4924,11 @@ type CreateTokenPoolParams = {
      */
     tokenProgramId?: PublicKey;
 };
-type AddTokenPoolParams = {
+/**
+ * @deprecated Use {@link CreateSplInterfaceParams} instead.
+ */
+type CreateTokenPoolParams = CreateSplInterfaceParams;
+type AddSplInterfaceParams = {
     /**
      * Fee payer
      */
@@ -2887,7 +4938,7 @@ type AddTokenPoolParams = {
      */
     mint: PublicKey;
     /**
-     * Token pool index
+     * SPL interface pool index
      */
     poolIndex: number;
     /**
@@ -2895,6 +4946,10 @@ type AddTokenPoolParams = {
      */
     tokenProgramId?: PublicKey;
 };
+/**
+ * @deprecated Use {@link AddSplInterfaceParams} instead.
+ */
+type AddTokenPoolParams = AddSplInterfaceParams;
 /**
  * Mint from existing SPL mint to compressed token accounts
  */
@@ -2930,7 +4985,7 @@ type ApproveAndMintToParams = {
     /**
      * Token pool
      */
-    tokenPoolInfo: TokenPoolInfo;
+    tokenPoolInfo: TokenPoolInfo | SplInterfaceInfo;
 };
 type CreateTokenProgramLookupTableParams = {
     /**
@@ -3008,37 +5063,49 @@ declare class CompressedTokenProgram {
      */
     static setProgramId(programId: PublicKey | string): void;
     /**
-     * Derive the token pool pda.
-     * To derive the token pool pda with bump, use {@link deriveTokenPoolPdaWithIndex}.
+     * Derive the SPL interface PDA.
+     * To derive the SPL interface PDA with bump, use {@link deriveSplInterfacePdaWithIndex}.
      *
-     * @param mint The mint of the token pool
+     * @param mint The mint of the SPL interface
      *
-     * @returns The token pool pda
+     * @returns The SPL interface PDA
+     */
+    static deriveSplInterfacePda(mint: PublicKey): PublicKey;
+    /**
+     * @deprecated Use {@link deriveSplInterfacePda} instead.
      */
     static deriveTokenPoolPda(mint: PublicKey): PublicKey;
     /**
-     * Find the index and bump for a given token pool pda and mint.
+     * Find the index and bump for a given SPL interface PDA and mint.
      *
-     * @param poolPda The token pool pda to find the index and bump for
-     * @param mint The mint of the token pool
+     * @param poolPda The SPL interface PDA to find the index and bump for
+     * @param mint The mint of the SPL interface
      *
      * @returns The index and bump number.
      */
+    static findSplInterfaceIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
+    /**
+     * @deprecated Use {@link findSplInterfaceIndexAndBump} instead.
+     */
     static findTokenPoolIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
     /**
-     * Derive the token pool pda with index.
+     * Derive the SPL interface PDA with index.
      *
-     * @param mint The mint of the token pool
-     * @param index Index. starts at 0. The Protocol supports 4 indexes aka token pools
+     * @param mint The mint of the SPL interface
+     * @param index Index. starts at 0. The Protocol supports 4 indexes aka SPL interfaces
      * per mint.
      *
-     * @returns The token pool pda and bump.
+     * @returns The SPL interface PDA and bump.
+     */
+    static deriveSplInterfacePdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
+    /**
+     * @deprecated Use {@link deriveSplInterfacePdaWithIndex} instead.
      */
     static deriveTokenPoolPdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
     /**
-     * Construct createMint instruction for compressed tokens.
+     * Construct createMint instruction for SPL tokens.
      *
      * @param feePayer              Fee payer.
      * @param mint                  SPL Mint address.
@@ -3067,7 +5134,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The createTokenPool instruction
      */
-    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateTokenPoolParams): 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}.
@@ -3080,7 +5147,7 @@ declare class CompressedTokenProgram {
      *
      * @returns The addTokenPool instruction
      */
-    static addTokenPool({ feePayer, mint, poolIndex, tokenProgramId, }: AddTokenPoolParams): Promise<TransactionInstruction>;
+    static addTokenPool({ feePayer, mint, poolIndex, tokenProgramId, }: AddSplInterfaceParams): Promise<TransactionInstruction>;
     /**
      * Construct mintTo instruction for compressed tokens
      *
@@ -3233,4 +5300,42 @@ declare class CompressedTokenProgram {
     static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
 }
 
-export { ADD_TOKEN_POOL_DISCRIMINATOR, APPROVE_DISCRIMINATOR, Action, type AddTokenPoolParams, type ApproveAndMintToParams, type ApproveParams, BATCH_COMPRESS_DISCRIMINATOR, type BatchCompressInstructionData, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, CpiContextLayout, type CreateMintParams, type CreateTokenPoolParams, type CreateTokenProgramLookupTableParams, type DecompressParams, type DelegatedTransfer, DelegatedTransferLayout, ERROR_NO_ACCOUNTS_FOUND, IDL, type InputTokenDataWithContext, type LightCompressedToken, MINT_TO_DISCRIMINATOR, type MergeTokenAccountsParams, type MintToInstructionData, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedTokenTransferOutputData, REVOKE_DISCRIMINATOR, type RevokeParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, TRANSFER_DISCRIMINATOR, type TokenData, type TokenPoolActivity, type TokenPoolInfo, type TokenTransferOutputData, type TransferParams, addTokenPoolAccountsLayout, type addTokenPoolAccountsLayoutParams, addTokenPools, approve, approveAccountsLayout, type approveAccountsLayoutParams, approveAndMintTo, batchCompressLayout, checkMint, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, createDecompressOutputState, createMint, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferOutputState, decodeApproveInstructionData, decodeBatchCompressInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTransferInstructionData, decompress, decompressDelegated, encodeApproveInstructionData, encodeBatchCompressInstructionData, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeRevokeInstructionData, encodeTransferInstructionData, freezeAccountsLayout, type freezeAccountsLayoutParams, getTokenPoolInfos, isSingleTokenPoolInfo, mergeTokenAccounts, mintTo, mintToAccountsLayout, type mintToAccountsLayoutParams, mintToLayout, packCompressedTokenAccounts, parseMaybeDelegatedTransfer, parseTokenData, revoke, revokeAccountsLayout, type revokeAccountsLayoutParams, selectMinCompressedTokenAccountsForDecompression, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, selectTokenAccountsForApprove, selectTokenPoolInfo, selectTokenPoolInfosForDecompression, sumUpTokenAmount, thawAccountsLayout, type thawAccountsLayoutParams, transfer, transferAccountsLayout, type transferAccountsLayoutParams, transferDelegated, validateSameTokenOwner };
+/**
+ * Retrieve associated token account for a given owner and mint.
+ *
+ * @param rpc         RPC connection
+ * @param ata         Associated token address
+ * @param owner       Owner public key
+ * @param mint        Mint public key
+ * @param commitment  Optional commitment level
+ * @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>;
+/**
+ * Create instructions to load token balances into a c-token ATA.
+ *
+ * @param rpc     RPC connection
+ * @param ata     Associated token address
+ * @param owner   Owner public key
+ * @param mint    Mint public key
+ * @param payer   Fee payer (defaults to owner)
+ * @param options Optional load options
+ * @returns       Array of instructions (empty if nothing to load)
+ */
+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.
+ *
+ * @param rpc               RPC connection
+ * @param ata               Associated token address
+ * @param owner             Owner of the tokens (signer)
+ * @param mint              Mint public key
+ * @param payer             Fee payer (signer, defaults to owner)
+ * @param confirmOptions    Optional confirm options
+ * @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_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 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, 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, 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 };