@lightprotocol/compressed-token 0.20.9 → 0.21.0

package/dist/types/index.d.ts

@@ -1,8 +1,351 @@
-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, StateTreeInfo, ParsedTokenAccount, PackedMerkleContext, 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';
+
+/**
+ * Approve a delegate to spend 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 delegate
+ * @param owner                 Owner of the compressed tokens
+ * @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;
+    action: Action;
+};
+/**
+ * Token pool pda info.
+ */
+type TokenPoolInfo = {
+    /**
+     * The mint of the token pool
+     */
+    mint: PublicKey;
+    /**
+     * The token pool address
+     */
+    tokenPoolPda: PublicKey;
+    /**
+     * The token program of the token pool
+     */
+    tokenProgram: PublicKey;
+    /**
+     * count of txs and volume in the past 60 seconds.
+     */
+    activity?: {
+        txs: number;
+        amountAdded: BN;
+        amountRemoved: BN;
+    };
+    /**
+     * Whether the token pool is initialized
+     */
+    isInitialized: boolean;
+    /**
+     * The balance of the token pool
+     */
+    balance: BN;
+    /**
+     * The index of the token pool
+     */
+    poolIndex: number;
+};
+/**
+ * @internal
+ */
+declare enum Action {
+    Compress = 1,
+    Decompress = 2,
+    Transfer = 3
+}
+/**
+ * Select a random token pool info from the token pool infos.
+ *
+ * @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[];
+
+/**
+ * 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 toPubkey              Address of the account to mint to
+ * @param authority             Minting authority
+ * @param amount                Amount to mint
+ * @param outputStateTreeInfo   State tree info
+ * @param tokenPoolInfo         Token pool info
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Compress SPL tokens
+ *
+ * @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 outputStateTreeInfo   State tree account that the compressed tokens
+ *                              should be inserted into. Defaults to a default
+ *                              state tree account.
+ * @param tokenPoolInfo         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?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * 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 remainingAmount       Optional: amount to leave in token account.
+ *                              Default: 0
+ * @param outputStateTreeInfo   State tree to insert the compressed token
+ *                              account into
+ * @param tokenPoolInfo         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?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * 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.
+ *
+ * @return Address of the new mint and the transaction signature
+ */
+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;
+}>;
+
+/**
+ * Register an existing mint with the CompressedToken program
+ *
+ * @param rpc             RPC to use
+ * @param payer           Payer of the transaction and initialization fees
+ * @param mint            Address of the existing mint
+ * @param confirmOptions  Options for confirming the transaction
+ * @param tokenProgramId  Optional: Address of the token program. Default:
+ *                        TOKEN_PROGRAM_ID
+ *
+ * @return transaction signature
+ */
+declare function createTokenPool(rpc: Rpc, payer: Signer, mint: PublicKey, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
+/**
+ * Create additional token pools for an existing mint
+ *
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param mint                  Address of the existing mint
+ * @param numMaxAdditionalPools Number of additional token pools to create. Max 3.
+ * @param confirmOptions        Options for confirming the transaction
+ * @param tokenProgramId        Optional: Address of the token program. Default:
+ *                              TOKEN_PROGRAM_ID
+ *
+ * @return transaction signature
+ */
+declare function addTokenPools(rpc: Rpc, payer: Signer, mint: PublicKey, numMaxAdditionalPools: number, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<string>;
+
+/**
+ * Create a lookup table for the token program's default accounts
+ *
+ * @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
+ *
+ * @return Transaction signatures and the address of the created lookup table
+ */
+declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
+    txIds: TransactionSignature[];
+    address: PublicKey;
+}>;
+
+/**
+ * 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 tokenPoolInfos        Token pool infos
+ * @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, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Merge multiple compressed token accounts for a given mint into a single
+ * account
+ *
+ * @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 confirmOptions        Options for confirming the transaction
+ *
+ * @return signature of the confirmed transaction
+ */
+declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Mint compressed tokens to a solana address
+ *
+ * @param rpc                   Rpc to use
+ * @param payer                 Payer of the transaction fees
+ * @param mint                  Mint for the account
+ * @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             Minting authority
+ * @param amount                Amount to mint. Can be an array of amounts if
+ *                              the toPubkey is an array of addresses.
+ * @param outputStateTreeInfo   State tree account that the compressed tokens
+ *                              should be part of. Defaults to the default state
+ *                              tree account.
+ * @param tokenPoolInfo         Token pool information
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey | PublicKey[], authority: Signer, amount: number | BN | number[] | BN[], outputStateTreeInfo?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Revoke one or more delegated token accounts
+ *
+ * @param rpc                   Rpc to use
+ * @param payer                 Payer of the transaction fees
+ * @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 function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[], owner: Signer, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Transfer compressed tokens from one owner to another
+ *
+ * @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 confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Transfer delegated compressed tokens to another owner
+ *
+ * @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 confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Decompress delegated compressed tokens. Remaining compressed tokens are
+ * returned to the owner without delegation.
+ *
+ * @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 decompress
+ * @param owner                 Owner of the compressed tokens
+ * @param toAddress             Destination **uncompressed** (associated) token
+ *                              account address.
+ * @param tokenPoolInfos        Token pool infos
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 type CompressedCpiContext = {
     setContext: boolean;
@@ -71,11 +414,12 @@ type CompressSplTokenAccountInstructionData = {
     remainingAmount: BN | null;
     cpiContext: CompressedCpiContext | null;
 };
+declare function isSingleTokenPoolInfo(tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[]): tokenPoolInfos is TokenPoolInfo;
 type CompressedTokenInstructionDataTransfer = {
     /**
      * Validity proof
      */
-    proof: CompressedProof | null;
+    proof: ValidityProof | null;
     /**
      * The mint of the transfer
      */
@@ -138,6 +482,24 @@ type TokenData = {
      */
     tlv: Buffer | null;
 };
+type CompressedTokenInstructionDataApprove = {
+    proof: ValidityProof;
+    mint: PublicKey;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    cpiContext: CompressedCpiContext | null;
+    delegate: PublicKey;
+    delegatedAmount: BN;
+    delegateMerkleTreeIndex: number;
+    changeAccountMerkleTreeIndex: number;
+    delegateLamports: BN | null;
+};
+type CompressedTokenInstructionDataRevoke = {
+    proof: ValidityProof;
+    mint: PublicKey;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    cpiContext: CompressedCpiContext | null;
+    outputAccountMerkleTreeIndex: number;
+};
 
 type PackCompressedTokenAccountsParams = {
     /** Input state to be consumed */
@@ -147,7 +509,7 @@ type PackCompressedTokenAccountsParams = {
      * state tree of the input state. Gets padded to the length of
      * outputCompressedAccounts.
      */
-    outputStateTrees?: PublicKey[] | PublicKey;
+    outputStateTreeInfo?: StateTreeInfo;
     /** Optional remaining accounts to append to */
     remainingAccounts?: PublicKey[];
     /**
@@ -166,659 +528,147 @@ declare function packCompressedTokenAccounts(params: PackCompressedTokenAccounts
     packedOutputTokenData: PackedTokenTransferOutputData[];
 };
 
-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;
-
-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
-     */
-    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.
-
-     */
-    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;
-};
+declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
 /**
- * Create Mint account for compressed Tokens
+ * Selects token accounts for approval, first trying to find an exact match, then falling back to minimum selection.
+ *
+ * @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.
  */
-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 selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Parameters for merging compressed token accounts
+ * Selects the minimum number of compressed token accounts required for a
+ * decompress instruction, up to a specified maximum.
+ *
+ * @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.
+ *
+ * @returns Returns selected accounts and their totals.
  */
-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 selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number): {
+    selectedAccounts: ParsedTokenAccount[];
+    total: BN;
+    totalLamports: BN | null;
+    maxPossibleAmount: BN;
 };
 /**
- * Create compressed token accounts
+ * Selects the minimum number of compressed token accounts required for a
+ * transfer or decompression instruction, up to a specified maximum.
+ *
+ * @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.
+ *
+ * @returns Returns selected accounts and their totals. [
+ *   selectedAccounts: ParsedTokenAccount[],
+ *   total: BN,
+ *   totalLamports: BN | null,
+ *   maxPossibleAmount: BN
+ * ]
  */
-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 selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Register an existing SPL mint account to the compressed token program
- * Creates an omnibus account for the mint
+ * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
+ * returns partial amounts if insufficient accounts are found instead of
+ * throwing an error.
  */
-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 selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 /**
- * Mint from existing SPL mint to compressed token accounts
- */
-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[];
-};
-/**
- * Sum up the token amounts of the compressed token accounts
- */
-declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
-/**
- * Validate that all the compressed token accounts are owned by the same owner.
- */
-declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
-/**
- * Parse compressed token accounts to get the mint, current owner and delegate.
- */
-declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
-    mint: PublicKey;
-    currentOwner: PublicKey;
-    delegate: PublicKey | null;
-};
-/**
- * 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 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;
-    /** @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
- *
- * @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 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>;
-
-/**
- * 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 compressed token accounts for a transfer, ensuring one extra account
+ * if possible, up to maxInputs.
  *
- * @return Address of the new mint and the transaction signature
- */
-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;
-}>;
-
-/**
- * Mint compressed tokens to a solana address
+ * 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 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 - 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 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>;
-
-/**
- * Merge multiple compressed token accounts for a given mint into a single
- * account
+ * @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 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
+ * const [selectedAccounts, total, totalLamports, maxPossibleAmount] =
+ *   selectSmartCompressedTokenAccountsForTransfer(accounts, transferAmount, maxInputs);
  *
- * @return Array of transaction signatures
+ * console.log(selectedAccounts.length); // 2
+ * console.log(total.toString()); // '150'
+ * console.log(totalLamports!.toString()); // '15'
+ * console.log(maxPossibleAmount.toString()); // '150'
  */
-declare function mergeTokenAccounts(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
-
+declare function selectSmartCompressedTokenAccountsForTransfer(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 selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
 
-/**
- * Transfer compressed tokens from one owner to another
- *
- * @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
- *
- *
- * @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
- *
- * @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
- *
- * @return Transaction signatures and the address of the created lookup table
- */
-declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
-    txIds: TransactionSignature[];
-    address: PublicKey;
-}>;
-
-/**
- * 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
- */
-declare function compressSplTokenAccount(rpc: Rpc, payer: Signer, mint: PublicKey, owner: Signer, tokenAccount: PublicKey, outputStateTree: PublicKey, remainingAmount?: BN, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey): Promise<TransactionSignature>;
-
-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 approveAccountsLayoutParams = BaseAccountsLayoutParams;
-type revokeAccountsLayoutParams = approveAccountsLayoutParams;
-type freezeAccountsLayoutParams = BaseAccountsLayoutParams & {
-    mint: PublicKey;
-};
-type thawAccountsLayoutParams = freezeAccountsLayoutParams;
-declare const createTokenPoolAccountsLayout: (accounts: createTokenPoolAccountsLayoutParams) => AccountMeta[];
-declare const mintToAccountsLayout: (accounts: mintToAccountsLayoutParams) => AccountMeta[];
-declare const transferAccountsLayout: (accounts: transferAccountsLayoutParams) => AccountMeta[];
+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;
+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 +1761,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: [
@@ -2560,112 +2508,539 @@ type LightCompressedToken = {
 };
 declare const IDL: LightCompressedToken;
 
-declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
-/**
- * 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'
- */
-declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
-/**
- * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
- * returns partial amounts if insufficient accounts are found instead of
- * throwing an error.
- */
-declare function selectMinCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
-/**
- * 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'
- */
-declare function selectSmartCompressedTokenAccountsForTransfer(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;
+declare function decodeMintToInstructionData(buffer: Buffer): MintToInstructionData;
+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 = {
+    /**
+     * 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.
+     */
+    outputStateTreeInfo: StateTreeInfo;
+    /**
+     * Tokenpool.
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+type CompressSplTokenAccountParams = {
+    /**
+     * Tx feepayer
+     */
+    feePayer: PublicKey;
+    /**
+     * Authority that owns the token account
+     */
+    authority: PublicKey;
+    /**
+     * Token account to compress
+     */
+    tokenAccount: PublicKey;
+    /**
+     * Mint public key
+     */
+    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.
+     */
+    outputStateTreeInfo: StateTreeInfo;
+    /**
+     * The token pool info.
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+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: ValidityProof | CompressedProof;
+    /**
+     * Tokenpool addresses. One or more token pools can be provided.
+     */
+    tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[];
+};
+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.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: ValidityProof | CompressedProof;
+};
+type ApproveParams = TransferParams;
+type RevokeParams = {
+    /**
+     * The payer of the transaction
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * 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: ValidityProof | CompressedProof;
+};
 /**
- * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
- * returns partial amounts if insufficient accounts are found instead of
- * throwing an error.
+ * Create Mint account for compressed Tokens
  */
-declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+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;
+};
+/**
+ * Parameters for merging compressed token accounts
+ */
+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: Recent validity proof for state inclusion
+     */
+    recentValidityProof: ValidityProof;
+    /**
+     * Optional: Recent state root indices of the input state
+     */
+    recentInputStateRootIndices: number[];
+};
+/**
+ * Create compressed token accounts
+ */
+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[];
+    /**
+     * The state tree to mint into.
+     */
+    outputStateTreeInfo: StateTreeInfo;
+    /**
+     * Tokenpool addresses. One or more token pools can be provided.
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+/**
+ * Register an existing SPL mint account to the compressed token program
+ * Creates an omnibus account for the mint
+ */
+type RegisterMintParams = {
+    /**
+     * Tx feepayer
+     */
+    feePayer: PublicKey;
+    /**
+     * Mint public key
+     */
+    mint: PublicKey;
+    /**
+     * Optional: The token program ID. Default: SPL Token Program ID
+     */
+    tokenProgramId?: PublicKey;
+};
+type AddTokenPoolParams = {
+    /**
+     * Tx feepayer
+     */
+    feePayer: PublicKey;
+    /**
+     * Mint public key
+     */
+    mint: PublicKey;
+    /**
+     * Optional: The token program ID. Default: SPL Token Program ID
+     */
+    tokenProgramId?: PublicKey;
+    /**
+     * Optional: index for the token pool. Default: 0
+     */
+    poolIndex: number;
+};
+/**
+ * Mint from existing SPL mint to compressed token accounts
+ */
+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;
+    /**
+     * The state tree to mint into. Defaults to a public state
+     * tree if unspecified.
+     */
+    outputStateTreeInfo: StateTreeInfo;
+    /**
+     * Tokenpool addresses. One or more token pools can be provided.
+     */
+    tokenPoolInfo: TokenPoolInfo;
+};
+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[];
+};
+/**
+ * Sum up the token amounts of the compressed token accounts
+ */
+declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
+/**
+ * Validate that all the compressed token accounts are owned by the same owner.
+ */
+declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
+/**
+ * Parse compressed token accounts to get the mint, current owner and delegate.
+ */
+declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
+    mint: PublicKey;
+    currentOwner: PublicKey;
+    delegate: PublicKey | null;
+};
+declare const parseMaybeDelegatedTransfer: (inputs: ParsedTokenAccount[], outputs: TokenTransferOutputData[]) => {
+    delegatedTransfer: DelegatedTransfer | null;
+    authority: PublicKey;
+};
+/**
+ * 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 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 deriveTokenPoolPdaWithBump}.
+     *
+     * @param mint The mint of the token pool
+     *
+     * @returns The token pool pda
+     */
+    static deriveTokenPoolPda(mint: PublicKey): PublicKey;
+    /**
+     * Derive the token pool pda with bump.
+     *
+     * @param mint The mint of the token pool
+     * @param bump Bump. starts at 0. The Protocol supports 4 bumps aka token pools
+     * per mint.
+     *
+     * @returns The token pool pda
+     */
+    static deriveTokenPoolPdaWithBump(mint: PublicKey, bump: number): 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>;
+    /**
+     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * For new mints, use `CompressedTokenProgram.createMint`.
+     */
+    static addTokenPool(params: AddTokenPoolParams): 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 getMintProgramId(mint: PublicKey, connection: Connection): Promise<PublicKey | undefined>;
+    static approve(params: TransferParams): Promise<TransactionInstruction>;
+    static revoke(params: 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, COMPRESS_SPL_TOKEN_ACCOUNT_DISCRIMINATOR, CPI_AUTHORITY_SEED, CREATE_TOKEN_POOL_DISCRIMINATOR, type CompressParams, type CompressSplTokenAccountInstructionData, type CompressSplTokenAccountParams, type CompressedCpiContext, type CompressedTokenInstructionDataApprove, CompressedTokenInstructionDataApproveLayout, type CompressedTokenInstructionDataRevoke, CompressedTokenInstructionDataRevokeLayout, 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, REVOKE_DISCRIMINATOR, type RegisterMintParams, 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, checkTokenPoolInfo, compress, compressSplTokenAccount, compressSplTokenAccountInstructionDataLayout, createDecompressOutputState, createMint, createTokenPool, createTokenPoolAccountsLayout, type createTokenPoolAccountsLayoutParams, createTokenProgramLookupTable, createTransferOutputState, decodeApproveInstructionData, decodeCompressSplTokenAccountInstructionData, decodeMintToInstructionData, decodeRevokeInstructionData, decodeTransferInstructionData, decompress, decompressDelegated, encodeApproveInstructionData, 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 };