@lightprotocol/compressed-token 0.12.0 → 0.13.0

package/dist/types/index.d.ts

@@ -1,9 +1,23 @@
-import { CompressedProof, ParsedTokenAccount, TokenTransferOutputData as TokenTransferOutputData$1, InputTokenDataWithContext as InputTokenDataWithContext$1, Rpc } from '@lightprotocol/stateless.js';
-import { PublicKey, AccountMeta, TransactionInstruction, Signer, ConfirmOptions, TransactionSignature, Keypair } from '@solana/web3.js';
+import {
+    CompressedProof,
+    ParsedTokenAccount,
+    TokenTransferOutputData as TokenTransferOutputData$1,
+    InputTokenDataWithContext as InputTokenDataWithContext$1,
+    Rpc,
+} from '@lightprotocol/stateless.js';
+import {
+    PublicKey,
+    AccountMeta,
+    TransactionInstruction,
+    Signer,
+    ConfirmOptions,
+    TransactionSignature,
+    Keypair,
+} from '@solana/web3.js';
 import { BN, Program } from '@coral-xyz/anchor';
 
 type LightCompressedToken = {
-    version: '1.0.0';
+    version: '1.2.0';
     name: 'light_compressed_token';
     instructions: [
         {
@@ -12,7 +26,7 @@ type LightCompressedToken = {
                 'This instruction creates a token pool for a given mint. Every spl mint',
                 'can have one token pool. When a token is compressed the tokens are',
                 'transferrred to the token pool, and their compressed equivalent is',
-                'minted into a Merkle tree.'
+                'minted into a Merkle tree.',
             ];
             accounts: [
                 {
@@ -45,7 +59,7 @@ type LightCompressedToken = {
                     name: 'cpiAuthorityPda';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [];
         },
@@ -58,7 +72,7 @@ type LightCompressedToken = {
                 'every amount and pubkey input pair. A constant amount of lamports can be',
                 'transferred to each output account to enable. A use case to add lamports',
                 'to a compressed token account is to prevent spam. This is the only way',
-                'to add lamports to a compressed token account.'
+                'to add lamports to a compressed token account.',
             ];
             accounts: [
                 {
@@ -87,7 +101,7 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                     docs: [
-                        'account to a token account of a different mint will fail'
+                        'account to a token account of a different mint will fail',
                     ];
                 },
                 {
@@ -141,7 +155,7 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
-                }
+                },
             ];
             args: [
                 {
@@ -161,7 +175,7 @@ type LightCompressedToken = {
                     type: {
                         option: 'u64';
                     };
-                }
+                },
             ];
         },
         {
@@ -174,7 +188,7 @@ type LightCompressedToken = {
                 'accounts specify less lamports than inputs the remaining lamports are',
                 'transferred to an output compressed account. Signer must be owner or',
                 'delegate. If a delegated token account is transferred the delegate is',
-                'not preserved.'
+                'not preserved.',
             ];
             accounts: [
                 {
@@ -190,7 +204,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.'
+                        'validity proof.',
                     ];
                 },
                 {
@@ -251,13 +265,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
@@ -268,7 +282,7 @@ type LightCompressedToken = {
                 'be called by a delegate.',
                 'The instruction creates two output accounts:',
                 '1. one account with delegated amount',
-                '2. one account with remaining(change) amount'
+                '2. one account with remaining(change) amount',
             ];
             accounts: [
                 {
@@ -284,7 +298,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.'
+                        'validity proof.',
                     ];
                 },
                 {
@@ -327,20 +341,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
             name: 'revoke';
             docs: [
                 'Revokes a delegation. The instruction merges all inputs into one output',
-                'account. Cannot be called by a delegate. Delegates are not preserved.'
+                'account. Cannot be called by a delegate. Delegates are not preserved.',
             ];
             accounts: [
                 {
@@ -356,7 +370,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.'
+                        'validity proof.',
                     ];
                 },
                 {
@@ -399,20 +413,20 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
             name: 'freeze';
             docs: [
                 'Freezes compressed token accounts. Inputs must not be frozen. Creates as',
-                'many outputs as inputs. Balances and delegates are preserved.'
+                'many outputs as inputs. Balances and delegates are preserved.',
             ];
             accounts: [
                 {
@@ -471,20 +485,20 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
             name: 'thaw';
             docs: [
                 'Thaws frozen compressed token accounts. Inputs must be frozen. Creates',
-                'as many outputs as inputs. Balances and delegates are preserved.'
+                'as many outputs as inputs. Balances and delegates are preserved.',
             ];
             accounts: [
                 {
@@ -543,13 +557,13 @@ type LightCompressedToken = {
                     name: 'mint';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
@@ -557,7 +571,7 @@ type LightCompressedToken = {
             docs: [
                 'Burns compressed tokens and spl tokens from the pool account. Delegates',
                 'can burn tokens. The output compressed token account remains delegated.',
-                'Creates one output compressed token account.'
+                'Creates one output compressed token account.',
             ];
             accounts: [
                 {
@@ -573,7 +587,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.'
+                        'validity proof.',
                     ];
                 },
                 {
@@ -630,13 +644,13 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
                     name: 'inputs';
                     type: 'bytes';
-                }
+                },
             ];
         },
         {
@@ -644,7 +658,7 @@ type LightCompressedToken = {
             docs: [
                 'This function is a stub to allow Anchor to include the input types in',
                 'the IDL. It should not be included in production builds nor be called in',
-                'practice.'
+                'practice.',
             ];
             accounts: [
                 {
@@ -660,7 +674,7 @@ type LightCompressedToken = {
                     docs: [
                         'Authority is verified through proof since both owner and delegate',
                         'are included in the token data hash, which is a public input to the',
-                        'validity proof.'
+                        'validity proof.',
                     ];
                 },
                 {
@@ -721,7 +735,7 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
-                }
+                },
             ];
             args: [
                 {
@@ -735,9 +749,9 @@ type LightCompressedToken = {
                     type: {
                         defined: 'TokenData';
                     };
-                }
+                },
             ];
-        }
+        },
     ];
     types: [
         {
@@ -753,7 +767,7 @@ type LightCompressedToken = {
                     {
                         name: 'programOwner';
                         docs: [
-                            'Program owner of the Merkle tree. This will be used for program owned Merkle trees.'
+                            'Program owner of the Merkle tree. This will be used for program owned Merkle trees.',
                         ];
                         type: 'publicKey';
                     },
@@ -765,10 +779,10 @@ type LightCompressedToken = {
                             'forested by light foresters. The variable is not used in the account',
                             'compression program but the registry program. The registry program',
                             'implements access control to prevent contention during forester. The',
-                            'forester pubkey specified in this struct can bypass contention checks.'
+                            'forester pubkey specified in this struct can bypass contention checks.',
                         ];
                         type: 'publicKey';
-                    }
+                    },
                 ];
             };
         },
@@ -782,7 +796,7 @@ type LightCompressedToken = {
                     },
                     {
                         name: 'Frozen';
-                    }
+                    },
                 ];
             };
         },
@@ -814,7 +828,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedAccountData';
                             };
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -838,7 +852,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -851,7 +865,7 @@ type LightCompressedToken = {
                         name: 'setContext';
                         docs: [
                             'Is set by the program that is invoking the CPI to signal that is should',
-                            'set the cpi context.'
+                            'set the cpi context.',
                         ];
                         type: 'bool';
                     },
@@ -859,17 +873,17 @@ type LightCompressedToken = {
                         name: 'firstSetContext';
                         docs: [
                             'Is set to wipe the cpi context since someone could have set it before',
-                            'with unrelated data.'
+                            'with unrelated data.',
                         ];
                         type: 'bool';
                     },
                     {
                         name: 'cpiContextAccountIndex';
                         docs: [
-                            'Index of cpi context account in remaining accounts.'
+                            'Index of cpi context account in remaining accounts.',
                         ];
                         type: 'u8';
-                    }
+                    },
                 ];
             };
         },
@@ -895,7 +909,7 @@ type LightCompressedToken = {
                         type: {
                             array: ['u8', 32];
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -921,7 +935,7 @@ type LightCompressedToken = {
                         docs: [
                             'Is required if the signer is delegate,',
                             '-> delegate is authority account,',
-                            'owner = Some(owner) is the owner of the token account.'
+                            'owner = Some(owner) is the owner of the token account.',
                         ];
                         type: {
                             option: {
@@ -968,14 +982,14 @@ type LightCompressedToken = {
                         type: {
                             option: 'u8';
                         };
-                    }
+                    },
                 ];
             };
         },
         {
             name: 'DelegatedTransfer';
             docs: [
-                'Struct to provide the owner when the delegate is signer of the transaction.'
+                'Struct to provide the owner when the delegate is signer of the transaction.',
             ];
             type: {
                 kind: 'struct';
@@ -990,12 +1004,12 @@ type LightCompressedToken = {
                             'Index of change compressed account in output compressed accounts. In',
                             "case that the delegate didn't spend the complete delegated compressed",
                             'account balance the change compressed account will be delegated to her',
-                            'as well.'
+                            'as well.',
                         ];
                         type: {
                             option: 'u8';
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1033,12 +1047,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1094,7 +1108,7 @@ type LightCompressedToken = {
                     {
                         name: 'isCompress';
                         type: 'bool';
-                    }
+                    },
                 ];
             };
         },
@@ -1158,7 +1172,7 @@ type LightCompressedToken = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1186,7 +1200,7 @@ type LightCompressedToken = {
                     {
                         name: 'nextMerkleTree';
                         type: 'publicKey';
-                    }
+                    },
                 ];
             };
         },
@@ -1202,7 +1216,7 @@ type LightCompressedToken = {
                     {
                         name: 'seq';
                         type: 'u64';
-                    }
+                    },
                 ];
             };
         },
@@ -1228,7 +1242,7 @@ type LightCompressedToken = {
                     {
                         name: 'addressMerkleTreeRootIndex';
                         type: 'u16';
-                    }
+                    },
                 ];
             };
         },
@@ -1246,7 +1260,7 @@ type LightCompressedToken = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
-                    }
+                    },
                 ];
             };
         },
@@ -1270,17 +1284,17 @@ type LightCompressedToken = {
                     {
                         name: 'rootIndex';
                         docs: [
-                            'Index of root used in inclusion validity proof.'
+                            'Index of root used in inclusion validity proof.',
                         ];
                         type: 'u16';
                     },
                     {
                         name: 'readOnly';
                         docs: [
-                            'Placeholder to mark accounts read-only unimplemented set to false.'
+                            'Placeholder to mark accounts read-only unimplemented set to false.',
                         ];
                         type: 'bool';
-                    }
+                    },
                 ];
             };
         },
@@ -1305,14 +1319,14 @@ type LightCompressedToken = {
                         name: 'queueIndex';
                         docs: [
                             'Index of leaf in queue. Placeholder of batched Merkle tree updates',
-                            'currently unimplemented.'
+                            'currently unimplemented.',
                         ];
                         type: {
                             option: {
                                 defined: 'QueueIndex';
                             };
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1342,12 +1356,12 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1421,7 +1435,7 @@ type LightCompressedToken = {
                         type: {
                             option: 'bytes';
                         };
-                    }
+                    },
                 ];
             };
         },
@@ -1439,7 +1453,7 @@ type LightCompressedToken = {
                         name: 'index';
                         docs: ['Index of compressed account hash in queue.'];
                         type: 'u16';
-                    }
+                    },
                 ];
             };
         },
@@ -1457,14 +1471,14 @@ type LightCompressedToken = {
                         name: 'rolloverFee';
                         docs: [
                             'This fee is used for rent for the next account.',
-                            'It accumulates in the account so that once the corresponding Merkle tree account is full it can be rolled over'
+                            'It accumulates in the account so that once the corresponding Merkle tree account is full it can be rolled over',
                         ];
                         type: 'u64';
                     },
                     {
                         name: 'rolloverThreshold';
                         docs: [
-                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).'
+                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).',
                         ];
                         type: 'u64';
                     },
@@ -1476,7 +1490,7 @@ type LightCompressedToken = {
                     {
                         name: 'rolledoverSlot';
                         docs: [
-                            'The slot when the account was rolled over, a rolled over account should not be written to.'
+                            'The slot when the account was rolled over, a rolled over account should not be written to.',
                         ];
                         type: 'u64';
                     },
@@ -1485,7 +1499,7 @@ type LightCompressedToken = {
                         docs: [
                             'If current slot is greater than rolledover_slot + close_threshold and',
                             "the account is empty it can be closed. No 'close' functionality has been",
-                            'implemented yet.'
+                            'implemented yet.',
                         ];
                         type: 'u64';
                     },
@@ -1493,10 +1507,10 @@ type LightCompressedToken = {
                         name: 'additionalBytes';
                         docs: [
                             'Placeholder for bytes of additional accounts which are tied to the',
-                            'Merkle trees operation and need to be rolled over as well.'
+                            'Merkle trees operation and need to be rolled over as well.',
                         ];
                         type: 'u64';
-                    }
+                    },
                 ];
             };
         },
@@ -1524,7 +1538,7 @@ type LightCompressedToken = {
                         name: 'delegate';
                         docs: [
                             'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate'
+                            'the amount authorized by the delegate',
                         ];
                         type: {
                             option: 'publicKey';
@@ -1540,142 +1554,37 @@ type LightCompressedToken = {
                     {
                         name: 'tlv';
                         docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
                         ];
                         type: {
                             option: 'bytes';
                         };
-                    }
+                    },
                 ];
             };
-        }
+        },
     ];
     errors: [
         {
             code: 6000;
-            name: 'PublicKeyAmountMissmatch';
-            msg: 'public keys and amounts must be of same length';
+            name: 'SignerCheckFailed';
+            msg: 'Signer check failed';
         },
         {
             code: 6001;
-            name: 'ComputeInputSumFailed';
-            msg: 'ComputeInputSumFailed';
+            name: 'CreateTransferInstructionFailed';
+            msg: 'Create transfer instruction failed';
         },
         {
             code: 6002;
-            name: 'ComputeOutputSumFailed';
-            msg: 'ComputeOutputSumFailed';
+            name: 'AccountNotFound';
+            msg: 'Account not found';
         },
         {
             code: 6003;
-            name: 'ComputeCompressSumFailed';
-            msg: 'ComputeCompressSumFailed';
-        },
-        {
-            code: 6004;
-            name: 'ComputeDecompressSumFailed';
-            msg: 'ComputeDecompressSumFailed';
-        },
-        {
-            code: 6005;
-            name: 'SumCheckFailed';
-            msg: 'SumCheckFailed';
-        },
-        {
-            code: 6006;
-            name: 'DecompressRecipientUndefinedForDecompress';
-            msg: 'DecompressRecipientUndefinedForDecompress';
-        },
-        {
-            code: 6007;
-            name: 'CompressedPdaUndefinedForDecompress';
-            msg: 'CompressedPdaUndefinedForDecompress';
-        },
-        {
-            code: 6008;
-            name: 'DeCompressAmountUndefinedForDecompress';
-            msg: 'DeCompressAmountUndefinedForDecompress';
-        },
-        {
-            code: 6009;
-            name: 'CompressedPdaUndefinedForCompress';
-            msg: 'CompressedPdaUndefinedForCompress';
-        },
-        {
-            code: 6010;
-            name: 'DeCompressAmountUndefinedForCompress';
-            msg: 'DeCompressAmountUndefinedForCompress';
-        },
-        {
-            code: 6011;
-            name: 'DelegateSignerCheckFailed';
-            msg: 'DelegateSignerCheckFailed';
-        },
-        {
-            code: 6012;
-            name: 'MintTooLarge';
-            msg: 'Minted amount greater than u64::MAX';
+            name: 'SerializationError';
+            msg: 'Serialization error';
         },
-        {
-            code: 6013;
-            name: 'SplTokenSupplyMismatch';
-            msg: 'SplTokenSupplyMismatch';
-        },
-        {
-            code: 6014;
-            name: 'HeapMemoryCheckFailed';
-            msg: 'HeapMemoryCheckFailed';
-        },
-        {
-            code: 6015;
-            name: 'InstructionNotCallable';
-            msg: 'The instruction is not callable';
-        },
-        {
-            code: 6016;
-            name: 'ArithmeticUnderflow';
-            msg: 'ArithmeticUnderflow';
-        },
-        {
-            code: 6017;
-            name: 'HashToFieldError';
-            msg: 'HashToFieldError';
-        },
-        {
-            code: 6018;
-            name: 'InvalidAuthorityMint';
-            msg: 'Expected the authority to be also a mint authority';
-        },
-        {
-            code: 6019;
-            name: 'InvalidFreezeAuthority';
-            msg: 'Provided authority is not the freeze authority';
-        },
-        {
-            code: 6020;
-            name: 'InvalidDelegateIndex';
-        },
-        {
-            code: 6021;
-            name: 'TokenPoolPdaUndefined';
-        },
-        {
-            code: 6022;
-            name: 'IsTokenPoolPda';
-            msg: 'Compress or decompress recipient is the same account as the token pool pda.';
-        },
-        {
-            code: 6023;
-            name: 'InvalidTokenPoolPda';
-        },
-        {
-            code: 6024;
-            name: 'NoInputTokenAccountsProvided';
-        },
-        {
-            code: 6025;
-            name: 'NoInputsProvided';
-        }
     ];
 };
 declare const IDL: LightCompressedToken;
@@ -1835,7 +1744,9 @@ type PackCompressedTokenAccountsParams = {
 /**
  * Packs Compressed Token Accounts.
  */
-declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
+declare function packCompressedTokenAccounts(
+    params: PackCompressedTokenAccountsParams,
+): {
     inputTokenDataWithContext: InputTokenDataWithContext$1[];
     remainingAccountMetas: AccountMeta[];
     packedOutputTokenData: PackedTokenTransferOutputData[];
@@ -1974,6 +1885,39 @@ type CreateMintParams = {
      */
     rentExemptBalance: 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: 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[];
+};
 /**
  * Create compressed token accounts
  */
@@ -2081,7 +2025,9 @@ declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
 /**
  * Parse compressed token accounts to get the mint, current owner and delegate.
  */
-declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
+declare const parseTokenData: (
+    compressedTokenAccounts: ParsedTokenAccount[],
+) => {
     mint: PublicKey;
     currentOwner: PublicKey;
     delegate: PublicKey | null;
@@ -2094,7 +2040,11 @@ declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) =>
  * @returns                             Output token data for the transfer
  *                                      instruction
  */
-declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData$1[];
+declare function createTransferOutputState(
+    inputCompressedTokenAccounts: ParsedTokenAccount[],
+    toAddress: PublicKey,
+    amount: number | BN,
+): TokenTransferOutputData$1[];
 /**
  * Create the output state for a compress transaction.
  * @param inputCompressedTokenAccounts  Input state
@@ -2102,7 +2052,10 @@ declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedT
  * @returns                             Output token data for the compress
  *                                      instruction
  */
-declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData$1[];
+declare function createDecompressOutputState(
+    inputCompressedTokenAccounts: ParsedTokenAccount[],
+    amount: number | BN,
+): TokenTransferOutputData$1[];
 declare class CompressedTokenProgram {
     /**
      * @internal
@@ -2127,12 +2080,16 @@ declare class CompressedTokenProgram {
     /**
      * Construct createMint instruction for compressed tokens
      */
-    static createMint(params: CreateMintParams): Promise<TransactionInstruction[]>;
+    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>;
+    static createTokenPool(
+        params: RegisterMintParams,
+    ): Promise<TransactionInstruction>;
     /**
      * Construct mintTo instruction for compressed tokens
      */
@@ -2140,7 +2097,9 @@ declare class CompressedTokenProgram {
     /**
      * Mint tokens from registed SPL mint account to a compressed account
      */
-    static approveAndMintTo(params: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    static approveAndMintTo(
+        params: ApproveAndMintToParams,
+    ): Promise<TransactionInstruction[]>;
     /**
      * Construct transfer instruction for compressed tokens
      */
@@ -2148,7 +2107,9 @@ declare class CompressedTokenProgram {
     /**
      * Create lookup table instructions for the token program's default accounts.
      */
-    static createTokenProgramLookupTable(params: CreateTokenProgramLookupTableParams): Promise<{
+    static createTokenProgramLookupTable(
+        params: CreateTokenProgramLookupTableParams,
+    ): Promise<{
         instructions: TransactionInstruction[];
         address: PublicKey;
     }>;
@@ -2160,7 +2121,12 @@ declare class CompressedTokenProgram {
     /**
      * Construct decompress instruction
      */
-    static decompress(params: DecompressParams): Promise<TransactionInstruction>;
+    static decompress(
+        params: DecompressParams,
+    ): Promise<TransactionInstruction>;
+    static mergeTokenAccounts(
+        params: MergeTokenAccountsParams,
+    ): Promise<TransactionInstruction[]>;
 }
 
 /**
@@ -2178,7 +2144,16 @@ declare class CompressedTokenProgram {
  *
  * @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): Promise<TransactionSignature>;
+declare function approveAndMintTo(
+    rpc: Rpc,
+    payer: Signer,
+    mint: PublicKey,
+    destination: PublicKey,
+    authority: Signer,
+    amount: number | BN,
+    merkleTree?: PublicKey,
+    confirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature>;
 
 /**
  * Compress SPL tokens
@@ -2198,7 +2173,17 @@ declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, dest
  *
  * @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): Promise<TransactionSignature>;
+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,
+): Promise<TransactionSignature>;
 
 /**
  * Decompress compressed tokens
@@ -2218,7 +2203,16 @@ declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: numb
  *
  * @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): Promise<TransactionSignature>;
+declare function decompress(
+    rpc: Rpc,
+    payer: Signer,
+    mint: PublicKey,
+    amount: number | BN,
+    owner: Signer,
+    toAddress: PublicKey,
+    merkleTree?: PublicKey,
+    confirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature>;
 
 /**
  * Create and initialize a new compressed token mint
@@ -2232,7 +2226,14 @@ declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: nu
  *
  * @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): Promise<{
+declare function createMint(
+    rpc: Rpc,
+    payer: Signer,
+    mintAuthority: PublicKey,
+    decimals: number,
+    keypair?: Keypair,
+    confirmOptions?: ConfirmOptions,
+): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
@@ -2254,7 +2255,38 @@ declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey, d
  *
  * @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): Promise<TransactionSignature>;
+declare function mintTo(
+    rpc: Rpc,
+    payer: Signer,
+    mint: PublicKey,
+    destination: PublicKey | PublicKey[],
+    authority: Signer,
+    amount: number | BN | number[] | BN[],
+    merkleTree?: PublicKey,
+    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 merkleTree      Optional merkle tree for compressed tokens
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Array of transaction signatures
+ */
+declare function mergeTokenAccounts(
+    rpc: Rpc,
+    payer: Signer,
+    mint: PublicKey,
+    owner: Signer,
+    merkleTree?: PublicKey,
+    confirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature>;
 
 /**
  * Register an existing mint with the CompressedToken program
@@ -2267,7 +2299,12 @@ declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: P
  *
  * @return transaction signature
  */
-declare function createTokenPool(rpc: Rpc, payer: Signer, mintAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function createTokenPool(
+    rpc: Rpc,
+    payer: Signer,
+    mintAddress: PublicKey,
+    confirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature>;
 
 /**
  * Transfer compressed tokens from one owner to another
@@ -2286,7 +2323,16 @@ declare function createTokenPool(rpc: Rpc, payer: Signer, mintAddress: PublicKey
  *
  * @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>;
+declare function transfer(
+    rpc: Rpc,
+    payer: Signer,
+    mint: PublicKey,
+    amount: number | BN,
+    owner: Signer,
+    toAddress: PublicKey,
+    merkleTree?: PublicKey,
+    confirmOptions?: ConfirmOptions,
+): Promise<TransactionSignature>;
 /**
  * Selects the minimal number of compressed token accounts for a transfer.
  *
@@ -2294,10 +2340,13 @@ declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: numb
  * 2. Accumulates the amount until it is greater than or equal to the transfer
  *    amount
  */
-declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN): [
+declare function selectMinCompressedTokenAccountsForTransfer(
+    accounts: ParsedTokenAccount[],
+    transferAmount: BN,
+): [
     selectedAccounts: ParsedTokenAccount[],
     total: BN,
-    totalLamports: BN | null
+    totalLamports: BN | null,
 ];
 
 /**
@@ -2313,9 +2362,51 @@ declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTok
  *
  * @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<{
+declare function createTokenProgramLookupTable(
+    rpc: Rpc,
+    payer: Signer,
+    authority: Signer,
+    mints?: PublicKey[],
+    additionalAccounts?: PublicKey[],
+): Promise<{
     txIds: TransactionSignature[];
     address: PublicKey;
 }>;
 
-export { type ApproveAndMintToParams, CPI_AUTHORITY_SEED, type CompressedTokenInstructionDataInvoke, CompressedTokenProgram, type CreateMintParams, type CreateTokenProgramLookupTableParams, IDL, type InputTokenDataWithContext, type LightCompressedToken, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedTokenTransferOutputData, type RegisterMintParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type TokenData, type TokenTransferOutputData, type TransferParams, approveAndMintTo, compress, createDecompressOutputState, createMint, createTokenPool, createTokenProgramLookupTable, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
+export {
+    type ApproveAndMintToParams,
+    CPI_AUTHORITY_SEED,
+    type CompressedTokenInstructionDataInvoke,
+    CompressedTokenProgram,
+    type CreateMintParams,
+    type CreateTokenProgramLookupTableParams,
+    IDL,
+    type InputTokenDataWithContext,
+    type LightCompressedToken,
+    type MergeTokenAccountsParams,
+    type MintToParams,
+    POOL_SEED,
+    type PackCompressedTokenAccountsParams,
+    type PackedTokenTransferOutputData,
+    type RegisterMintParams,
+    SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE,
+    type TokenData,
+    type TokenTransferOutputData,
+    type TransferParams,
+    approveAndMintTo,
+    compress,
+    createDecompressOutputState,
+    createMint,
+    createTokenPool,
+    createTokenProgramLookupTable,
+    createTransferOutputState,
+    decompress,
+    mergeTokenAccounts,
+    mintTo,
+    packCompressedTokenAccounts,
+    parseTokenData,
+    selectMinCompressedTokenAccountsForTransfer,
+    sumUpTokenAmount,
+    transfer,
+    validateSameTokenOwner,
+};