@lightprotocol/compressed-token 0.20.9 → 0.22.0

package/dist/types/index.d.ts

@@ -1,824 +1,696 @@
-import { PackedMerkleContext, CompressedProof, ParsedTokenAccount, InputTokenDataWithContext as InputTokenDataWithContext$1, Rpc } from '@lightprotocol/stateless.js';
-import { PublicKey, AccountMeta, TransactionInstruction, Connection, Signer, ConfirmOptions, TransactionSignature, Keypair } from '@solana/web3.js';
+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';
-import { Buffer as Buffer$1 } from 'buffer';
 
-type CompressedCpiContext = {
-    setContext: boolean;
-    firstSetContext: boolean;
-    cpiContextAccountIndex: number;
-};
-type TokenTransferOutputData = {
-    /**
-     * The owner of the output token account
-     */
-    owner: PublicKey;
-    /**
-     * The amount of tokens of the output token account
-     */
-    amount: BN;
-    /**
-     * lamports associated with the output token account
-     */
-    lamports: BN | null;
-    /**
-     * TokenExtension tlv
-     */
-    tlv: Buffer | null;
-};
-type PackedTokenTransferOutputData = {
-    /**
-     * The owner of the output token account
-     */
-    owner: PublicKey;
-    /**
-     * The amount of tokens of the output token account
-     */
-    amount: BN;
-    /**
-     * lamports associated with the output token account
-     */
-    lamports: BN | null;
-    /**
-     * Merkle tree pubkey index in remaining accounts
-     */
-    merkleTreeIndex: number;
-    /**
-     * TokenExtension tlv
-     */
-    tlv: Buffer | null;
-};
-type InputTokenDataWithContext = {
+/**
+ * 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>;
+
+/**
+ * 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
+ */
+declare function checkTokenPoolInfo(tokenPoolInfo: TokenPoolInfo, mint: PublicKey): boolean;
+/**
+ * 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
+ *
+ * @returns The token pool infos
+ */
+declare function getTokenPoolInfos(rpc: Rpc, mint: PublicKey, commitment?: Commitment): Promise<TokenPoolInfo[]>;
+type TokenPoolActivity = {
+    signature: string;
     amount: BN;
-    delegateIndex: number | null;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    lamports: BN | null;
-    tlv: Buffer | null;
-};
-type DelegatedTransfer = {
-    owner: PublicKey;
-    delegateChangeAccountIndex: number | null;
-};
-type MintToInstructionData = {
-    recipients: PublicKey[];
-    amounts: BN[];
-    lamports: BN | null;
-};
-type CompressSplTokenAccountInstructionData = {
-    owner: PublicKey;
-    remainingAmount: BN | null;
-    cpiContext: CompressedCpiContext | null;
+    action: Action;
 };
-type CompressedTokenInstructionDataTransfer = {
-    /**
-     * Validity proof
-     */
-    proof: CompressedProof | null;
+/**
+ * Token pool pda info.
+ */
+type TokenPoolInfo = {
     /**
-     * The mint of the transfer
+     * The mint of the token pool
      */
     mint: PublicKey;
     /**
-     * Whether the signer is a delegate
-     * TODO: implement delegated transfer struct
-     */
-    delegatedTransfer: DelegatedTransfer | null;
-    /**
-     * Input token data with packed merkle context
-     */
-    inputTokenDataWithContext: InputTokenDataWithContext[];
-    /**
-     * Data of the output token accounts
-     */
-    outputCompressedAccounts: PackedTokenTransferOutputData[];
-    /**
-     * Whether it's a compress or decompress action if compressOrDecompressAmount is non-null
-     */
-    isCompress: boolean;
-    /**
-     * If null, it's a transfer.
-     * If some, the amount that is being deposited into (compress) or withdrawn from (decompress) the token escrow
-     */
-    compressOrDecompressAmount: BN | null;
-    /**
-     * CPI context if
-     */
-    cpiContext: CompressedCpiContext | null;
-    /**
-     * The index of the Merkle tree for a lamport change account.
+     * The token pool address
      */
-    lamportsChangeAccountMerkleTreeIndex: number | null;
-};
-type TokenData = {
+    tokenPoolPda: PublicKey;
     /**
-     * The mint associated with this account
+     * The token program of the token pool
      */
-    mint: PublicKey;
+    tokenProgram: PublicKey;
     /**
-     * The owner of this account
+     * count of txs and volume in the past 60 seconds.
      */
-    owner: PublicKey;
+    activity?: {
+        txs: number;
+        amountAdded: BN;
+        amountRemoved: BN;
+    };
     /**
-     * The amount of tokens this account holds
+     * Whether the token pool is initialized
      */
-    amount: BN;
+    isInitialized: boolean;
     /**
-     * If `delegate` is `Some` then `delegated_amount` represents the amount
-     * authorized by the delegate
+     * The balance of the token pool
      */
-    delegate: PublicKey | null;
+    balance: BN;
     /**
-     * The account's state
+     * The index of the token pool
      */
-    state: number;
+    poolIndex: number;
     /**
-     * TokenExtension tlv
+     * The bump used to derive the token pool pda
      */
-    tlv: Buffer | null;
+    bump: number;
 };
+/**
+ * @internal
+ */
+declare enum Action {
+    Compress = 1,
+    Decompress = 2,
+    Transfer = 3
+}
+/**
+ * For `compress` and `mintTo` instructions only.
+ * Select a random token pool info from the token pool infos.
+ *
+ * For `decompress`, use {@link selectTokenPoolInfosForDecompression} instead.
+ *
+ * @param infos The token pool infos
+ *
+ * @returns A random token pool info
+ */
+declare function selectTokenPoolInfo(infos: TokenPoolInfo[]): TokenPoolInfo;
+/**
+ * Select one or multiple token pool infos from the token pool infos.
+ *
+ * Use this function for `decompress`.
+ *
+ * For `compress`, `mintTo` use {@link selectTokenPoolInfo} instead.
+ *
+ * @param infos             The token pool infos
+ * @param decompressAmount  The amount of tokens to withdraw
+ *
+ * @returns Array with one or more token pool infos.
+ */
+declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], decompressAmount: number | BN): TokenPoolInfo[];
 
-type PackCompressedTokenAccountsParams = {
-    /** Input state to be consumed */
-    inputCompressedTokenAccounts: ParsedTokenAccount[];
-    /**
-     * State trees that the output should be inserted into. Defaults to the 0th
-     * state tree of the input state. Gets padded to the length of
-     * outputCompressedAccounts.
-     */
-    outputStateTrees?: PublicKey[] | PublicKey;
-    /** Optional remaining accounts to append to */
-    remainingAccounts?: PublicKey[];
-    /**
-     *  Root indices that are used on-chain to fetch the correct root
-     *  from the state Merkle tree account for validity proof verification.
-     */
-    rootIndices: number[];
-    tokenTransferOutputs: TokenTransferOutputData[];
-};
 /**
- * Packs Compressed Token Accounts.
+ * Mint compressed tokens to a solana address from an external mint authority
+ *
+ * @param rpc                   Rpc to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param toPubkey              Address of the account to mint to
+ * @param authority             Minting authority
+ * @param amount                Amount to mint
+ * @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 confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
  */
-declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
-    inputTokenDataWithContext: InputTokenDataWithContext$1[];
-    remainingAccountMetas: AccountMeta[];
-    packedOutputTokenData: PackedTokenTransferOutputData[];
-};
+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 const POOL_SEED: Buffer;
-declare const CPI_AUTHORITY_SEED: Buffer;
-declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer;
-declare const MINT_TO_DISCRIMINATOR: Buffer;
-declare const TRANSFER_DISCRIMINATOR: Buffer;
-declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer;
+/**
+ * Compress SPL tokens
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to compress.
+ * @param owner                 Owner of the SPL token account.
+ * @param sourceTokenAccount    Source SPL token account. (ATA)
+ * @param toAddress             Recipient owner address.
+ * @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 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>;
 
-type CompressParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * owner of the *uncompressed* token account.
-     */
-    owner: PublicKey;
-    /**
-     * source (associated) token account address.
-     */
-    source: PublicKey;
-    /**
-     * owner of the compressed token account.
-     * To compress to a batch of recipients, pass an array of PublicKeys.
-     */
-    toAddress: PublicKey | PublicKey[];
-    /**
-     * Mint address of the token to compress.
-     */
-    mint: PublicKey;
-    /**
-     * amount of tokens to compress.
-     */
-    amount: number | BN | number[] | BN[];
-    /**
-     * The state tree that the tx output should be inserted into. Defaults to a
-     * public state tree if unspecified.
-     */
-    outputStateTree?: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
-type CompressSplTokenAccountParams = {
-    /**
-     * Tx feepayer
-     */
-    feePayer: PublicKey;
-    /**
-     * Authority that owns the token account
-     */
-    authority: PublicKey;
-    /**
-     * Token account to compress
-     */
-    tokenAccount: PublicKey;
-    /**
-     * Mint public key
-     */
+/**
+ * Compress SPL tokens into compressed token format
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param owner                 Owner of the token account
+ * @param tokenAccount          Token account to compress
+ * @param remainingAmount       Optional: amount to leave in token account.
+ *                              Default: 0
+ * @param outputStateTreeInfo   Optional: State tree account that the compressed
+ *                              account into
+ * @param tokenPoolInfo         Optional: Token pool 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>;
+
+/**
+ * Create and initialize a new compressed token mint
+ *
+ * @param rpc               RPC connection to use
+ * @param payer             Fee payer
+ * @param mintAuthority     Account that will control minting
+ * @param decimals          Location of the decimal place
+ * @param keypair           Optional: Mint keypair. Defaults to a random
+ *                          keypair.
+ * @param confirmOptions    Options for confirming the transaction
+ * @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<{
     mint: PublicKey;
-    /**
-     * Optional: remaining amount to leave in token account. Default: 0
-     */
-    remainingAmount?: BN;
-    /**
-     * The state tree that the compressed token account should be inserted into.
-     */
-    outputStateTree: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
-type DecompressParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * input state to be consumed
-     */
-    inputCompressedTokenAccounts: ParsedTokenAccount[];
-    /**
-     * address of **uncompressed** destination token account.
-     */
-    toAddress: PublicKey;
-    /**
-     * amount of tokens to decompress.
-     */
-    amount: number | BN;
-    /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
-     */
-    recentInputStateRootIndices: number[];
-    /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
-     */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state tree that the change tx output should be inserted into.
-     * Defaults to a public state tree if unspecified.
-     */
-    outputStateTree?: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
-type TransferParams = {
-    /**
-     * The payer of the transaction
-     */
-    payer: PublicKey;
-    /**
-     * The input state to be consumed
-     */
-    inputCompressedTokenAccounts: ParsedTokenAccount[];
-    /**
-     * Recipient address
-     */
-    toAddress: PublicKey;
-    /**
-     * Amount of tokens to transfer
-     */
-    amount: BN | number;
-    /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
+    transactionSignature: TransactionSignature;
+}>;
 
-     */
-    recentInputStateRootIndices: number[];
-    /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
-     */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state trees that the tx output should be inserted into. This can be a
-     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
-     * of input state.
-     */
-    outputStateTrees?: PublicKey[] | PublicKey;
-};
 /**
- * Create Mint account for compressed Tokens
+ * Register an existing mint with the CompressedToken program
+ *
+ * @param rpc             RPC connection to use
+ * @param payer           Fee payer
+ * @param mint            SPL Mint address
+ * @param confirmOptions  Options for confirming the transaction
+ * @param tokenProgramId  Optional: Address of the token program. Default:
+ *                        TOKEN_PROGRAM_ID
+ *
+ * @return transaction signature
  */
-type CreateMintParams = {
-    /**
-     * Tx feepayer
-     */
-    feePayer: PublicKey;
-    /**
-     * Mint authority
-     */
-    authority: PublicKey;
-    /**
-     * Mint public key
-     */
-    mint: PublicKey;
-    /**
-     * Mint decimals
-     */
-    decimals: number;
-    /**
-     * Optional: freeze authority
-     */
-    freezeAuthority: PublicKey | null;
-    /**
-     * lamport amount for mint account rent exemption
-     */
-    rentExemptBalance: number;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-    /**
-     * Optional: Mint size to use, defaults to MINT_SIZE
-     */
-    mintSize?: number;
-};
+declare function createTokenPool(rpc: Rpc, payer: Signer, mint: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
 /**
- * Parameters for merging compressed token accounts
+ * Create additional token pools 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
+ *                              3.
+ * @param confirmOptions        Optional: Options for confirming the transaction
+ * @param tokenProgramId        Optional: Address of the token program. Default:
+ *                              TOKEN_PROGRAM_ID
+ *
+ * @return transaction signature
  */
-type MergeTokenAccountsParams = {
-    /**
-     * Tx feepayer
-     */
-    payer: PublicKey;
-    /**
-     * Owner of the token accounts to be merged
-     */
-    owner: PublicKey;
-    /**
-     * Mint public key
-     */
-    mint: PublicKey;
-    /**
-     * Array of compressed token accounts to merge
-     */
-    inputCompressedTokenAccounts: ParsedTokenAccount[];
-    /**
-     * Optional: Public key of the state tree to merge into
-     */
-    outputStateTree: PublicKey;
-    /**
-     * Optional: Recent validity proof for state inclusion
-     */
-    recentValidityProof: CompressedProof;
-    /**
-     * Optional: Recent state root indices of the input state
-     */
-    recentInputStateRootIndices: number[];
-};
+declare function addTokenPools(rpc: Rpc, payer: Signer, mint: PublicKey, numMaxAdditionalPools: number, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<string>;
+
 /**
- * Create compressed token accounts
+ * Create a lookup table for the token program's default accounts
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param authority             Authority of the lookup table
+ * @param mints                 Optional array of mint public keys to include in
+ *                              the lookup table
+ * @param additionalAccounts    Optional array of additional account public keys
+ *                              to include in the lookup table
+ *
+ * @return Object with transaction signatures and the address of the created
+ *         lookup table
  */
-type MintToParams = {
-    /**
-     * Tx feepayer
-     */
-    feePayer: PublicKey;
-    /**
-     * Mint authority
-     */
-    authority: PublicKey;
-    /**
-     * Mint public key
-     */
-    mint: PublicKey;
-    /**
-     * The Solana Public Keys to mint to.
-     */
-    toPubkey: PublicKey[] | PublicKey;
-    /**
-     * The amount of compressed tokens to mint.
-     */
-    amount: BN | BN[] | number | number[];
-    /**
-     * Public key of the state tree to mint into. Defaults to a public state
-     * tree if unspecified.
-     */
-    merkleTree?: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
+declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
+    txIds: TransactionSignature[];
+    address: PublicKey;
+}>;
+
 /**
- * Register an existing SPL mint account to the compressed token program
- * Creates an omnibus account for the mint
+ * Decompress compressed tokens
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to transfer
+ * @param owner                 Owner of the compressed tokens
+ * @param toAddress             Destination **uncompressed** token account
+ *                              address. (ATA)
+ * @param tokenPoolInfos        Optional: Token pool infos.
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return confirmed transaction signature
  */
-type RegisterMintParams = {
-    /** Tx feepayer */
-    feePayer: PublicKey;
-    /** Mint public key */
-    mint: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
+declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
- * Mint from existing SPL mint to compressed token accounts
+ * Merge multiple compressed token accounts for a given mint into a single
+ * account
+ *
+ * @param rpc                   RPC connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param owner                 Owner of the token accounts to be merged
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return confirmed transaction signature
  */
-type ApproveAndMintToParams = {
-    /**
-     * Tx feepayer
-     */
-    feePayer: PublicKey;
-    /**
-     * Mint authority
-     */
-    authority: PublicKey;
-    /**
-     * Mint authority (associated) token account
-     */
-    authorityTokenAccount: PublicKey;
-    /**
-     * Mint public key
-     */
-    mint: PublicKey;
-    /**
-     * The Solana Public Key to mint to.
-     */
-    toPubkey: PublicKey;
-    /**
-     * The amount of compressed tokens to mint.
-     */
-    amount: BN | number;
-    /**
-     * Public key of the state tree to mint into. Defaults to a public state
-     * tree if unspecified.
-     */
-    merkleTree?: PublicKey;
-    /**
-     * Optional: The token program ID. Default: SPL Token Program ID
-     */
-    tokenProgramId?: PublicKey;
-};
-type CreateTokenProgramLookupTableParams = {
-    /**
-     * The payer of the transaction.
-     */
-    payer: PublicKey;
-    /**
-     * The authority of the transaction.
-     */
-    authority: PublicKey;
-    /**
-     *  Recently finalized Solana slot.
-     */
-    recentSlot: number;
-    /**
-     * Optional Mint addresses to store in the lookup table.
-     */
-    mints?: PublicKey[];
-    /**
-     * Optional additional addresses to store in the lookup table.
-     */
-    remainingAccounts?: PublicKey[];
-};
+declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
- * Sum up the token amounts of the compressed token accounts
+ * Mint compressed tokens to a solana address
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param toPubkey              Address of the account to mint to. Can be an
+ *                              array of addresses if the amount is an array of
+ *                              amounts.
+ * @param authority             Mint authority
+ * @param amount                Amount to mint. Pass an array of amounts if the
+ *                              toPubkey is an array of addresses.
+ * @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 confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
  */
-declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
+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>;
+
 /**
- * Validate that all the compressed token accounts are owned by the same owner.
+ * Revoke one or more delegated token accounts
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param accounts              Delegated compressed token accounts to revoke
+ * @param owner                 Owner of the compressed tokens
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
  */
-declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
+declare function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[], owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
- * Parse compressed token accounts to get the mint, current owner and delegate.
+ * Transfer compressed tokens from one owner to another
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to transfer
+ * @param owner                 Owner of the compressed tokens
+ * @param toAddress             Destination address of the recipient
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return confirmed transaction signature
  */
-declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
-    mint: PublicKey;
-    currentOwner: PublicKey;
-    delegate: PublicKey | null;
-};
+declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
- * Create the output state for a transfer transaction.
- * @param inputCompressedTokenAccounts  Input state
- * @param toAddress                     Recipient address
- * @param amount                        Amount of tokens to transfer
- * @returns                             Output token data for the transfer
- *                                      instruction
+ * Transfer delegated compressed tokens to another owner
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to transfer
+ * @param owner                 Owner of the compressed tokens
+ * @param toAddress             Destination address of the recipient
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return confirmed transaction signature
  */
-declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData[];
+declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
- * Create the output state for a compress transaction.
- * @param inputCompressedTokenAccounts  Input state
- * @param amount                        Amount of tokens to compress
- * @returns                             Output token data for the compress
- *                                      instruction
- */
-declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData[];
-declare class CompressedTokenProgram {
-    /**
-     * @internal
-     */
-    constructor();
-    /**
-     * Public key that identifies the CompressedPda program
-     */
-    static programId: PublicKey;
-    /**
-     * Set a custom programId via PublicKey or base58 encoded string.
-     * This method is not required for regular usage.
-     *
-     * Use this only if you know what you are doing.
-     */
-    static setProgramId(programId: PublicKey | string): void;
-    /** @internal */
-    static deriveTokenPoolPda(mint: PublicKey): PublicKey;
-    /** @internal */
-    static get deriveCpiAuthorityPda(): PublicKey;
-    /**
-     * Construct createMint instruction for compressed tokens.
-     * @returns [createMintAccountInstruction, initializeMintInstruction, createTokenPoolInstruction]
-     *
-     * Note that `createTokenPoolInstruction` must be executed after `initializeMintInstruction`.
-     */
-    static createMint(params: CreateMintParams): Promise<TransactionInstruction[]>;
-    /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
-     * For new mints, use `CompressedTokenProgram.createMint`.
-     */
-    static createTokenPool(params: RegisterMintParams): Promise<TransactionInstruction>;
-    /**
-     * Construct mintTo instruction for compressed tokens
-     */
-    static mintTo(params: MintToParams): Promise<TransactionInstruction>;
-    /**
-     * Mint tokens from registered SPL mint account to a compressed account
-     */
-    static approveAndMintTo(params: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
-    /**
-     * Construct transfer instruction for compressed tokens
-     */
-    static transfer(params: TransferParams): Promise<TransactionInstruction>;
-    /**
-     * Create lookup table instructions for the token program's default accounts.
-     */
-    static createTokenProgramLookupTable(params: CreateTokenProgramLookupTableParams): Promise<{
-        instructions: TransactionInstruction[];
-        address: PublicKey;
-    }>;
-    /**
-     * Create compress instruction
-     * @returns compressInstruction
-     */
-    static compress(params: CompressParams): Promise<TransactionInstruction>;
-    /**
-     * Construct decompress instruction
-     */
-    static decompress(params: DecompressParams): Promise<TransactionInstruction>;
-    static mergeTokenAccounts(params: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
-    static compressSplTokenAccount(params: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
-    static get_mint_program_id(mint: PublicKey, connection: Connection): Promise<PublicKey | undefined>;
-}
-
-/**
- * Mint compressed tokens to a solana address from an external mint authority
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to
- * @param authority      Minting authority
- * @param amount         Amount to mint
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       part of. Defaults to random public state tree account.
- * @param confirmOptions Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
-
-/**
- * Compress SPL tokens
+ * Decompress delegated compressed tokens. Remaining compressed tokens are
+ * returned to the owner without delegation.
  *
  * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint of the compressed token
- * @param amount                Number of tokens to transfer
- * @param owner                 Owner of the compressed tokens.
- * @param sourceTokenAccount    Source (associated) token account
- * @param toAddress             Destination address of the recipient
- * @param merkleTree            State tree account that the compressed tokens
- *                              should be inserted into. Defaults to a default
- *                              state tree account.
+ * @param payer                 Fee payer
+ * @param mint                  SPL Mint address
+ * @param amount                Number of tokens to decompress
+ * @param owner                 Owner of the compressed tokens
+ * @param toAddress             Destination **uncompressed** token account
+ *                              address. (ATA)
+ * @param tokenPoolInfos        Optional: Token pool infos.
  * @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>, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
-
-/**
- * Decompress compressed tokens
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint of the compressed token
- * @param amount         Number of tokens to transfer
- * @param owner          Owner of the compressed tokens
- * @param toAddress      Destination **uncompressed** (associated) token account
- *                       address.
- * @param merkleTree     State tree account that any change compressed tokens should be
- *                       inserted into. Defaults to a default state tree
- *                       account.
- * @param confirmOptions Options for confirming the transaction
- *
- *
  * @return Signature of the confirmed transaction
  */
-declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
+declare function decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
+declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
 /**
- * Create and initialize a new compressed token mint
- *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction and initialization fees
- * @param mintAuthority   Account or multisig that will control minting
- * @param decimals        Location of the decimal place
- * @param keypair         Optional keypair, defaulting to a new random one
- * @param confirmOptions  Options for confirming the transaction
- * @param tokenProgramId  Program ID for the token. Defaults to
- *                        TOKEN_PROGRAM_ID. You can pass in a boolean to
- *                        automatically resolve to TOKEN_2022_PROGRAM_ID if
- *                        true, or TOKEN_PROGRAM_ID if false.
- * @param freezeAuthority Account that will control freeze and thaw. Defaults to null.
+ * Selects token accounts for approval, first trying to find an exact match, then falling back to minimum selection.
  *
- * @return Address of the new mint and the transaction signature
+ * @param {ParsedTokenAccount[]} accounts - Token accounts to choose from.
+ * @param {BN} approveAmount - Amount to approve.
+ * @param {number} [maxInputs=4] - Max accounts to select when falling back to minimum selection.
+ * @returns {[
+ *   selectedAccounts: ParsedTokenAccount[],
+ *   total: BN,
+ *   totalLamports: BN | null,
+ *   maxPossibleAmount: BN
+ * ]} - Returns:
+ *   - selectedAccounts: Accounts chosen for approval.
+ *   - total: Total amount from selected accounts.
+ *   - totalLamports: Total lamports from selected accounts.
+ *   - maxPossibleAmount: Max approvable amount given maxInputs.
  */
-declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey | boolean, freezeAuthority?: PublicKey): Promise<{
-    mint: PublicKey;
-    transactionSignature: TransactionSignature;
-}>;
-
+declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Mint compressed tokens to a solana address
+ * Selects the minimum number of compressed token accounts required for a
+ * decompress instruction, up to a specified maximum.
  *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to. Can be an array of
- *                       addresses if the amount is an array of amounts.
- * @param authority      Minting authority
- * @param amount         Amount to mint. Can be an array of amounts if the
- *                       destination is an array of addresses.
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       part of. Defaults to the default state tree account.
- * @param confirmOptions Options for confirming the transaction
+ * @param {ParsedTokenAccount[]} accounts   Token accounts to choose from.
+ * @param {BN} amount                       Amount to decompress.
+ * @param {number} [maxInputs=4]            Max accounts to select. Default
+ *                                          is 4.
  *
- * @return Signature of the confirmed transaction
+ * @returns Returns selected accounts and their totals.
  */
-declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey | PublicKey[], authority: Signer, amount: number | BN | number[] | BN[], merkleTree?: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
-
+declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number): {
+    selectedAccounts: ParsedTokenAccount[];
+    total: BN;
+    totalLamports: BN | null;
+    maxPossibleAmount: BN;
+};
 /**
- * Merge multiple compressed token accounts for a given mint into a single
- * account
+ * Selects the minimum number of compressed token accounts required for a
+ * transfer or decompression instruction, up to a specified maximum.
  *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction fees
- * @param mint            Public key of the token's mint
- * @param owner           Owner of the token accounts to be merged
- * @param merkleTree      Optional merkle tree for compressed tokens
- * @param confirmOptions  Options for confirming the transaction
+ * @param {ParsedTokenAccount[]} accounts   Token accounts to choose from.
+ * @param {BN} transferAmount               Amount to transfer or decompress.
+ * @param {number} [maxInputs=4]            Max accounts to select. Default
+ *                                          is 4.
  *
- * @return Array of transaction signatures
+ * @returns Returns selected accounts and their totals. [
+ *   selectedAccounts: ParsedTokenAccount[],
+ *   total: BN,
+ *   totalLamports: BN | null,
+ *   maxPossibleAmount: BN
+ * ]
  */
-declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
+declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Register an existing mint with the CompressedToken program
- *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction and initialization fees
- * @param mintAuthority   Account or multisig that will control minting. Is signer.
- * @param mintAddress     Address of the existing mint
- * @param confirmOptions  Options for confirming the transaction
- *
- * @return transaction signature
+ * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
+ * returns partial amounts if insufficient accounts are found instead of
+ * throwing an error.
  */
-declare function createTokenPool(rpc: Rpc, payer: Signer, mint: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
-
+declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Transfer compressed tokens from one owner to another
+ * Selects compressed token accounts for a transfer, ensuring one extra account
+ * if possible, up to maxInputs.
  *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint of the compressed token
- * @param amount         Number of tokens to transfer
- * @param owner          Owner of the compressed tokens
- * @param toAddress      Destination address of the recipient
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       inserted into. Defaults to the default state tree
- *                       account.
- * @param confirmOptions Options for confirming the transaction
+ * 1. Sorts accounts by amount (desc)
+ * 2. Selects accounts until transfer amount is met or maxInputs is reached,
+ *    attempting to add one extra account if possible.
  *
+ * @param {ParsedTokenAccount[]} accounts - The list of token accounts to select from.
+ * @param {BN} transferAmount - The token amount to be transferred.
+ * @param {number} [maxInputs=4] - The maximum number of accounts to select. Default: 4.
+ * @returns {[
+ *   selectedAccounts: ParsedTokenAccount[],
+ *   total: BN,
+ *   totalLamports: BN | null,
+ *   maxPossibleAmount: BN
+ * ]} - An array containing:
+ *   - selectedAccounts: The accounts selected for the transfer.
+ *   - total: The total amount accumulated from the selected accounts.
+ *   - totalLamports: The total lamports accumulated from the selected accounts.
+ *   - maxPossibleAmount: The maximum possible amount that can be transferred considering maxInputs.
  *
- * @return Signature of the confirmed transaction
- */
-declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
-/**
- * Create a lookup table for the token program's default accounts
+ * @example
+ * const accounts = [
+ *   { parsed: { amount: new BN(100) }, compressedAccount: { lamports: new BN(10) } },
+ *   { parsed: { amount: new BN(50) }, compressedAccount: { lamports: new BN(5) } },
+ *   { parsed: { amount: new BN(25) }, compressedAccount: { lamports: new BN(2) } },
+ * ];
+ * const transferAmount = new BN(75);
+ * const maxInputs = 2;
  *
- * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param authority             Authority of the lookup table
- * @param mints                 Optional array of mint public keys to include in
- *                              the lookup table
- * @param additionalAccounts    Optional array of additional account public keys
- *                              to include in the lookup table
+ * const [selectedAccounts, total, totalLamports, maxPossibleAmount] =
+ *   selectSmartCompressedTokenAccountsForTransfer(accounts, transferAmount, maxInputs);
  *
- * @return Transaction signatures and the address of the created lookup table
+ * console.log(selectedAccounts.length); // 2
+ * console.log(total.toString()); // '150'
+ * console.log(totalLamports!.toString()); // '15'
+ * console.log(maxPossibleAmount.toString()); // '150'
  */
-declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
-    txIds: TransactionSignature[];
-    address: PublicKey;
-}>;
-
+declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Compress SPL tokens into compressed token format
- *
- * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint of the token to compress
- * @param owner                 Owner of the token account
- * @param tokenAccount         Token account to compress
- * @param outputStateTree       State tree to insert the compressed token account into
- * @param remainingAmount      Optional: amount to leave in token account. Default: 0
- * @param confirmOptions       Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
+ * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
+ * returns partial amounts if insufficient accounts are found instead of
+ * throwing an error.
  */
-declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, tokenAccount: PublicKey, outputStateTree: PublicKey, remainingAmount?: BN, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
+declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 
-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 compressSplTokenAccountInstructionDataLayout: buffer_layout.Layout<unknown>;
-declare function encodeMintToInstructionData(data: MintToInstructionData): Buffer$1;
-declare function decodeMintToInstructionData(buffer: Buffer$1): MintToInstructionData;
-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;
-    cpiAuthorityPda: PublicKey;
-    lightSystemProgram: PublicKey;
-    registeredProgramPda: PublicKey;
-    noopProgram: PublicKey;
-    accountCompressionAuthority: PublicKey;
-    accountCompressionProgram: PublicKey;
-    selfProgram: PublicKey;
-    systemProgram: PublicKey;
-}
-type createTokenPoolAccountsLayoutParams = {
-    feePayer: PublicKey;
-    tokenPoolPda: PublicKey;
-    systemProgram: PublicKey;
-    mint: PublicKey;
-    tokenProgram: PublicKey;
-    cpiAuthorityPda: PublicKey;
-};
-type mintToAccountsLayoutParams = BaseAccountsLayoutParams & {
-    mint: PublicKey;
-    tokenPoolPda: PublicKey;
-    tokenProgram: PublicKey;
-    merkleTree: PublicKey;
-    solPoolPda: PublicKey | null;
-};
-type transferAccountsLayoutParams = BaseAccountsLayoutParams & {
-    tokenPoolPda?: PublicKey;
-    compressOrDecompressTokenAccount?: PublicKey;
-    tokenProgram?: PublicKey;
+type TokenTransferOutputData = {
+    /**
+     * The owner of the output token account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens of the output token account
+     */
+    amount: BN;
+    /**
+     * lamports associated with the output token account
+     */
+    lamports: BN | null;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
 };
-type approveAccountsLayoutParams = BaseAccountsLayoutParams;
-type revokeAccountsLayoutParams = approveAccountsLayoutParams;
-type freezeAccountsLayoutParams = BaseAccountsLayoutParams & {
+type PackedTokenTransferOutputData = {
+    /**
+     * The owner of the output token account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens of the output token account
+     */
+    amount: BN;
+    /**
+     * lamports associated with the output token account
+     */
+    lamports: BN | null;
+    /**
+     * Merkle tree pubkey index in remaining accounts
+     */
+    merkleTreeIndex: number;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
+};
+type InputTokenDataWithContext = {
+    amount: BN;
+    delegateIndex: number | null;
+    merkleContext: PackedMerkleContextLegacy;
+    rootIndex: number;
+    lamports: BN | null;
+    tlv: Buffer | null;
+};
+type DelegatedTransfer = {
+    owner: PublicKey;
+    delegateChangeAccountIndex: number | null;
+};
+type BatchCompressInstructionData = {
+    pubkeys: PublicKey[];
+    amounts: BN[] | null;
+    lamports: BN | null;
+    amount: BN | null;
+    index: number;
+    bump: number;
+};
+type MintToInstructionData = {
+    recipients: PublicKey[];
+    amounts: BN[];
+    lamports: BN | null;
+};
+type CompressSplTokenAccountInstructionData = {
+    owner: PublicKey;
+    remainingAmount: BN | null;
+    cpiContext: CompressedCpiContext | null;
+};
+declare function isSingleTokenPoolInfo(tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[]): tokenPoolInfos is TokenPoolInfo;
+type CompressedTokenInstructionDataTransfer = {
+    /**
+     * Validity proof
+     */
+    proof: ValidityProof | null;
+    /**
+     * The mint of the transfer
+     */
+    mint: PublicKey;
+    /**
+     * Whether the signer is a delegate
+     */
+    delegatedTransfer: DelegatedTransfer | null;
+    /**
+     * Input token data with packed merkle context
+     */
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    /**
+     * Data of the output token accounts
+     */
+    outputCompressedAccounts: PackedTokenTransferOutputData[];
+    /**
+     * Whether it's a compress or decompress action if compressOrDecompressAmount is non-null
+     */
+    isCompress: boolean;
+    /**
+     * If null, it's a transfer.
+     * If some, the amount that is being deposited into (compress) or withdrawn from (decompress) the token escrow
+     */
+    compressOrDecompressAmount: BN | null;
+    /**
+     * CPI context if
+     */
+    cpiContext: CompressedCpiContext | null;
+    /**
+     * The index of the Merkle tree for a lamport change account.
+     */
+    lamportsChangeAccountMerkleTreeIndex: number | null;
+};
+type TokenData = {
+    /**
+     * The mint associated with this account
+     */
+    mint: PublicKey;
+    /**
+     * The owner of this account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens this account holds
+     */
+    amount: BN;
+    /**
+     * If `delegate` is `Some` then `delegated_amount` represents the amount
+     * authorized by the delegate
+     */
+    delegate: PublicKey | null;
+    /**
+     * The account's state
+     */
+    state: number;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
+};
+type CompressedTokenInstructionDataApprove = {
+    proof: ValidityProof | null;
     mint: PublicKey;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    cpiContext: CompressedCpiContext | null;
+    delegate: PublicKey;
+    delegatedAmount: BN;
+    delegateMerkleTreeIndex: number;
+    changeAccountMerkleTreeIndex: number;
+    delegateLamports: BN | null;
 };
-type thawAccountsLayoutParams = freezeAccountsLayoutParams;
-declare const createTokenPoolAccountsLayout: (accounts: createTokenPoolAccountsLayoutParams) => AccountMeta[];
-declare const mintToAccountsLayout: (accounts: mintToAccountsLayoutParams) => AccountMeta[];
-declare const transferAccountsLayout: (accounts: transferAccountsLayoutParams) => AccountMeta[];
+type CompressedTokenInstructionDataRevoke = {
+    proof: ValidityProof | null;
+    mint: PublicKey;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    cpiContext: CompressedCpiContext | null;
+    outputAccountMerkleTreeIndex: number;
+};
+
+type PackCompressedTokenAccountsParams = {
+    /** Input state to be consumed */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * State trees that the output should be inserted into. Defaults to the 0th
+     * state tree of the input state. Gets padded to the length of
+     * outputCompressedAccounts.
+     */
+    outputStateTreeInfo?: TreeInfo;
+    /** Optional remaining accounts to append to */
+    remainingAccounts?: PublicKey[];
+    /**
+     *  Root indices that are used on-chain to fetch the correct root
+     *  from the state Merkle tree account for validity proof verification.
+     */
+    rootIndices: number[];
+    tokenTransferOutputs: TokenTransferOutputData[];
+};
+/**
+ * Packs Compressed Token Accounts.
+ */
+declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
+    inputTokenDataWithContext: InputTokenDataWithContext$1[];
+    remainingAccountMetas: AccountMeta[];
+    packedOutputTokenData: PackedTokenTransferOutputData[];
+};
+
+/**
+ * Check if all input accounts belong to the same mint.
+ *
+ * @param compressedTokenAccounts   The compressed token accounts
+ * @param mint                      The mint of the token pool
+ * @returns True if all input accounts belong to the same mint
+ */
+declare function checkMint(compressedTokenAccounts: ParsedTokenAccount[], mint: PublicKey): boolean;
+
+declare const POOL_SEED: Buffer;
+declare const CPI_AUTHORITY_SEED: Buffer;
+declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
+declare const CREATE_TOKEN_POOL_DISCRIMINATOR: Buffer;
+declare const MINT_TO_DISCRIMINATOR: Buffer;
+declare const BATCH_COMPRESS_DISCRIMINATOR: Buffer;
+declare const TRANSFER_DISCRIMINATOR: Buffer;
+declare const COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer;
+declare const APPROVE_DISCRIMINATOR: Buffer;
+declare const REVOKE_DISCRIMINATOR: Buffer;
+declare const ADD_TOKEN_POOL_DISCRIMINATOR: Buffer;
 
 type LightCompressedToken = {
     version: '1.2.0';
@@ -1911,6 +1783,104 @@ type LightCompressedToken = {
                 ];
             };
         },
+        {
+            name: 'CompressedTokenInstructionDataRevoke';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'mint';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'inputTokenDataWithContext';
+                        type: {
+                            vec: {
+                                defined: 'InputTokenDataWithContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'cpiContext';
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputAccountMerkleTreeIndex';
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedTokenInstructionDataApprove';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'mint';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'inputTokenDataWithContext';
+                        type: {
+                            vec: {
+                                defined: 'InputTokenDataWithContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'cpiContext';
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'delegate';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'delegatedAmount';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'delegateMerkleTreeIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'changeAccountMerkleTreeIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'delegateLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    }
+                ];
+            };
+        },
         {
             name: 'DelegatedTransfer';
             docs: [
@@ -2205,7 +2175,7 @@ type LightCompressedToken = {
                         type: 'u8';
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex';
+                        name: 'queuePubkeyIndex';
                         type: 'u8';
                     },
                     {
@@ -2213,12 +2183,8 @@ type LightCompressedToken = {
                         type: 'u32';
                     },
                     {
-                        name: 'queueIndex';
-                        type: {
-                            option: {
-                                defined: 'QueueIndex';
-                            };
-                        };
+                        name: 'proveByIndex';
+                        type: 'bool';
                     }
                 ];
             };
@@ -2560,112 +2526,711 @@ type LightCompressedToken = {
 };
 declare const IDL: LightCompressedToken;
 
-declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
+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;
+interface BaseAccountsLayoutParams {
+    feePayer: PublicKey;
+    authority: PublicKey;
+    cpiAuthorityPda: PublicKey;
+    lightSystemProgram: PublicKey;
+    registeredProgramPda: PublicKey;
+    noopProgram: PublicKey;
+    accountCompressionAuthority: PublicKey;
+    accountCompressionProgram: PublicKey;
+    selfProgram: PublicKey;
+    systemProgram: PublicKey;
+}
+type createTokenPoolAccountsLayoutParams = {
+    feePayer: PublicKey;
+    tokenPoolPda: PublicKey;
+    systemProgram: PublicKey;
+    mint: PublicKey;
+    tokenProgram: PublicKey;
+    cpiAuthorityPda: PublicKey;
+};
+type addTokenPoolAccountsLayoutParams = createTokenPoolAccountsLayoutParams & {
+    existingTokenPoolPda: PublicKey;
+};
+type mintToAccountsLayoutParams = BaseAccountsLayoutParams & {
+    mint: PublicKey;
+    tokenPoolPda: PublicKey;
+    tokenProgram: PublicKey;
+    merkleTree: PublicKey;
+    solPoolPda: PublicKey | null;
+};
+type transferAccountsLayoutParams = BaseAccountsLayoutParams & {
+    tokenPoolPda?: PublicKey;
+    compressOrDecompressTokenAccount?: PublicKey;
+    tokenProgram?: PublicKey;
+};
+type approveAccountsLayoutParams = BaseAccountsLayoutParams;
+type revokeAccountsLayoutParams = approveAccountsLayoutParams;
+type freezeAccountsLayoutParams = BaseAccountsLayoutParams & {
+    mint: PublicKey;
+};
+type thawAccountsLayoutParams = freezeAccountsLayoutParams;
+declare const createTokenPoolAccountsLayout: (accounts: createTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const addTokenPoolAccountsLayout: (accounts: addTokenPoolAccountsLayoutParams) => AccountMeta[];
+declare const mintToAccountsLayout: (accounts: mintToAccountsLayoutParams) => AccountMeta[];
+declare const transferAccountsLayout: (accounts: transferAccountsLayoutParams) => AccountMeta[];
+declare const approveAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const revokeAccountsLayout: (accounts: approveAccountsLayoutParams) => AccountMeta[];
+declare const freezeAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
+declare const thawAccountsLayout: (accounts: freezeAccountsLayoutParams) => AccountMeta[];
+declare const 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;
+
+type CompressParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Owner of uncompressed token account
+     */
+    owner: PublicKey;
+    /**
+     * Source SPL Token account address
+     */
+    source: PublicKey;
+    /**
+     * Recipient address(es)
+     */
+    toAddress: PublicKey | PublicKey[];
+    /**
+     * Token amount(s) to compress
+     */
+    amount: number | BN | number[] | BN[];
+    /**
+     * SPL Token mint address
+     */
+    mint: PublicKey;
+    /**
+     * State tree to write to
+     */
+    outputStateTreeInfo: TreeInfo;
+    /**
+     * Token pool
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+type CompressSplTokenAccountParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * SPL Token account owner
+     */
+    authority: PublicKey;
+    /**
+     * SPL Token account to compress
+     */
+    tokenAccount: PublicKey;
+    /**
+     * SPL Token mint address
+     */
+    mint: PublicKey;
+    /**
+     * Amount to leave in token account
+     */
+    remainingAmount?: BN;
+    /**
+     * State tree to write to
+     */
+    outputStateTreeInfo: TreeInfo;
+    /**
+     * Token pool
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+type DecompressParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Source compressed token accounts
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Destination uncompressed token account
+     */
+    toAddress: PublicKey;
+    /**
+     * Token amount to decompress
+     */
+    amount: number | BN;
+    /**
+     * Validity proof for input state
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * Recent state root indices
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * Token pool(s)
+     */
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[];
+};
+type TransferParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Source compressed token accounts
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Recipient address
+     */
+    toAddress: PublicKey;
+    /**
+     * Token amount to transfer
+     */
+    amount: BN | number;
+    /**
+     * Validity proof for input state
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * Recent state root indices
+     */
+    recentInputStateRootIndices: number[];
+};
+type ApproveParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Source compressed token accounts
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Recipient address
+     */
+    toAddress: PublicKey;
+    /**
+     * Token amount to approve
+     */
+    amount: BN | number;
+    /**
+     * Validity proof for input state
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * Recent state root indices
+     */
+    recentInputStateRootIndices: number[];
+};
+type RevokeParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Input compressed token accounts
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Validity proof for input state
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * Recent state root indices
+     */
+    recentInputStateRootIndices: number[];
+};
+/**
+ * Create Mint account for compressed Tokens
+ */
+type CreateMintParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * SPL Mint address
+     */
+    mint: PublicKey;
+    /**
+     * Mint authority
+     */
+    authority: PublicKey;
+    /**
+     * Optional: freeze authority
+     */
+    freezeAuthority: PublicKey | null;
+    /**
+     * Mint decimals
+     */
+    decimals: number;
+    /**
+     * lamport amount for mint account rent exemption
+     */
+    rentExemptBalance: number;
+    /**
+     * Optional: The token program ID. Default: SPL Token Program ID
+     */
+    tokenProgramId?: PublicKey;
+    /**
+     * Optional: Mint size to use, defaults to MINT_SIZE
+     */
+    mintSize?: number;
+};
+/**
+ * Parameters for merging compressed token accounts
+ */
+type MergeTokenAccountsParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Owner of the compressed token accounts to be merged
+     */
+    owner: PublicKey;
+    /**
+     * SPL Token mint address
+     */
+    mint: PublicKey;
+    /**
+     * Array of compressed token accounts to merge
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Validity proof for state inclusion
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * State root indices of the input state
+     */
+    recentInputStateRootIndices: number[];
+};
+/**
+ * Create compressed token accounts
+ */
+type MintToParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * Token mint address
+     */
+    mint: PublicKey;
+    /**
+     * Mint authority
+     */
+    authority: PublicKey;
+    /**
+     * Recipient address(es)
+     */
+    toPubkey: PublicKey[] | PublicKey;
+    /**
+     * Token amount(s) to mint
+     */
+    amount: BN | BN[] | number | number[];
+    /**
+     * State tree for minted tokens
+     */
+    outputStateTreeInfo: TreeInfo;
+    /**
+     * Token pool
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+/**
+ * Register an existing SPL mint account to the compressed token program
+ * Creates an omnibus account for the mint
+ */
+type CreateTokenPoolParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * SPL Mint address
+     */
+    mint: PublicKey;
+    /**
+     * Optional: The token program ID. Default: SPL Token Program ID
+     */
+    tokenProgramId?: PublicKey;
+};
+type AddTokenPoolParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * Token mint address
+     */
+    mint: PublicKey;
+    /**
+     * Token pool index
+     */
+    poolIndex: number;
+    /**
+     * Optional: Token program ID. Default: SPL Token Program ID
+     */
+    tokenProgramId?: PublicKey;
+};
+/**
+ * Mint from existing SPL mint to compressed token accounts
+ */
+type ApproveAndMintToParams = {
+    /**
+     * Fee payer
+     */
+    feePayer: PublicKey;
+    /**
+     * SPL Mint address
+     */
+    mint: PublicKey;
+    /**
+     * Mint authority
+     */
+    authority: PublicKey;
+    /**
+     * Mint authority (associated) token account
+     */
+    authorityTokenAccount: PublicKey;
+    /**
+     * Recipient address
+     */
+    toPubkey: PublicKey;
+    /**
+     * Token amount to mint
+     */
+    amount: BN | number;
+    /**
+     * State tree to write to
+     */
+    outputStateTreeInfo: TreeInfo;
+    /**
+     * Token pool
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+type CreateTokenProgramLookupTableParams = {
+    /**
+     * Fee payer
+     */
+    payer: PublicKey;
+    /**
+     * Authority of the transaction
+     */
+    authority: PublicKey;
+    /**
+     * Optional Mint addresses to store in the lookup table
+     */
+    mints?: PublicKey[];
+    /**
+     * Recently finalized Solana slot
+     */
+    recentSlot: number;
+    /**
+     * Optional additional addresses to store in the lookup table
+     */
+    remainingAccounts?: PublicKey[];
+};
 /**
- * Selects the minimum number of compressed token accounts required for a transfer, up to a specified maximum.
- *
- * @param {ParsedTokenAccount[]} accounts - Token accounts to choose from.
- * @param {BN} transferAmount - Amount to transfer.
- * @param {number} [maxInputs=4] - Max accounts to select. Default is 4.
- * @returns {[
- *   selectedAccounts: ParsedTokenAccount[],
- *   total: BN,
- *   totalLamports: BN | null,
- *   maxPossibleAmount: BN
- * ]} - Returns:
- *   - selectedAccounts: Accounts chosen for transfer.
- *   - total: Total amount from selected accounts.
- *   - totalLamports: Total lamports from selected accounts.
- *   - maxPossibleAmount: Max transferable amount given maxInputs.
- *
- * @example
- * const accounts = [
- *   { parsed: { amount: new BN(100) }, compressedAccount: { lamports: new BN(10) } },
- *   { parsed: { amount: new BN(50) }, compressedAccount: { lamports: new BN(5) } },
- *   { parsed: { amount: new BN(25) }, compressedAccount: { lamports: new BN(2) } },
- * ];
- * const transferAmount = new BN(75);
- * const maxInputs = 2;
- *
- * const [selectedAccounts, total, totalLamports, maxPossibleAmount] =
- *   selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount, maxInputs);
- *
- * console.log(selectedAccounts.length); // 2
- * console.log(total.toString()); // '150'
- * console.log(totalLamports!.toString()); // '15'
+ * Sum up the token amounts of the compressed token accounts
  */
-declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
 /**
- * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
- * returns partial amounts if insufficient accounts are found instead of
- * throwing an error.
+ * Validate that all the compressed token accounts are owned by the same owner.
  */
-declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
 /**
- * Selects compressed token accounts for a transfer, ensuring one extra account
- * if possible, up to maxInputs.
- *
- * 1. Sorts accounts by amount (desc)
- * 2. Selects accounts until transfer amount is met or maxInputs is reached,
- *    attempting to add one extra account if possible.
- *
- * @param {ParsedTokenAccount[]} accounts - The list of token accounts to select from.
- * @param {BN} transferAmount - The token amount to be transferred.
- * @param {number} [maxInputs=4] - The maximum number of accounts to select. Default: 4.
- * @returns {[
- *   selectedAccounts: ParsedTokenAccount[],
- *   total: BN,
- *   totalLamports: BN | null,
- *   maxPossibleAmount: BN
- * ]} - An array containing:
- *   - selectedAccounts: The accounts selected for the transfer.
- *   - total: The total amount accumulated from the selected accounts.
- *   - totalLamports: The total lamports accumulated from the selected accounts.
- *   - maxPossibleAmount: The maximum possible amount that can be transferred considering maxInputs.
- *
- * @example
- * const accounts = [
- *   { parsed: { amount: new BN(100) }, compressedAccount: { lamports: new BN(10) } },
- *   { parsed: { amount: new BN(50) }, compressedAccount: { lamports: new BN(5) } },
- *   { parsed: { amount: new BN(25) }, compressedAccount: { lamports: new BN(2) } },
- * ];
- * const transferAmount = new BN(75);
- * const maxInputs = 2;
- *
- * const [selectedAccounts, total, totalLamports, maxPossibleAmount] =
- *   selectSmartCompressedTokenAccountsForTransfer(accounts, transferAmount, maxInputs);
- *
- * console.log(selectedAccounts.length); // 2
- * console.log(total.toString()); // '150'
- * console.log(totalLamports!.toString()); // '15'
- * console.log(maxPossibleAmount.toString()); // '150'
+ * Parse compressed token accounts to get the mint, current owner and delegate.
  */
-declare function selectSmartCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
+    mint: PublicKey;
+    currentOwner: PublicKey;
+    delegate: PublicKey | null;
+};
+declare const parseMaybeDelegatedTransfer: (inputs: ParsedTokenAccount[], outputs: TokenTransferOutputData[]) => {
+    delegatedTransfer: DelegatedTransfer | null;
+    authority: PublicKey;
+};
 /**
- * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
- * returns partial amounts if insufficient accounts are found instead of
- * throwing an error.
+ * Create the output state for a transfer transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param toAddress                     Recipient address
+ * @param amount                        Amount of tokens to transfer
+ * @returns                             Output token data for the transfer
+ *                                      instruction
  */
-declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData[];
+/**
+ * Create the output state for a compress transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param amount                        Amount of tokens to compress
+ * @returns                             Output token data for the compress
+ *                                      instruction
+ */
+declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData[];
+declare class CompressedTokenProgram {
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * Public key that identifies the CompressedPda program
+     */
+    static programId: PublicKey;
+    /**
+     * Set a custom programId via PublicKey or base58 encoded string.
+     * This method is not required for regular usage.
+     *
+     * Use this only if you know what you are doing.
+     */
+    static setProgramId(programId: PublicKey | string): void;
+    /**
+     * Derive the token pool pda.
+     * To derive the token pool pda with bump, use {@link deriveTokenPoolPdaWithIndex}.
+     *
+     * @param mint The mint of the token pool
+     *
+     * @returns The token pool pda
+     */
+    static deriveTokenPoolPda(mint: PublicKey): PublicKey;
+    /**
+     * Find the index and bump for a given token pool pda and mint.
+     *
+     * @param poolPda The token pool pda to find the index and bump for
+     * @param mint The mint of the token pool
+     *
+     * @returns The index and bump number.
+     */
+    static findTokenPoolIndexAndBump(poolPda: PublicKey, mint: PublicKey): [number, number];
+    /**
+     * Derive the token pool 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
+     * per mint.
+     *
+     * @returns The token pool pda and bump.
+     */
+    static deriveTokenPoolPdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
+    /** @internal */
+    static get deriveCpiAuthorityPda(): PublicKey;
+    /**
+     * Construct createMint instruction for compressed tokens.
+     *
+     * @param feePayer              Fee payer.
+     * @param mint                  SPL Mint address.
+     * @param authority             Mint authority.
+     * @param freezeAuthority       Optional: freeze authority.
+     * @param decimals              Decimals.
+     * @param rentExemptBalance     Lamport amount for mint account rent exemption.
+     * @param tokenProgramId        Optional: Token program ID. Default: SPL Token Program ID
+     * @param mintSize              Optional: mint size. Default: MINT_SIZE
+     *
+     * @returns [createMintAccountInstruction, initializeMintInstruction,
+     * createTokenPoolInstruction]
+     *
+     * Note that `createTokenPoolInstruction` must be executed after
+     * `initializeMintInstruction`.
+     */
+    static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
+    /**
+     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * For new mints, use `CompressedTokenProgram.createMint`.
+     *
+     * @param feePayer              Fee payer.
+     * @param mint                  SPL Mint address.
+     * @param tokenProgramId        Optional: Token program ID. Default: SPL
+     *                              Token Program ID
+     *
+     * @returns The createTokenPool instruction
+     */
+    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateTokenPoolParams): Promise<TransactionInstruction>;
+    /**
+     * Add a token pool to an existing SPL mint.  For new mints, use
+     * {@link createTokenPool}.
+     *
+     * @param feePayer              Fee payer.
+     * @param mint                  SPL Mint address.
+     * @param poolIndex             Pool index.
+     * @param tokenProgramId        Optional: Token program ID. Default: SPL
+     *                              Token Program ID
+     *
+     * @returns The addTokenPool instruction
+     */
+    static addTokenPool({ feePayer, mint, poolIndex, tokenProgramId, }: AddTokenPoolParams): Promise<TransactionInstruction>;
+    /**
+     * Construct mintTo instruction for compressed tokens
+     *
+     * @param feePayer              Fee payer.
+     * @param mint                  SPL Mint address.
+     * @param authority             Mint authority.
+     * @param toPubkey              Recipient owner address.
+     * @param amount                Amount of tokens to mint.
+     * @param outputStateTreeInfo   State tree to write to.
+     * @param tokenPoolInfo         Token pool info.
+     *
+     * @returns The mintTo instruction
+     */
+    static mintTo({ feePayer, mint, authority, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: MintToParams): Promise<TransactionInstruction>;
+    /**
+     * Mint tokens from registered SPL mint account to a compressed account
+     *
+     * @param feePayer              Fee payer.
+     * @param mint                  SPL Mint address.
+     * @param authority             Mint authority.
+     * @param authorityTokenAccount The mint authority's associated token
+     *                              account (ATA).
+     * @param toPubkey              Recipient owner address.
+     * @param amount                Amount of tokens to mint.
+     * @param outputStateTreeInfo   State tree to write to.
+     * @param tokenPoolInfo         Token pool info.
+     *
+     * @returns The mintTo instruction
+     */
+    static approveAndMintTo({ feePayer, mint, authority, authorityTokenAccount, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    /**
+     * Construct transfer instruction for compressed tokens
+     *
+     * @param payer                         Fee payer.
+     * @param inputCompressedTokenAccounts  Source compressed token accounts.
+     * @param toAddress                     Recipient owner address.
+     * @param amount                        Amount of tokens to transfer.
+     * @param recentValidityProof           Recent validity proof.
+     * @param recentInputStateRootIndices   Recent state root indices.
+     *
+     * @returns The transfer instruction
+     */
+    static transfer({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: TransferParams): Promise<TransactionInstruction>;
+    /**
+     * Create lookup table instructions for the token program's default
+     * accounts.
+     *
+     * @param payer                     Fee payer.
+     * @param authority                 Authority.
+     * @param mints                     Mints.
+     * @param recentSlot                Recent slot.
+     * @param remainingAccounts         Remaining accounts.
+     *
+     * @returns [createInstruction, extendInstruction, option(extendInstruction2)]
+     */
+    static createTokenProgramLookupTable({ payer, authority, mints, recentSlot, remainingAccounts, }: CreateTokenProgramLookupTableParams): Promise<{
+        instructions: TransactionInstruction[];
+        address: PublicKey;
+    }>;
+    /**
+     * Create compress instruction
+     *
+     * @param payer                         Fee payer.
+     * @param owner                         Owner of uncompressed token account.
+     * @param source                        Source SPL Token account address.
+     * @param toAddress                     Recipient owner address(es).
+     * @param amount                        Amount of tokens to compress.
+     * @param mint                          SPL Token mint address.
+     * @param outputStateTreeInfo           State tree to write to.
+     * @param tokenPoolInfo                 Token pool info.
+     *
+     * @returns The compress instruction
+     */
+    static compress({ payer, owner, source, toAddress, amount, mint, outputStateTreeInfo, tokenPoolInfo, }: CompressParams): Promise<TransactionInstruction>;
+    /**
+     * Construct decompress instruction
+     *
+     * @param payer                         Fee payer.
+     * @param inputCompressedTokenAccounts  Source compressed token accounts.
+     * @param toAddress                     Destination **uncompressed** token
+     *                                      account address. (ATA)
+     * @param amount                        Amount of tokens to decompress.
+     * @param recentValidityProof           Recent validity proof.
+     * @param recentInputStateRootIndices   Recent state root indices.
+     * @param tokenPoolInfos                Token pool info.
+     *
+     * @returns The decompress instruction
+     */
+    static decompress({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, tokenPoolInfos, }: DecompressParams): Promise<TransactionInstruction>;
+    /**
+     * Create `mergeTokenAccounts` instruction
+     *
+     * @param payer                         Fee payer.
+     * @param owner                         Owner of the compressed token
+     *                                      accounts to be merged.
+     * @param inputCompressedTokenAccounts  Source compressed token accounts.
+     * @param mint                          SPL Token mint address.
+     * @param recentValidityProof           Recent validity proof.
+     * @param recentInputStateRootIndices   Recent state root indices.
+     *
+     * @returns instruction
+     */
+    static mergeTokenAccounts({ payer, owner, inputCompressedTokenAccounts, mint, recentValidityProof, recentInputStateRootIndices, }: MergeTokenAccountsParams): Promise<TransactionInstruction[]>;
+    /**
+     * Create `compressSplTokenAccount` instruction
+     *
+     * @param feePayer              Fee payer.
+     * @param authority             SPL Token account owner.
+     * @param tokenAccount          SPL Token account to compress.
+     * @param mint                  SPL Token mint address.
+     * @param remainingAmount       Optional: Amount to leave in token account.
+     * @param outputStateTreeInfo   State tree to write to.
+     * @param tokenPoolInfo         Token pool info.
+     *
+     * @returns instruction
+     */
+    static compressSplTokenAccount({ feePayer, authority, tokenAccount, mint, remainingAmount, outputStateTreeInfo, tokenPoolInfo, }: CompressSplTokenAccountParams): Promise<TransactionInstruction>;
+    /**
+     * Get the program ID for a mint
+     *
+     * @param mint                  SPL Token mint address.
+     * @param connection            Connection.
+     *
+     * @returns program ID
+     */
+    static getMintProgramId(mint: PublicKey, connection: Connection): Promise<PublicKey | undefined>;
+    /**
+     * Create `approve` instruction to delegate compressed tokens.
+     *
+     * @param payer                         Fee payer.
+     * @param inputCompressedTokenAccounts  Source compressed token accounts.
+     * @param toAddress                     Owner to delegate to.
+     * @param amount                        Amount of tokens to delegate.
+     * @param recentValidityProof           Recent validity proof.
+     * @param recentInputStateRootIndices   Recent state root indices.
+     *
+     * @returns instruction
+     */
+    static approve({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: ApproveParams): Promise<TransactionInstruction>;
+    /**
+     * Create `revoke` instruction to revoke delegation of compressed tokens.
+     *
+     * @param payer                         Fee payer.
+     * @param inputCompressedTokenAccounts  Source compressed token accounts.
+     * @param recentValidityProof           Recent validity proof.
+     * @param recentInputStateRootIndices   Recent state root indices.
+     *
+     * @returns instruction
+     */
+    static revoke({ payer, inputCompressedTokenAccounts, recentValidityProof, recentInputStateRootIndices, }: RevokeParams): Promise<TransactionInstruction>;
+}
 
-export { type ApproveAndMintToParams, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedCpiContext, type CompressedTokenInstructionDataTransfer, CompressedTokenInstructionDataTransferLayout, CompressedTokenProgram, CpiContextLayout, type CreateMintParams, 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, type RegisterMintParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, TRANSFER_DISCRIMINATOR, type TokenData, type TokenTransferOutputData, type TransferParams, type approveAccountsLayoutParams, approveAndMintTo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, createDecompressOutputState, createMint, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferOutputState, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeTransferInstructionData, decompress, encodeCompressSplTokenAccountInstructionData, encodeMintToInstructionData, encodeTransferInstructionData, type freezeAccountsLayoutParams, mergeTokenAccounts, mintTo, mintToAccountsLayout, type mintToAccountsLayoutParams, mintToLayout, packCompressedTokenAccounts, parseTokenData, type revokeAccountsLayoutParams, selectMinCompressedTokenAccountsForTransfer, selectMinCompressedTokenAccountsForTransferOrPartial, selectSmartCompressedTokenAccountsForTransfer, selectSmartCompressedTokenAccountsForTransferOrPartial, sumUpTokenAmount, type thawAccountsLayoutParams, transfer, transferAccountsLayout, type transferAccountsLayoutParams, validateSameTokenOwner };
+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 };