@lightprotocol/compressed-token 0.16.0 → 0.17.1

package/dist/cjs/browser/index.cjs

@@ -89,9 +89,6 @@ const IDL = {
                     name: 'tokenPoolPda',
                     isMut: true,
                     isSigner: false,
-                    docs: [
-                        'account to a token account of a different mint will fail',
-                    ],
                 },
                 {
                     name: 'tokenProgram',
@@ -169,6 +166,11 @@ const IDL = {
         },
         {
             name: 'compressSplTokenAccount',
+            docs: [
+                'Compresses the balance of an spl token account sub an optional remaining',
+                'amount. This instruction does not close the spl token account. To close',
+                'the account bundle a close spl account instruction in your transaction.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
@@ -1162,8 +1164,7 @@ const IDL = {
                         name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined:
-                                    'PackedCompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -1171,8 +1172,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1228,8 +1228,7 @@ const IDL = {
                         name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined:
-                                    'PackedCompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -1237,8 +1236,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1483,8 +1481,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1661,23 +1658,141 @@ const IDL = {
     errors: [
         {
             code: 6000,
-            name: 'SignerCheckFailed',
-            msg: 'Signer check failed',
+            name: 'PublicKeyAmountMissmatch',
+            msg: 'public keys and amounts must be of same length',
         },
         {
             code: 6001,
-            name: 'CreateTransferInstructionFailed',
-            msg: 'Create transfer instruction failed',
+            name: 'ComputeInputSumFailed',
+            msg: 'ComputeInputSumFailed',
         },
         {
             code: 6002,
-            name: 'AccountNotFound',
-            msg: 'Account not found',
+            name: 'ComputeOutputSumFailed',
+            msg: 'ComputeOutputSumFailed',
         },
         {
             code: 6003,
-            name: 'SerializationError',
-            msg: 'Serialization error',
+            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',
+        },
+        {
+            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',
+        },
+        {
+            code: 6026,
+            name: 'MintHasNoFreezeAuthority',
+        },
+        {
+            code: 6027,
+            name: 'MintWithInvalidExtension',
+        },
+        {
+            code: 6028,
+            name: 'InsufficientTokenAccountBalance',
+            msg: 'The token account balance is less than the remaining amount.',
         },
     ],
 };
@@ -1687,37 +1802,20 @@ const IDL = {
  * Packs Compressed Token Accounts.
  */
 function packCompressedTokenAccounts(params) {
-    const {
-        inputCompressedTokenAccounts,
-        outputStateTrees,
-        remainingAccounts = [],
-        rootIndices,
-        tokenTransferOutputs,
-    } = params;
+    const { inputCompressedTokenAccounts, outputStateTrees, remainingAccounts = [], rootIndices, tokenTransferOutputs, } = params;
     const _remainingAccounts = remainingAccounts.slice();
     let delegateIndex = null;
-    if (
-        inputCompressedTokenAccounts.length > 0 &&
-        inputCompressedTokenAccounts[0].parsed.delegate
-    ) {
-        delegateIndex = stateless_js.getIndexOrAdd(
-            _remainingAccounts,
-            inputCompressedTokenAccounts[0].parsed.delegate,
-        );
+    if (inputCompressedTokenAccounts.length > 0 &&
+        inputCompressedTokenAccounts[0].parsed.delegate) {
+        delegateIndex = stateless_js.getIndexOrAdd(_remainingAccounts, inputCompressedTokenAccounts[0].parsed.delegate);
     }
     /// TODO: move pubkeyArray to remainingAccounts
     /// Currently just packs 'delegate' to pubkeyArray
     const packedInputTokenData = [];
     /// pack inputs
     inputCompressedTokenAccounts.forEach((account, index) => {
-        const merkleTreePubkeyIndex = stateless_js.getIndexOrAdd(
-            _remainingAccounts,
-            account.compressedAccount.merkleTree,
-        );
-        const nullifierQueuePubkeyIndex = stateless_js.getIndexOrAdd(
-            _remainingAccounts,
-            account.compressedAccount.nullifierQueue,
-        );
+        const merkleTreePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
+        const nullifierQueuePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
         packedInputTokenData.push({
             amount: account.parsed.amount,
             delegateIndex,
@@ -1735,27 +1833,15 @@ function packCompressedTokenAccounts(params) {
         });
     });
     /// pack output state trees
-    const paddedOutputStateMerkleTrees = stateless_js.padOutputStateMerkleTrees(
-        outputStateTrees,
-        tokenTransferOutputs.length,
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const paddedOutputStateMerkleTrees = stateless_js.padOutputStateMerkleTrees(outputStateTrees, tokenTransferOutputs.length, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const packedOutputTokenData = [];
     paddedOutputStateMerkleTrees.forEach((account, index) => {
         var _a;
-        const merkleTreeIndex = stateless_js.getIndexOrAdd(
-            _remainingAccounts,
-            account,
-        );
+        const merkleTreeIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account);
         packedOutputTokenData.push({
             owner: tokenTransferOutputs[index].owner,
             amount: tokenTransferOutputs[index].amount,
-            lamports: (
-                (_a = tokenTransferOutputs[index].lamports) === null ||
-                _a === void 0
-                    ? void 0
-                    : _a.eq(stateless_js.bn(0))
-            )
+            lamports: ((_a = tokenTransferOutputs[index].lamports) === null || _a === void 0 ? void 0 : _a.eq(stateless_js.bn(0)))
                 ? null
                 : tokenTransferOutputs[index].lamports,
             merkleTreeIndex,
@@ -1763,7 +1849,7 @@ function packCompressedTokenAccounts(params) {
         });
     });
     // to meta
-    const remainingAccountMetas = _remainingAccounts.map(account => ({
+    const remainingAccountMetas = _remainingAccounts.map((account) => ({
         pubkey: account,
         isWritable: true,
         isSigner: false,
@@ -1782,16 +1868,13 @@ const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
 /**
  * Sum up the token amounts of the compressed token accounts
  */
-const sumUpTokenAmount = accounts => {
-    return accounts.reduce(
-        (acc, account) => acc.add(account.parsed.amount),
-        stateless_js.bn(0),
-    );
+const sumUpTokenAmount = (accounts) => {
+    return accounts.reduce((acc, account) => acc.add(account.parsed.amount), stateless_js.bn(0));
 };
 /**
  * Validate that all the compressed token accounts are owned by the same owner.
  */
-const validateSameTokenOwner = accounts => {
+const validateSameTokenOwner = (accounts) => {
     const owner = accounts[0].parsed.owner;
     accounts.forEach(acc => {
         if (!acc.parsed.owner.equals(owner)) {
@@ -1802,7 +1885,7 @@ const validateSameTokenOwner = accounts => {
 /**
  * Parse compressed token accounts to get the mint, current owner and delegate.
  */
-const parseTokenData = compressedTokenAccounts => {
+const parseTokenData = (compressedTokenAccounts) => {
     const mint = compressedTokenAccounts[0].parsed.mint;
     const currentOwner = compressedTokenAccounts[0].parsed.owner;
     const delegate = compressedTokenAccounts[0].parsed.delegate;
@@ -1816,22 +1899,13 @@ const parseTokenData = compressedTokenAccounts => {
  * @returns                             Output token data for the transfer
  *                                      instruction
  */
-function createTransferOutputState(
-    inputCompressedTokenAccounts,
-    toAddress,
-    amount,
-) {
+function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount) {
     amount = stateless_js.bn(amount);
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
-    const inputLamports = stateless_js.sumUpLamports(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const inputLamports = stateless_js.sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const changeAmount = inputAmount.sub(amount);
     stateless_js.validateSufficientBalance(changeAmount);
-    if (
-        changeAmount.eq(stateless_js.bn(0)) &&
-        inputLamports.eq(stateless_js.bn(0))
-    ) {
+    if (changeAmount.eq(stateless_js.bn(0)) && inputLamports.eq(stateless_js.bn(0))) {
         return [
             {
                 owner: toAddress,
@@ -1842,9 +1916,7 @@ function createTransferOutputState(
         ];
     }
     /// validates token program
-    stateless_js.validateSameOwner(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    stateless_js.validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     validateSameTokenOwner(inputCompressedTokenAccounts);
     const outputCompressedAccounts = [
         {
@@ -1871,22 +1943,15 @@ function createTransferOutputState(
  */
 function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
     amount = stateless_js.bn(amount);
-    const inputLamports = stateless_js.sumUpLamports(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const inputLamports = stateless_js.sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
     const changeAmount = inputAmount.sub(amount);
     stateless_js.validateSufficientBalance(changeAmount);
     /// lamports gets decompressed
-    if (
-        changeAmount.eq(stateless_js.bn(0)) &&
-        inputLamports.eq(stateless_js.bn(0))
-    ) {
+    if (changeAmount.eq(stateless_js.bn(0)) && inputLamports.eq(stateless_js.bn(0))) {
         return [];
     }
-    stateless_js.validateSameOwner(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    stateless_js.validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     validateSameTokenOwner(inputCompressedTokenAccounts);
     const tokenTransferOutputs = [
         {
@@ -1902,7 +1967,7 @@ class CompressedTokenProgram {
     /**
      * @internal
      */
-    constructor() {}
+    constructor() { }
     /**
      * Set a custom programId via PublicKey or base58 encoded string.
      * This method is not required for regular usage.
@@ -1934,85 +1999,70 @@ class CompressedTokenProgram {
             /// program only for serde and building instructions, not for
             /// interacting with the network.
             const mockKeypair = web3_js.Keypair.generate();
-            const mockConnection = new web3_js.Connection(
-                'http://127.0.0.1:8899',
-                'confirmed',
-            );
-            const mockProvider = new anchor.AnchorProvider(
-                mockConnection,
-                stateless_js.useWallet(mockKeypair),
-                stateless_js.confirmConfig,
-            );
+            const mockConnection = new web3_js.Connection('http://127.0.0.1:8899', 'confirmed');
+            const mockProvider = new anchor.AnchorProvider(mockConnection, stateless_js.useWallet(mockKeypair), stateless_js.confirmConfig);
             anchor.setProvider(mockProvider);
-            this._program = new anchor.Program(
-                IDL,
-                this.programId,
-                mockProvider,
-            );
+            this._program = new anchor.Program(IDL, this.programId, mockProvider);
         }
     }
     /** @internal */
     static deriveTokenPoolPda(mint) {
         const seeds = [POOL_SEED, mint.toBuffer()];
-        const [address, _] = web3_js.PublicKey.findProgramAddressSync(
-            seeds,
-            this.programId,
-        );
+        const [address, _] = web3_js.PublicKey.findProgramAddressSync(seeds, this.programId);
         return address;
     }
     /** @internal */
     static get deriveCpiAuthorityPda() {
-        const [address, _] = web3_js.PublicKey.findProgramAddressSync(
-            [CPI_AUTHORITY_SEED],
-            this.programId,
-        );
+        const [address, _] = web3_js.PublicKey.findProgramAddressSync([CPI_AUTHORITY_SEED], this.programId);
         return address;
     }
     /**
-     * Construct createMint instruction for compressed tokens
+     * Construct createMint instruction for compressed tokens.
+     * @returns [createMintAccountInstruction, initializeMintInstruction, createTokenPoolInstruction]
+     *
+     * Note that `createTokenPoolInstruction` must be executed after `initializeMintInstruction`.
      */
     static async createMint(params) {
-        const { mint, authority, feePayer, rentExemptBalance } = params;
+        const { mint, authority, feePayer, rentExemptBalance, tokenProgramId, freezeAuthority, mintSize, } = params;
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         /// Create and initialize SPL Mint account
-        const createMintAccountInstruction =
-            web3_js.SystemProgram.createAccount({
-                fromPubkey: feePayer,
-                lamports: rentExemptBalance,
-                newAccountPubkey: mint,
-                programId: splToken.TOKEN_PROGRAM_ID,
-                space: splToken.MINT_SIZE,
-            });
-        const initializeMintInstruction =
-            splToken.createInitializeMint2Instruction(
-                mint,
-                params.decimals,
-                authority,
-                params.freezeAuthority,
-                splToken.TOKEN_PROGRAM_ID,
-            );
-        const ix = await this.createTokenPool({
+        const createMintAccountInstruction = web3_js.SystemProgram.createAccount({
+            fromPubkey: feePayer,
+            lamports: rentExemptBalance,
+            newAccountPubkey: mint,
+            programId: tokenProgram,
+            space: mintSize !== null && mintSize !== void 0 ? mintSize : splToken.MINT_SIZE,
+        });
+        const initializeMintInstruction = splToken.createInitializeMint2Instruction(mint, params.decimals, authority, freezeAuthority, tokenProgram);
+        const createTokenPoolInstruction = await this.createTokenPool({
             feePayer,
             mint,
+            tokenProgramId: tokenProgram,
         });
-        return [createMintAccountInstruction, initializeMintInstruction, ix];
+        return [
+            createMintAccountInstruction,
+            initializeMintInstruction,
+            createTokenPoolInstruction,
+        ];
     }
     /**
      * Enable compression for an existing SPL mint, creating an omnibus account.
      * For new mints, use `CompressedTokenProgram.createMint`.
      */
     static async createTokenPool(params) {
-        const { mint, feePayer } = params;
+        const { mint, feePayer, tokenProgramId } = params;
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
         const ix = await this.program.methods
             .createTokenPool()
             .accounts({
-                mint,
-                feePayer,
-                tokenPoolPda,
-                systemProgram: web3_js.SystemProgram.programId,
-                tokenProgram: splToken.TOKEN_PROGRAM_ID,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            })
+            mint,
+            feePayer,
+            tokenPoolPda,
+            systemProgram: web3_js.SystemProgram.programId,
+            tokenProgram,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+        })
             .instruction();
         return ix;
     }
@@ -2021,65 +2071,43 @@ class CompressedTokenProgram {
      */
     static async mintTo(params) {
         const systemKeys = stateless_js.defaultStaticAccountsStruct();
-        const { mint, feePayer, authority, merkleTree, toPubkey, amount } =
-            params;
+        const { mint, feePayer, authority, merkleTree, toPubkey, amount, tokenProgramId, } = params;
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const amounts = stateless_js
-            .toArray(amount)
-            .map(amount => stateless_js.bn(amount));
+        const amounts = stateless_js.toArray(amount).map(amount => stateless_js.bn(amount));
         const toPubkeys = stateless_js.toArray(toPubkey);
         if (amounts.length !== toPubkeys.length) {
-            throw new Error(
-                'Amount and toPubkey arrays must have the same length',
-            );
+            throw new Error('Amount and toPubkey arrays must have the same length');
         }
         const instruction = await this.program.methods
             .mintTo(toPubkeys, amounts, null)
             .accounts({
-                feePayer,
-                authority,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                mint,
-                tokenPoolPda,
-                tokenProgram: splToken.TOKEN_PROGRAM_ID,
-                lightSystemProgram: stateless_js.LightSystemProgram.programId,
-                registeredProgramPda: systemKeys.registeredProgramPda,
-                noopProgram: systemKeys.noopProgram,
-                accountCompressionAuthority:
-                    systemKeys.accountCompressionAuthority,
-                accountCompressionProgram: systemKeys.accountCompressionProgram,
-                merkleTree:
-                    merkleTree !== null && merkleTree !== void 0
-                        ? merkleTree
-                        : stateless_js.defaultTestStateTreeAccounts()
-                              .merkleTree,
-                selfProgram: this.programId,
-                solPoolPda: null,
-            })
+            feePayer,
+            authority,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            mint,
+            tokenPoolPda,
+            tokenProgram,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
+            registeredProgramPda: systemKeys.registeredProgramPda,
+            noopProgram: systemKeys.noopProgram,
+            accountCompressionAuthority: systemKeys.accountCompressionAuthority,
+            accountCompressionProgram: systemKeys.accountCompressionProgram,
+            merkleTree: merkleTree !== null && merkleTree !== void 0 ? merkleTree : stateless_js.defaultTestStateTreeAccounts().merkleTree,
+            selfProgram: this.programId,
+            solPoolPda: null,
+        })
             .instruction();
         return instruction;
     }
-    /// TODO: add compressBatch functionality for batch minting
     /**
-     * Mint tokens from registed SPL mint account to a compressed account
+     * Mint tokens from registered SPL mint account to a compressed account
      */
     static async approveAndMintTo(params) {
-        const {
-            mint,
-            feePayer,
-            authorityTokenAccount,
-            authority,
-            merkleTree,
-            toPubkey,
-        } = params;
+        const { mint, feePayer, authorityTokenAccount, authority, merkleTree, toPubkey, tokenProgramId, } = params;
         const amount = BigInt(params.amount.toString());
         /// 1. Mint to existing ATA of mintAuthority.
-        const splMintToInstruction = splToken.createMintToInstruction(
-            mint,
-            authorityTokenAccount,
-            authority,
-            amount,
-        );
+        const splMintToInstruction = splToken.createMintToInstruction(mint, authorityTokenAccount, authority, amount, [], tokenProgramId);
         /// 2. Compress from mint authority ATA to recipient compressed account
         const compressInstruction = await this.compress({
             payer: feePayer,
@@ -2089,6 +2117,7 @@ class CompressedTokenProgram {
             mint,
             amount: params.amount,
             outputStateTree: merkleTree,
+            tokenProgramId,
         });
         return [splMintToInstruction, compressInstruction];
     }
@@ -2096,33 +2125,15 @@ class CompressedTokenProgram {
      * Construct transfer instruction for compressed tokens
      */
     static async transfer(params) {
-        const {
-            payer,
-            inputCompressedTokenAccounts,
-            recentInputStateRootIndices,
-            recentValidityProof,
-            amount,
-            outputStateTrees,
-            toAddress,
-        } = params;
-        const tokenTransferOutputs = createTransferOutputState(
-            inputCompressedTokenAccounts,
-            toAddress,
-            amount,
-        );
-        const {
-            inputTokenDataWithContext,
-            packedOutputTokenData,
-            remainingAccountMetas,
-        } = packCompressedTokenAccounts({
+        const { payer, inputCompressedTokenAccounts, recentInputStateRootIndices, recentValidityProof, amount, outputStateTrees, toAddress, } = params;
+        const tokenTransferOutputs = createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount);
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts,
             outputStateTrees,
             rootIndices: recentInputStateRootIndices,
             tokenTransferOutputs,
         });
-        const { mint, currentOwner } = parseTokenData(
-            inputCompressedTokenAccounts,
-        );
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
             mint,
@@ -2134,32 +2145,24 @@ class CompressedTokenProgram {
             cpiContext: null,
             lamportsChangeAccountMerkleTreeIndex: null,
         };
-        const encodedData = this.program.coder.types.encode(
-            'CompressedTokenInstructionDataTransfer',
-            data,
-        );
-        const {
-            accountCompressionAuthority,
-            noopProgram,
-            registeredProgramPda,
-            accountCompressionProgram,
-        } = stateless_js.defaultStaticAccountsStruct();
+        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
+        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: currentOwner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: stateless_js.LightSystemProgram.programId,
-                registeredProgramPda: registeredProgramPda,
-                noopProgram: noopProgram,
-                accountCompressionAuthority: accountCompressionAuthority,
-                accountCompressionProgram: accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: null,
-                compressOrDecompressTokenAccount: null,
-                tokenProgram: null,
-            })
+            feePayer: payer,
+            authority: currentOwner,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
+            registeredProgramPda: registeredProgramPda,
+            noopProgram: noopProgram,
+            accountCompressionAuthority: accountCompressionAuthority,
+            accountCompressionProgram: accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: null,
+            compressOrDecompressTokenAccount: null,
+            tokenProgram: null,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
@@ -2168,14 +2171,12 @@ class CompressedTokenProgram {
      * Create lookup table instructions for the token program's default accounts.
      */
     static async createTokenProgramLookupTable(params) {
-        const { authority, mints, recentSlot, payer, remainingAccounts } =
-            params;
-        const [createInstruction, lookupTableAddress] =
-            web3_js.AddressLookupTableProgram.createLookupTable({
-                authority,
-                payer: authority,
-                recentSlot,
-            });
+        const { authority, mints, recentSlot, payer, remainingAccounts } = params;
+        const [createInstruction, lookupTableAddress] = web3_js.AddressLookupTableProgram.createLookupTable({
+            authority,
+            payer: authority,
+            recentSlot,
+        });
         let optionalMintKeys = [];
         if (mints) {
             optionalMintKeys = [
@@ -2183,35 +2184,29 @@ class CompressedTokenProgram {
                 ...mints.map(mint => this.deriveTokenPoolPda(mint)),
             ];
         }
-        const extendInstruction =
-            web3_js.AddressLookupTableProgram.extendLookupTable({
-                payer,
+        const extendInstruction = web3_js.AddressLookupTableProgram.extendLookupTable({
+            payer,
+            authority,
+            lookupTable: lookupTableAddress,
+            addresses: [
+                this.deriveCpiAuthorityPda,
+                stateless_js.LightSystemProgram.programId,
+                stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
+                stateless_js.defaultStaticAccountsStruct().noopProgram,
+                stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
+                stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
+                stateless_js.defaultTestStateTreeAccounts().merkleTree,
+                stateless_js.defaultTestStateTreeAccounts().nullifierQueue,
+                stateless_js.defaultTestStateTreeAccounts().addressTree,
+                stateless_js.defaultTestStateTreeAccounts().addressQueue,
+                this.programId,
+                splToken.TOKEN_PROGRAM_ID,
+                splToken.TOKEN_2022_PROGRAM_ID,
                 authority,
-                lookupTable: lookupTableAddress,
-                addresses: [
-                    this.deriveCpiAuthorityPda,
-                    stateless_js.LightSystemProgram.programId,
-                    stateless_js.defaultStaticAccountsStruct()
-                        .registeredProgramPda,
-                    stateless_js.defaultStaticAccountsStruct().noopProgram,
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionAuthority,
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionProgram,
-                    stateless_js.defaultTestStateTreeAccounts().merkleTree,
-                    stateless_js.defaultTestStateTreeAccounts().nullifierQueue,
-                    stateless_js.defaultTestStateTreeAccounts().addressTree,
-                    stateless_js.defaultTestStateTreeAccounts().addressQueue,
-                    this.programId,
-                    splToken.TOKEN_PROGRAM_ID,
-                    authority,
-                    ...optionalMintKeys,
-                    ...(remainingAccounts !== null &&
-                    remainingAccounts !== void 0
-                        ? remainingAccounts
-                        : []),
-                ],
-            });
+                ...optionalMintKeys,
+                ...(remainingAccounts !== null && remainingAccounts !== void 0 ? remainingAccounts : []),
+            ],
+        });
         return {
             instructions: [createInstruction, extendInstruction],
             address: lookupTableAddress,
@@ -2222,19 +2217,14 @@ class CompressedTokenProgram {
      * @returns compressInstruction
      */
     static async compress(params) {
-        const { payer, owner, source, toAddress, mint, outputStateTree } =
-            params;
+        const { payer, owner, source, toAddress, mint, outputStateTree, tokenProgramId, } = params;
         if (Array.isArray(params.amount) !== Array.isArray(params.toAddress)) {
-            throw new Error(
-                'Both amount and toAddress must be arrays or both must be single values',
-            );
+            throw new Error('Both amount and toAddress must be arrays or both must be single values');
         }
         let tokenTransferOutputs;
         if (Array.isArray(params.amount) && Array.isArray(params.toAddress)) {
             if (params.amount.length !== params.toAddress.length) {
-                throw new Error(
-                    'Amount and toAddress arrays must have the same length',
-                );
+                throw new Error('Amount and toAddress arrays must have the same length');
             }
             tokenTransferOutputs = params.amount.map((amt, index) => {
                 const amount = stateless_js.bn(amt);
@@ -2245,7 +2235,8 @@ class CompressedTokenProgram {
                     tlv: null,
                 };
             });
-        } else {
+        }
+        else {
             tokenTransferOutputs = [
                 {
                     owner: toAddress,
@@ -2255,11 +2246,7 @@ class CompressedTokenProgram {
                 },
             ];
         }
-        const {
-            inputTokenDataWithContext,
-            packedOutputTokenData,
-            remainingAccountMetas,
-        } = packCompressedTokenAccounts({
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts: [],
             outputStateTrees: outputStateTree,
             rootIndices: [],
@@ -2273,40 +2260,31 @@ class CompressedTokenProgram {
             outputCompressedAccounts: packedOutputTokenData,
             compressOrDecompressAmount: Array.isArray(params.amount)
                 ? params.amount
-                      .map(amt => new anchor.BN(amt))
-                      .reduce((sum, amt) => sum.add(amt), new anchor.BN(0))
+                    .map(amt => new anchor.BN(amt))
+                    .reduce((sum, amt) => sum.add(amt), new anchor.BN(0))
                 : new anchor.BN(params.amount),
             isCompress: true,
             cpiContext: null,
             lamportsChangeAccountMerkleTreeIndex: null,
         };
-        const encodedData = this.program.coder.types.encode(
-            'CompressedTokenInstructionDataTransfer',
-            data,
-        );
+        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: owner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: stateless_js.LightSystemProgram.programId,
-                registeredProgramPda:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .registeredProgramPda,
-                noopProgram:
-                    stateless_js.defaultStaticAccountsStruct().noopProgram,
-                accountCompressionAuthority:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionAuthority,
-                accountCompressionProgram:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: source, // token
-                tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            })
+            feePayer: payer,
+            authority: owner,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
+            registeredProgramPda: stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
+            noopProgram: stateless_js.defaultStaticAccountsStruct().noopProgram,
+            accountCompressionAuthority: stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
+            accountCompressionProgram: stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: this.deriveTokenPoolPda(mint),
+            compressOrDecompressTokenAccount: source, // token
+            tokenProgram,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
@@ -2315,33 +2293,17 @@ class CompressedTokenProgram {
      * Construct decompress instruction
      */
     static async decompress(params) {
-        const {
-            payer,
-            inputCompressedTokenAccounts,
-            toAddress,
-            outputStateTree,
-            recentValidityProof,
-            recentInputStateRootIndices,
-        } = params;
+        const { payer, inputCompressedTokenAccounts, toAddress, outputStateTree, recentValidityProof, recentInputStateRootIndices, tokenProgramId, } = params;
         const amount = stateless_js.bn(params.amount);
-        const tokenTransferOutputs = createDecompressOutputState(
-            inputCompressedTokenAccounts,
-            amount,
-        );
+        const tokenTransferOutputs = createDecompressOutputState(inputCompressedTokenAccounts, amount);
         /// Pack
-        const {
-            inputTokenDataWithContext,
-            packedOutputTokenData,
-            remainingAccountMetas,
-        } = packCompressedTokenAccounts({
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts,
             outputStateTrees: outputStateTree,
             rootIndices: recentInputStateRootIndices,
             tokenTransferOutputs: tokenTransferOutputs,
         });
-        const { mint, currentOwner } = parseTokenData(
-            inputCompressedTokenAccounts,
-        );
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
             mint,
@@ -2353,45 +2315,31 @@ class CompressedTokenProgram {
             cpiContext: null,
             lamportsChangeAccountMerkleTreeIndex: null,
         };
-        const encodedData = this.program.coder.types.encode(
-            'CompressedTokenInstructionDataTransfer',
-            data,
-        );
-        const {
-            accountCompressionAuthority,
-            noopProgram,
-            registeredProgramPda,
-            accountCompressionProgram,
-        } = stateless_js.defaultStaticAccountsStruct();
+        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
+        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: currentOwner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: stateless_js.LightSystemProgram.programId,
-                registeredProgramPda: registeredProgramPda,
-                noopProgram: noopProgram,
-                accountCompressionAuthority: accountCompressionAuthority,
-                accountCompressionProgram: accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: toAddress,
-                tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            })
+            feePayer: payer,
+            authority: currentOwner,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
+            registeredProgramPda: registeredProgramPda,
+            noopProgram: noopProgram,
+            accountCompressionAuthority: accountCompressionAuthority,
+            accountCompressionProgram: accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: this.deriveTokenPoolPda(mint),
+            compressOrDecompressTokenAccount: toAddress,
+            tokenProgram,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
     }
     static async mergeTokenAccounts(params) {
-        const {
-            payer,
-            owner,
-            inputCompressedTokenAccounts,
-            outputStateTree,
-            recentValidityProof,
-            recentInputStateRootIndices,
-        } = params;
+        const { payer, owner, inputCompressedTokenAccounts, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
         if (inputCompressedTokenAccounts.length > 3) {
             throw new Error('Cannot merge more than 3 token accounts at once');
         }
@@ -2399,10 +2347,7 @@ class CompressedTokenProgram {
             payer,
             inputCompressedTokenAccounts,
             toAddress: owner,
-            amount: inputCompressedTokenAccounts.reduce(
-                (sum, account) => sum.add(account.parsed.amount),
-                new anchor.BN(0),
-            ),
+            amount: inputCompressedTokenAccounts.reduce((sum, account) => sum.add(account.parsed.amount), new anchor.BN(0)),
             outputStateTrees: outputStateTree,
             recentInputStateRootIndices,
             recentValidityProof,
@@ -2410,14 +2355,8 @@ class CompressedTokenProgram {
         return [ix];
     }
     static async compressSplTokenAccount(params) {
-        const {
-            feePayer,
-            authority,
-            tokenAccount,
-            mint,
-            remainingAmount,
-            outputStateTree,
-        } = params;
+        const { feePayer, authority, tokenAccount, mint, remainingAmount, outputStateTree, tokenProgramId, } = params;
+        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
         const remainingAccountMetas = [
             {
                 pubkey: outputStateTree,
@@ -2426,46 +2365,35 @@ class CompressedTokenProgram {
             },
         ];
         const instruction = await this.program.methods
-            .compressSplTokenAccount(
-                authority,
-                remainingAmount !== null && remainingAmount !== void 0
-                    ? remainingAmount
-                    : null,
-                null,
-            )
+            .compressSplTokenAccount(authority, remainingAmount !== null && remainingAmount !== void 0 ? remainingAmount : null, null)
             .accounts({
-                feePayer,
-                authority,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: stateless_js.LightSystemProgram.programId,
-                registeredProgramPda:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .registeredProgramPda,
-                noopProgram:
-                    stateless_js.defaultStaticAccountsStruct().noopProgram,
-                accountCompressionAuthority:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionAuthority,
-                accountCompressionProgram:
-                    stateless_js.defaultStaticAccountsStruct()
-                        .accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: tokenAccount,
-                tokenProgram: splToken.TOKEN_PROGRAM_ID,
-                systemProgram: web3_js.SystemProgram.programId,
-            })
+            feePayer,
+            authority,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
+            registeredProgramPda: stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
+            noopProgram: stateless_js.defaultStaticAccountsStruct().noopProgram,
+            accountCompressionAuthority: stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
+            accountCompressionProgram: stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: this.deriveTokenPoolPda(mint),
+            compressOrDecompressTokenAccount: tokenAccount,
+            tokenProgram,
+            systemProgram: web3_js.SystemProgram.programId,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
     }
+    static async get_mint_program_id(mint, connection) {
+        var _a;
+        return (_a = (await connection.getAccountInfo(mint))) === null || _a === void 0 ? void 0 : _a.owner;
+    }
 }
 /**
  * Public key that identifies the CompressedPda program
  */
-CompressedTokenProgram.programId = new web3_js.PublicKey(
-    'cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m',
-);
+CompressedTokenProgram.programId = new web3_js.PublicKey('cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m');
 CompressedTokenProgram._program = null;
 
 /**
@@ -2483,23 +2411,11 @@ CompressedTokenProgram._program = null;
  *
  * @return Signature of the confirmed transaction
  */
-async function approveAndMintTo(
-    rpc,
-    payer,
-    mint,
-    destination,
-    authority,
-    amount,
-    merkleTree,
-    confirmOptions,
-) {
-    const authorityTokenAccount =
-        await splToken.getOrCreateAssociatedTokenAccount(
-            rpc,
-            payer,
-            mint,
-            authority.publicKey,
-        );
+async function approveAndMintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
+    const authorityTokenAccount = await splToken.getOrCreateAssociatedTokenAccount(rpc, payer, mint, authority.publicKey, undefined, undefined, confirmOptions, tokenProgramId);
     const ixs = await CompressedTokenProgram.approveAndMintTo({
         feePayer: payer.publicKey,
         mint,
@@ -2508,20 +2424,14 @@ async function approveAndMintTo(
         amount,
         toPubkey: destination,
         merkleTree,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
-    const tx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            ...ixs,
-        ],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const tx = stateless_js.buildAndSignTx([
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+        ...ixs,
+    ], payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
     return txId;
 }
@@ -2544,17 +2454,10 @@ async function approveAndMintTo(
  *
  * @return Signature of the confirmed transaction
  */
-async function compress(
-    rpc,
-    payer,
-    mint,
-    amount,
-    owner,
-    sourceTokenAccount,
-    toAddress,
-    merkleTree,
-    confirmOptions,
-) {
+async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
     const compressIx = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
@@ -2563,26 +2466,17 @@ async function compress(
         amount,
         mint,
         outputStateTree: merkleTree,
+        tokenProgramId,
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            compressIx,
-        ],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-        blockhashCtx,
-    );
+    const signedTx = stateless_js.buildAndSignTx([
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1000000,
+        }),
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
 
@@ -2603,33 +2497,15 @@ async function compress(
  *
  * @return Signature of the confirmed transaction
  */
-async function transfer(
-    rpc,
-    payer,
-    mint,
-    amount,
-    owner,
-    toAddress,
-    /// TODO: allow multiple
-    merkleTree,
-    confirmOptions,
-) {
+async function transfer(rpc, payer, mint, amount, owner, toAddress, 
+/// TODO: allow multiple
+merkleTree, confirmOptions) {
     amount = stateless_js.bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(
-        owner.publicKey,
-        {
-            mint,
-        },
-    );
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(
-        compressedTokenAccounts.items,
-        amount,
-    );
-    const proof = await rpc.getValidityProof(
-        inputAccounts.map(account =>
-            stateless_js.bn(account.compressedAccount.hash),
-        ),
-    );
+    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
+        mint,
+    });
+    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts.items, amount);
+    const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.bn(account.compressedAccount.hash)));
     const ix = await CompressedTokenProgram.transfer({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
@@ -2641,22 +2517,8 @@ async function transfer(
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            ix,
-        ],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-    );
+    const signedTx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
 /**
@@ -2672,17 +2534,14 @@ function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
     const selectedAccounts = [];
     accounts.sort((a, b) => b.parsed.amount.cmp(a.parsed.amount));
     for (const account of accounts) {
-        if (accumulatedAmount.gte(stateless_js.bn(transferAmount))) break;
+        if (accumulatedAmount.gte(stateless_js.bn(transferAmount)))
+            break;
         accumulatedAmount = accumulatedAmount.add(account.parsed.amount);
-        accumulatedLamports = accumulatedLamports.add(
-            account.compressedAccount.lamports,
-        );
+        accumulatedLamports = accumulatedLamports.add(account.compressedAccount.lamports);
         selectedAccounts.push(account);
     }
     if (accumulatedAmount.lt(stateless_js.bn(transferAmount))) {
-        throw new Error(
-            `Not enough balance for transfer. Required: ${transferAmount.toString()}, available: ${accumulatedAmount.toString()}`,
-        );
+        throw new Error(`Not enough balance for transfer. Required: ${transferAmount.toString()}, available: ${accumulatedAmount.toString()}`);
     }
     return [
         selectedAccounts,
@@ -2709,34 +2568,19 @@ function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
  *
  * @return Signature of the confirmed transaction
  */
-async function decompress(
-    rpc,
-    payer,
-    mint,
-    amount,
-    owner,
-    toAddress,
-    /// TODO: allow multiple
-    merkleTree,
-    confirmOptions,
-) {
+async function decompress(rpc, payer, mint, amount, owner, toAddress, 
+/// TODO: allow multiple
+merkleTree, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
     amount = stateless_js.bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(
-        owner.publicKey,
-        {
-            mint,
-        },
-    );
+    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
+        mint,
+    });
     /// TODO: consider using a different selection algorithm
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(
-        compressedTokenAccounts.items,
-        amount,
-    );
-    const proof = await rpc.getValidityProof(
-        inputAccounts.map(account =>
-            stateless_js.bn(account.compressedAccount.hash),
-        ),
-    );
+    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts.items, amount);
+    const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.bn(account.compressedAccount.hash)));
     const ix = await CompressedTokenProgram.decompress({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
@@ -2745,25 +2589,12 @@ async function decompress(
         outputStateTree: merkleTree,
         recentInputStateRootIndices: proof.rootIndices,
         recentValidityProof: proof.compressedProof,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            ix,
-        ],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-    );
+    const signedTx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
 
@@ -2776,20 +2607,13 @@ async function decompress(
  * @param decimals        Location of the decimal place
  * @param keypair         Optional keypair, defaulting to a new random one
  * @param confirmOptions  Options for confirming the transaction
+ * @param isToken22       Whether to create a Token 2022 mint. Defaults to false.
  *
  * @return Address of the new mint and the transaction signature
  */
-async function createMint(
-    rpc,
-    payer,
-    mintAuthority,
-    decimals,
-    keypair = web3_js.Keypair.generate(),
-    confirmOptions,
-) {
-    const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(
-        splToken.MINT_SIZE,
-    );
+async function createMint(rpc, payer, mintAuthority, decimals, keypair = web3_js.Keypair.generate(), confirmOptions, isToken22 = false) {
+    const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(splToken.MINT_SIZE);
+    const tokenProgramId = isToken22 ? splToken.TOKEN_2022_PROGRAM_ID : splToken.TOKEN_PROGRAM_ID;
     const ixs = await CompressedTokenProgram.createMint({
         feePayer: payer.publicKey,
         mint: keypair.publicKey,
@@ -2797,15 +2621,11 @@ async function createMint(
         authority: mintAuthority,
         freezeAuthority: null, // TODO: add feature
         rentExemptBalance,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [keypair]);
-    const tx = stateless_js.buildAndSignTx(
-        ixs,
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const tx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
     return { mint: keypair.publicKey, transactionSignature: txId };
 }
@@ -2827,16 +2647,10 @@ async function createMint(
  *
  * @return Signature of the confirmed transaction
  */
-async function mintTo(
-    rpc,
-    payer,
-    mint,
-    destination,
-    authority,
-    amount,
-    merkleTree,
-    confirmOptions,
-) {
+async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
     const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
     const ix = await CompressedTokenProgram.mintTo({
         feePayer: payer.publicKey,
@@ -2845,19 +2659,10 @@ async function mintTo(
         amount: amount,
         toPubkey: destination,
         merkleTree,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            ix,
-        ],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const tx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
     return txId;
 }
@@ -2875,67 +2680,35 @@ async function mintTo(
  *
  * @return Array of transaction signatures
  */
-async function mergeTokenAccounts(
-    rpc,
-    payer,
-    mint,
-    owner,
-    merkleTree,
-    confirmOptions,
-) {
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(
-        owner.publicKey,
-        { mint },
-    );
+async function mergeTokenAccounts(rpc, payer, mint, owner, merkleTree, confirmOptions) {
+    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, { mint });
     if (compressedTokenAccounts.items.length === 0) {
-        throw new Error(
-            `No compressed token accounts found for mint ${mint.toBase58()}`,
-        );
+        throw new Error(`No compressed token accounts found for mint ${mint.toBase58()}`);
     }
     if (compressedTokenAccounts.items.length >= 6) {
-        throw new Error(
-            `Too many compressed token accounts used for mint ${mint.toBase58()}`,
-        );
+        throw new Error(`Too many compressed token accounts used for mint ${mint.toBase58()}`);
     }
     const instructions = [
         web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
     ];
-    for (
-        let i = 0;
-        i < compressedTokenAccounts.items.slice(0, 6).length;
-        i += 3
-    ) {
+    for (let i = 0; i < compressedTokenAccounts.items.slice(0, 6).length; i += 3) {
         const batch = compressedTokenAccounts.items.slice(i, i + 3);
-        const proof = await rpc.getValidityProof(
-            batch.map(account =>
-                stateless_js.bn(account.compressedAccount.hash),
-            ),
-        );
-        const batchInstructions =
-            await CompressedTokenProgram.mergeTokenAccounts({
-                payer: payer.publicKey,
-                owner: owner.publicKey,
-                mint,
-                inputCompressedTokenAccounts: batch,
-                outputStateTree: merkleTree,
-                recentValidityProof: proof.compressedProof,
-                recentInputStateRootIndices: proof.rootIndices,
-            });
+        const proof = await rpc.getValidityProof(batch.map(account => stateless_js.bn(account.compressedAccount.hash)));
+        const batchInstructions = await CompressedTokenProgram.mergeTokenAccounts({
+            payer: payer.publicKey,
+            owner: owner.publicKey,
+            mint,
+            inputCompressedTokenAccounts: batch,
+            outputStateTree: merkleTree,
+            recentValidityProof: proof.compressedProof,
+            recentInputStateRootIndices: proof.rootIndices,
+        });
         instructions.push(...batchInstructions);
     }
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(
-        instructions,
-        payer,
-        blockhash,
-        additionalSigners,
-    );
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-    );
+    const signedTx = stateless_js.buildAndSignTx(instructions, payer, blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
 
@@ -2950,10 +2723,14 @@ async function mergeTokenAccounts(
  *
  * @return transaction signature
  */
-async function createTokenPool(rpc, payer, mintAddress, confirmOptions) {
+async function createTokenPool(rpc, payer, mint, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
     const ix = await CompressedTokenProgram.createTokenPool({
         feePayer: payer.publicKey,
-        mint: mintAddress,
+        mint,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const tx = stateless_js.buildAndSignTx([ix], payer, blockhash);
@@ -2974,50 +2751,23 @@ async function createTokenPool(rpc, payer, mintAddress, confirmOptions) {
  *
  * @return Transaction signatures and the address of the created lookup table
  */
-async function createTokenProgramLookupTable(
-    rpc,
-    payer,
-    authority,
-    mints,
-    additionalAccounts,
-) {
+async function createTokenProgramLookupTable(rpc, payer, authority, mints, additionalAccounts) {
     const recentSlot = await rpc.getSlot('finalized');
-    const { instructions, address } =
-        await CompressedTokenProgram.createTokenProgramLookupTable({
-            payer: payer.publicKey,
-            authority: authority.publicKey,
-            mints,
-            remainingAccounts: additionalAccounts,
-            recentSlot,
-        });
+    const { instructions, address } = await CompressedTokenProgram.createTokenProgramLookupTable({
+        payer: payer.publicKey,
+        authority: authority.publicKey,
+        mints,
+        remainingAccounts: additionalAccounts,
+        recentSlot,
+    });
     const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
     const blockhashCtx = await rpc.getLatestBlockhash();
-    const signedTx = stateless_js.buildAndSignTx(
-        [instructions[0]],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
+    const signedTx = stateless_js.buildAndSignTx([instructions[0]], payer, blockhashCtx.blockhash, additionalSigners);
     /// Must wait for the first instruction to be finalized.
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        { commitment: 'finalized' },
-        blockhashCtx,
-    );
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, { commitment: 'finalized' }, blockhashCtx);
     const blockhashCtx2 = await rpc.getLatestBlockhash();
-    const signedTx2 = stateless_js.buildAndSignTx(
-        [instructions[1]],
-        payer,
-        blockhashCtx2.blockhash,
-        additionalSigners,
-    );
-    const txId2 = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx2,
-        { commitment: 'finalized' },
-        blockhashCtx2,
-    );
+    const signedTx2 = stateless_js.buildAndSignTx([instructions[1]], payer, blockhashCtx2.blockhash, additionalSigners);
+    const txId2 = await stateless_js.sendAndConfirmTx(rpc, signedTx2, { commitment: 'finalized' }, blockhashCtx2);
     return { txIds: [txId, txId2], address };
 }
 
@@ -3035,16 +2785,10 @@ async function createTokenProgramLookupTable(
  *
  * @return Signature of the confirmed transaction
  */
-async function compressSplTokenAccount(
-    rpc,
-    payer,
-    mint,
-    owner,
-    tokenAccount,
-    outputStateTree,
-    remainingAmount,
-    confirmOptions,
-) {
+async function compressSplTokenAccount(rpc, payer, mint, owner, tokenAccount, outputStateTree, remainingAmount, confirmOptions, tokenProgramId) {
+    tokenProgramId = tokenProgramId
+        ? tokenProgramId
+        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
     const compressIx = await CompressedTokenProgram.compressSplTokenAccount({
         feePayer: payer.publicKey,
         authority: owner.publicKey,
@@ -3052,26 +2796,17 @@ async function compressSplTokenAccount(
         mint,
         remainingAmount,
         outputStateTree,
+        tokenProgramId,
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(
-        [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1000000,
-            }),
-            compressIx,
-        ],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
-    const txId = await stateless_js.sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-        blockhashCtx,
-    );
+    const signedTx = stateless_js.buildAndSignTx([
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1000000,
+        }),
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
 
@@ -3093,8 +2828,7 @@ exports.mergeTokenAccounts = mergeTokenAccounts;
 exports.mintTo = mintTo;
 exports.packCompressedTokenAccounts = packCompressedTokenAccounts;
 exports.parseTokenData = parseTokenData;
-exports.selectMinCompressedTokenAccountsForTransfer =
-    selectMinCompressedTokenAccountsForTransfer;
+exports.selectMinCompressedTokenAccountsForTransfer = selectMinCompressedTokenAccountsForTransfer;
 exports.sumUpTokenAmount = sumUpTokenAmount;
 exports.transfer = transfer;
 exports.validateSameTokenOwner = validateSameTokenOwner;