@lightprotocol/compressed-token 0.21.0 → 0.22.0

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 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 { 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';
@@ -8,10 +8,10 @@ import * as buffer_layout from 'buffer-layout';
  * 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 payer                 Fee payer
+ * @param mint                  SPL Mint address
  * @param amount                Number of tokens to delegate
- * @param owner                 Owner of the compressed tokens
+ * @param owner                 Owner of the SPL token account.
  * @param delegate              Address of the delegate
  * @param confirmOptions        Options for confirming the transaction
  *
@@ -76,6 +76,10 @@ type TokenPoolInfo = {
      * The index of the token pool
      */
     poolIndex: number;
+    /**
+     * The bump used to derive the token pool pda
+     */
+    bump: number;
 };
 /**
  * @internal
@@ -86,8 +90,11 @@ declare enum Action {
     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
@@ -111,78 +118,79 @@ declare function selectTokenPoolInfosForDecompression(infos: TokenPoolInfo[], de
  * 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 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   State tree info
- * @param tokenPoolInfo         Token pool info
+ * @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 approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, toPubkey: PublicKey, authority: Signer, amount: number | BN, outputStateTreeInfo?: TreeInfo, 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 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?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN | number[] | BN[], owner: Signer, sourceTokenAccount: PublicKey, toAddress: PublicKey | Array<PublicKey>, outputStateTreeInfo?: TreeInfo, 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 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   State tree to insert the compressed token
+ * @param outputStateTreeInfo   Optional: State tree account that the compressed
  *                              account into
- * @param tokenPoolInfo         Token pool info
+ * @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?: StateTreeInfo, tokenPoolInfo?: TokenPoolInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+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 to use
- * @param payer             Payer of the transaction and initialization fees
- * @param mintAuthority     Account or multisig that will control minting
+ * @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 keypair, defaulting to a new random one
+ * @param keypair           Optional: Mint keypair. Defaults to a random
+ *                          keypair.
  * @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.
+ * @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 Address of the new mint and the transaction signature
+ * @return Object with mint address and transaction signature
  */
-declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions, tokenProgramId?: PublicKey | boolean, freezeAuthority?: PublicKey): Promise<{
+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;
     transactionSignature: TransactionSignature;
 }>;
@@ -190,9 +198,9 @@ declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey, d
 /**
  * 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 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
@@ -203,11 +211,12 @@ declare function createTokenPool(rpc: Rpc, payer: Signer, mint: PublicKey, confi
 /**
  * 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 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
  *
@@ -219,14 +228,15 @@ declare function addTokenPools(rpc: Rpc, payer: Signer, mint: PublicKey, numMaxA
  * 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 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 Transaction signatures and the address of the created lookup table
+ * @return Object with transaction signatures and the address of the created
+ *         lookup table
  */
 declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authority: Signer, mints?: PublicKey[], additionalAccounts?: PublicKey[]): Promise<{
     txIds: TransactionSignature[];
@@ -236,17 +246,17 @@ declare function createTokenProgramLookupTable(rpc: Rpc, payer: Signer, authorit
 /**
  * Decompress compressed tokens
  *
- * @param rpc                   Rpc to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint of the compressed token
+ * @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** (associated) token
- *                              account address.
- * @param tokenPoolInfos        Token pool infos
+ * @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
+ * @return confirmed transaction signature
  */
 declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
@@ -254,44 +264,44 @@ declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: nu
  * 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 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 signature of the confirmed transaction
+ * @return confirmed transaction signature
  */
 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 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             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 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 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>;
+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>;
 
 /**
  * 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 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
  *
@@ -302,30 +312,30 @@ declare function revoke(rpc: Rpc, payer: Signer, accounts: ParsedTokenAccount[],
 /**
  * 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 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 Signature of the confirmed transaction
+ * @return confirmed transaction signature
  */
 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 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 Signature of the confirmed transaction
+ * @return confirmed transaction signature
  */
 declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
@@ -333,25 +343,151 @@ declare function transferDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amo
  * 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 rpc                   Rpc connection to use
+ * @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** (associated) token
- *                              account address.
- * @param tokenPoolInfos        Token pool infos
+ * @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 decompressDelegated(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, tokenPoolInfos?: TokenPoolInfo[], confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
-type CompressedCpiContext = {
-    setContext: boolean;
-    firstSetContext: boolean;
-    cpiContextAccountIndex: number;
+declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
+/**
+ * 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.
+ */
+declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
+/**
+ * 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.
+ */
+declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number): {
+    selectedAccounts: ParsedTokenAccount[];
+    total: BN;
+    totalLamports: BN | null;
+    maxPossibleAmount: BN;
 };
+/**
+ * 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
+ * ]
+ */
+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
+];
+/**
+ * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
+ * returns partial amounts if insufficient accounts are found instead of
+ * throwing an error.
+ */
+declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    totalLamports: BN | null,
+    maxPossibleAmount: BN
+];
+
 type TokenTransferOutputData = {
     /**
      * The owner of the output token account
@@ -395,7 +531,7 @@ type PackedTokenTransferOutputData = {
 type InputTokenDataWithContext = {
     amount: BN;
     delegateIndex: number | null;
-    merkleContext: PackedMerkleContext;
+    merkleContext: PackedMerkleContextLegacy;
     rootIndex: number;
     lamports: BN | null;
     tlv: Buffer | null;
@@ -404,6 +540,14 @@ 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[];
@@ -426,7 +570,6 @@ type CompressedTokenInstructionDataTransfer = {
     mint: PublicKey;
     /**
      * Whether the signer is a delegate
-     * TODO: implement delegated transfer struct
      */
     delegatedTransfer: DelegatedTransfer | null;
     /**
@@ -483,7 +626,7 @@ type TokenData = {
     tlv: Buffer | null;
 };
 type CompressedTokenInstructionDataApprove = {
-    proof: ValidityProof;
+    proof: ValidityProof | null;
     mint: PublicKey;
     inputTokenDataWithContext: InputTokenDataWithContext[];
     cpiContext: CompressedCpiContext | null;
@@ -494,7 +637,7 @@ type CompressedTokenInstructionDataApprove = {
     delegateLamports: BN | null;
 };
 type CompressedTokenInstructionDataRevoke = {
-    proof: ValidityProof;
+    proof: ValidityProof | null;
     mint: PublicKey;
     inputTokenDataWithContext: InputTokenDataWithContext[];
     cpiContext: CompressedCpiContext | null;
@@ -509,7 +652,7 @@ type PackCompressedTokenAccountsParams = {
      * state tree of the input state. Gets padded to the length of
      * outputCompressedAccounts.
      */
-    outputStateTreeInfo?: StateTreeInfo;
+    outputStateTreeInfo?: TreeInfo;
     /** Optional remaining accounts to append to */
     remainingAccounts?: PublicKey[];
     /**
@@ -528,142 +671,21 @@ declare function packCompressedTokenAccounts(params: PackCompressedTokenAccounts
     packedOutputTokenData: PackedTokenTransferOutputData[];
 };
 
-declare const ERROR_NO_ACCOUNTS_FOUND = "Could not find accounts to select for transfer.";
-/**
- * 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.
- */
-declare function selectTokenAccountsForApprove(accounts: ParsedTokenAccount[], approveAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
-/**
- * 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.
- */
-declare function selectMinCompressedTokenAccountsForDecompression(accounts: ParsedTokenAccount[], amount: BN, maxInputs?: number): {
-    selectedAccounts: ParsedTokenAccount[];
-    total: BN;
-    totalLamports: BN | null;
-    maxPossibleAmount: BN;
-};
 /**
- * Selects the minimum number of compressed token accounts required for a
- * transfer or decompression instruction, up to a specified maximum.
+ * Check if all input accounts belong to the same mint.
  *
- * @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
- * ]
- */
-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.
+ * @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 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
-];
-/**
- * Executes {@link selectMinCompressedTokenAccountsForTransfer} strategy,
- * returns partial amounts if insufficient accounts are found instead of
- * throwing an error.
- */
-declare function selectSmartCompressedTokenAccountsForTransferOrPartial(accounts: ParsedTokenAccount[], transferAmount: BN, maxInputs?: number): [
-    selectedAccounts: ParsedTokenAccount[],
-    total: BN,
-    totalLamports: BN | null,
-    maxPossibleAmount: BN
-];
+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;
@@ -2153,7 +2175,7 @@ type LightCompressedToken = {
                         type: 'u8';
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex';
+                        name: 'queuePubkeyIndex';
                         type: 'u8';
                     },
                     {
@@ -2161,12 +2183,8 @@ type LightCompressedToken = {
                         type: 'u32';
                     },
                     {
-                        name: 'queueIndex';
-                        type: {
-                            option: {
-                                defined: 'QueueIndex';
-                            };
-                        };
+                        name: 'proveByIndex';
+                        type: 'bool';
                     }
                 ];
             };
@@ -2512,9 +2530,12 @@ 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;
@@ -2577,109 +2598,105 @@ declare function decodeRevokeInstructionData(buffer: Buffer): CompressedTokenIns
 
 type CompressParams = {
     /**
-     * The payer of the transaction.
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * owner of the *uncompressed* token account.
+     * Owner of uncompressed token account
      */
     owner: PublicKey;
     /**
-     * source (associated) token account address.
+     * Source SPL Token account address
      */
     source: PublicKey;
     /**
-     * owner of the compressed token account.
-     * To compress to a batch of recipients, pass an array of PublicKeys.
+     * Recipient address(es)
      */
     toAddress: PublicKey | PublicKey[];
     /**
-     * Mint address of the token to compress.
+     * Token amount(s) to compress
      */
-    mint: PublicKey;
+    amount: number | BN | number[] | BN[];
     /**
-     * amount of tokens to compress.
+     * SPL Token mint address
      */
-    amount: number | BN | number[] | BN[];
+    mint: PublicKey;
     /**
-     * The state tree that the tx output should be inserted into. Defaults to a
-     * public state tree if unspecified.
+     * State tree to write to
      */
-    outputStateTreeInfo: StateTreeInfo;
+    outputStateTreeInfo: TreeInfo;
     /**
-     * Tokenpool.
+     * Token pool
      */
     tokenPoolInfo: TokenPoolInfo;
 };
 type CompressSplTokenAccountParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
     /**
-     * Authority that owns the token account
+     * SPL Token account owner
      */
     authority: PublicKey;
     /**
-     * Token account to compress
+     * SPL Token account to compress
      */
     tokenAccount: PublicKey;
     /**
-     * Mint public key
+     * SPL Token mint address
      */
     mint: PublicKey;
     /**
-     * Optional: remaining amount to leave in token account. Default: 0
+     * Amount to leave in token account
      */
     remainingAmount?: BN;
     /**
-     * The state tree that the compressed token account should be inserted into.
+     * State tree to write to
      */
-    outputStateTreeInfo: StateTreeInfo;
+    outputStateTreeInfo: TreeInfo;
     /**
-     * The token pool info.
+     * Token pool
      */
     tokenPoolInfo: TokenPoolInfo;
 };
 type DecompressParams = {
     /**
-     * The payer of the transaction.
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * input state to be consumed
+     * Source compressed token accounts
      */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
     /**
-     * address of **uncompressed** destination token account.
+     * Destination uncompressed token account
      */
     toAddress: PublicKey;
     /**
-     * amount of tokens to decompress.
+     * Token amount to decompress
      */
     amount: number | BN;
     /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
+     * Validity proof for input state
      */
-    recentInputStateRootIndices: number[];
+    recentValidityProof: ValidityProof | CompressedProof | null;
     /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
+     * Recent state root indices
      */
-    recentValidityProof: ValidityProof | CompressedProof;
+    recentInputStateRootIndices: number[];
     /**
-     * Tokenpool addresses. One or more token pools can be provided.
+     * Token pool(s)
      */
     tokenPoolInfos: TokenPoolInfo | TokenPoolInfo[];
 };
 type TransferParams = {
     /**
-     * The payer of the transaction
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * The input state to be consumed
+     * Source compressed token accounts
      */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
     /**
@@ -2687,65 +2704,86 @@ type TransferParams = {
      */
     toAddress: PublicKey;
     /**
-     * Amount of tokens to transfer
+     * Token amount to transfer
      */
     amount: BN | number;
     /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
+     * Validity proof for input state
+     */
+    recentValidityProof: ValidityProof | CompressedProof | null;
+    /**
+     * Recent state root indices
      */
     recentInputStateRootIndices: number[];
+};
+type ApproveParams = {
     /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
+     * Fee payer
      */
-    recentValidityProof: ValidityProof | CompressedProof;
+    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 ApproveParams = TransferParams;
 type RevokeParams = {
     /**
-     * The payer of the transaction
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * The input state to be consumed
+     * Input compressed token accounts
      */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
     /**
-     * The recent state root indices of the input state. The expiry is tied to
-     * the proof.
+     * Validity proof for input state
      */
-    recentInputStateRootIndices: number[];
+    recentValidityProof: ValidityProof | CompressedProof | null;
     /**
-     * The recent validity proof for state inclusion of the input state. It
-     * expires after n slots.
+     * Recent state root indices
      */
-    recentValidityProof: ValidityProof | CompressedProof;
+    recentInputStateRootIndices: number[];
 };
 /**
  * Create Mint account for compressed Tokens
  */
 type CreateMintParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
+    /**
+     * SPL Mint address
+     */
+    mint: PublicKey;
     /**
      * Mint authority
      */
     authority: PublicKey;
     /**
-     * Mint public key
+     * Optional: freeze authority
      */
-    mint: PublicKey;
+    freezeAuthority: PublicKey | null;
     /**
      * Mint decimals
      */
     decimals: number;
-    /**
-     * Optional: freeze authority
-     */
-    freezeAuthority: PublicKey | null;
     /**
      * lamport amount for mint account rent exemption
      */
@@ -2764,15 +2802,15 @@ type CreateMintParams = {
  */
 type MergeTokenAccountsParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * Owner of the token accounts to be merged
+     * Owner of the compressed token accounts to be merged
      */
     owner: PublicKey;
     /**
-     * Mint public key
+     * SPL Token mint address
      */
     mint: PublicKey;
     /**
@@ -2780,11 +2818,11 @@ type MergeTokenAccountsParams = {
      */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
     /**
-     * Optional: Recent validity proof for state inclusion
+     * Validity proof for state inclusion
      */
-    recentValidityProof: ValidityProof;
+    recentValidityProof: ValidityProof | CompressedProof | null;
     /**
-     * Optional: Recent state root indices of the input state
+     * State root indices of the input state
      */
     recentInputStateRootIndices: number[];
 };
@@ -2793,31 +2831,31 @@ type MergeTokenAccountsParams = {
  */
 type MintToParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
     /**
-     * Mint authority
+     * Token mint address
      */
-    authority: PublicKey;
+    mint: PublicKey;
     /**
-     * Mint public key
+     * Mint authority
      */
-    mint: PublicKey;
+    authority: PublicKey;
     /**
-     * The Solana Public Keys to mint to.
+     * Recipient address(es)
      */
     toPubkey: PublicKey[] | PublicKey;
     /**
-     * The amount of compressed tokens to mint.
+     * Token amount(s) to mint
      */
     amount: BN | BN[] | number | number[];
     /**
-     * The state tree to mint into.
+     * State tree for minted tokens
      */
-    outputStateTreeInfo: StateTreeInfo;
+    outputStateTreeInfo: TreeInfo;
     /**
-     * Tokenpool addresses. One or more token pools can be provided.
+     * Token pool
      */
     tokenPoolInfo: TokenPoolInfo;
 };
@@ -2825,13 +2863,13 @@ type MintToParams = {
  * Register an existing SPL mint account to the compressed token program
  * Creates an omnibus account for the mint
  */
-type RegisterMintParams = {
+type CreateTokenPoolParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
     /**
-     * Mint public key
+     * SPL Mint address
      */
     mint: PublicKey;
     /**
@@ -2841,30 +2879,34 @@ type RegisterMintParams = {
 };
 type AddTokenPoolParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
     /**
-     * Mint public key
+     * Token mint address
      */
     mint: PublicKey;
     /**
-     * Optional: The token program ID. Default: SPL Token Program ID
+     * Token pool index
      */
-    tokenProgramId?: PublicKey;
+    poolIndex: number;
     /**
-     * Optional: index for the token pool. Default: 0
+     * Optional: Token program ID. Default: SPL Token Program ID
      */
-    poolIndex: number;
+    tokenProgramId?: PublicKey;
 };
 /**
  * Mint from existing SPL mint to compressed token accounts
  */
 type ApproveAndMintToParams = {
     /**
-     * Tx feepayer
+     * Fee payer
      */
     feePayer: PublicKey;
+    /**
+     * SPL Mint address
+     */
+    mint: PublicKey;
     /**
      * Mint authority
      */
@@ -2874,46 +2916,41 @@ type ApproveAndMintToParams = {
      */
     authorityTokenAccount: PublicKey;
     /**
-     * Mint public key
-     */
-    mint: PublicKey;
-    /**
-     * The Solana Public Key to mint to.
+     * Recipient address
      */
     toPubkey: PublicKey;
     /**
-     * The amount of compressed tokens to mint.
+     * Token amount to mint
      */
     amount: BN | number;
     /**
-     * The state tree to mint into. Defaults to a public state
-     * tree if unspecified.
+     * State tree to write to
      */
-    outputStateTreeInfo: StateTreeInfo;
+    outputStateTreeInfo: TreeInfo;
     /**
-     * Tokenpool addresses. One or more token pools can be provided.
+     * Token pool
      */
     tokenPoolInfo: TokenPoolInfo;
 };
 type CreateTokenProgramLookupTableParams = {
     /**
-     * The payer of the transaction.
+     * Fee payer
      */
     payer: PublicKey;
     /**
-     * The authority of the transaction.
+     * Authority of the transaction
      */
     authority: PublicKey;
     /**
-     *  Recently finalized Solana slot.
+     * Optional Mint addresses to store in the lookup table
      */
-    recentSlot: number;
+    mints?: PublicKey[];
     /**
-     * Optional Mint addresses to store in the lookup table.
+     * Recently finalized Solana slot
      */
-    mints?: PublicKey[];
+    recentSlot: number;
     /**
-     * Optional additional addresses to store in the lookup table.
+     * Optional additional addresses to store in the lookup table
      */
     remainingAccounts?: PublicKey[];
 };
@@ -2972,7 +3009,7 @@ declare class CompressedTokenProgram {
     static setProgramId(programId: PublicKey | string): void;
     /**
      * Derive the token pool pda.
-     * To derive the token pool pda with bump, use {@link deriveTokenPoolPdaWithBump}.
+     * To derive the token pool pda with bump, use {@link deriveTokenPoolPdaWithIndex}.
      *
      * @param mint The mint of the token pool
      *
@@ -2980,67 +3017,220 @@ declare class CompressedTokenProgram {
      */
     static deriveTokenPoolPda(mint: PublicKey): PublicKey;
     /**
-     * Derive the token pool pda with bump.
+     * 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
-     * @param bump Bump. starts at 0. The Protocol supports 4 bumps aka token pools
+     *
+     * @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
+     * @returns The token pool pda and bump.
      */
-    static deriveTokenPoolPdaWithBump(mint: PublicKey, bump: number): PublicKey;
+    static deriveTokenPoolPdaWithIndex(mint: PublicKey, index: number): [PublicKey, number];
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
     /**
      * Construct createMint instruction for compressed tokens.
-     * @returns [createMintAccountInstruction, initializeMintInstruction, createTokenPoolInstruction]
      *
-     * Note that `createTokenPoolInstruction` must be executed after `initializeMintInstruction`.
+     * @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(params: CreateMintParams): Promise<TransactionInstruction[]>;
+    static createMint({ feePayer, mint, authority, freezeAuthority, decimals, rentExemptBalance, tokenProgramId, mintSize, }: CreateMintParams): Promise<TransactionInstruction[]>;
     /**
      * Enable compression for an existing SPL mint, creating an omnibus account.
      * For new mints, use `CompressedTokenProgram.createMint`.
+     *
+     * @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(params: RegisterMintParams): Promise<TransactionInstruction>;
+    static createTokenPool({ feePayer, mint, tokenProgramId, }: CreateTokenPoolParams): Promise<TransactionInstruction>;
     /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
-     * For new mints, use `CompressedTokenProgram.createMint`.
+     * 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(params: AddTokenPoolParams): Promise<TransactionInstruction>;
+    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(params: MintToParams): Promise<TransactionInstruction>;
+    static mintTo({ feePayer, mint, authority, toPubkey, amount, outputStateTreeInfo, tokenPoolInfo, }: MintToParams): Promise<TransactionInstruction>;
     /**
      * Mint tokens from registered SPL mint account to a compressed account
+     *
+     * @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(params: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    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(params: TransferParams): Promise<TransactionInstruction>;
+    static transfer({ payer, inputCompressedTokenAccounts, toAddress, amount, recentValidityProof, recentInputStateRootIndices, }: TransferParams): Promise<TransactionInstruction>;
     /**
-     * Create lookup table instructions for the token program's default accounts.
+     * 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(params: CreateTokenProgramLookupTableParams): Promise<{
+    static createTokenProgramLookupTable({ payer, authority, mints, recentSlot, remainingAccounts, }: CreateTokenProgramLookupTableParams): Promise<{
         instructions: TransactionInstruction[];
         address: PublicKey;
     }>;
     /**
      * Create compress instruction
-     * @returns compressInstruction
+     *
+     * @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(params: CompressParams): Promise<TransactionInstruction>;
+    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 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>;
+    /**
+     * 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 { 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 };
+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 };