@lightprotocol/compressed-token 0.16.0 → 0.17.1

package/dist/es/browser/index.js

@@ -1,36 +1,7 @@
-import {
-    getIndexOrAdd,
-    bn,
-    padOutputStateMerkleTrees,
-    useWallet,
-    confirmConfig,
-    defaultStaticAccountsStruct,
-    toArray,
-    LightSystemProgram,
-    defaultTestStateTreeAccounts,
-    sumUpLamports,
-    validateSufficientBalance,
-    validateSameOwner,
-    dedupeSigner,
-    buildAndSignTx,
-    sendAndConfirmTx,
-} from '@lightprotocol/stateless.js';
-import {
-    PublicKey,
-    Keypair,
-    Connection,
-    SystemProgram,
-    AddressLookupTableProgram,
-    ComputeBudgetProgram,
-} from '@solana/web3.js';
+import { getIndexOrAdd, bn, padOutputStateMerkleTrees, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, defaultTestStateTreeAccounts, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx } from '@lightprotocol/stateless.js';
+import { PublicKey, Keypair, Connection, SystemProgram, AddressLookupTableProgram, ComputeBudgetProgram } from '@solana/web3.js';
 import { AnchorProvider, setProvider, Program, BN } from '@coral-xyz/anchor';
-import {
-    TOKEN_PROGRAM_ID,
-    MINT_SIZE,
-    createInitializeMint2Instruction,
-    createMintToInstruction,
-    getOrCreateAssociatedTokenAccount,
-} from '@solana/spl-token';
+import { MINT_SIZE, createInitializeMint2Instruction, createMintToInstruction, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, getOrCreateAssociatedTokenAccount } from '@solana/spl-token';
 
 const IDL = {
     version: '1.2.0',
@@ -116,9 +87,6 @@ const IDL = {
                     name: 'tokenPoolPda',
                     isMut: true,
                     isSigner: false,
-                    docs: [
-                        'account to a token account of a different mint will fail',
-                    ],
                 },
                 {
                     name: 'tokenProgram',
@@ -196,6 +164,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',
@@ -1189,8 +1162,7 @@ const IDL = {
                         name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined:
-                                    'PackedCompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -1198,8 +1170,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1255,8 +1226,7 @@ const IDL = {
                         name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined:
-                                    'PackedCompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -1264,8 +1234,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1510,8 +1479,7 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined:
-                                    'OutputCompressedAccountWithPackedContext',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
@@ -1688,23 +1656,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.',
         },
     ],
 };
@@ -1714,37 +1800,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 = getIndexOrAdd(
-            _remainingAccounts,
-            inputCompressedTokenAccounts[0].parsed.delegate,
-        );
+    if (inputCompressedTokenAccounts.length > 0 &&
+        inputCompressedTokenAccounts[0].parsed.delegate) {
+        delegateIndex = 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 = getIndexOrAdd(
-            _remainingAccounts,
-            account.compressedAccount.merkleTree,
-        );
-        const nullifierQueuePubkeyIndex = getIndexOrAdd(
-            _remainingAccounts,
-            account.compressedAccount.nullifierQueue,
-        );
+        const merkleTreePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
+        const nullifierQueuePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
         packedInputTokenData.push({
             amount: account.parsed.amount,
             delegateIndex,
@@ -1762,11 +1831,7 @@ function packCompressedTokenAccounts(params) {
         });
     });
     /// pack output state trees
-    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(
-        outputStateTrees,
-        tokenTransferOutputs.length,
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(outputStateTrees, tokenTransferOutputs.length, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const packedOutputTokenData = [];
     paddedOutputStateMerkleTrees.forEach((account, index) => {
         const merkleTreeIndex = getIndexOrAdd(_remainingAccounts, account);
@@ -1781,7 +1846,7 @@ function packCompressedTokenAccounts(params) {
         });
     });
     // to meta
-    const remainingAccountMetas = _remainingAccounts.map(account => ({
+    const remainingAccountMetas = _remainingAccounts.map((account) => ({
         pubkey: account,
         isWritable: true,
         isSigner: false,
@@ -1800,16 +1865,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),
-        bn(0),
-    );
+const sumUpTokenAmount = (accounts) => {
+    return accounts.reduce((acc, account) => acc.add(account.parsed.amount), 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)) {
@@ -1820,7 +1882,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;
@@ -1834,16 +1896,10 @@ const parseTokenData = compressedTokenAccounts => {
  * @returns                             Output token data for the transfer
  *                                      instruction
  */
-function createTransferOutputState(
-    inputCompressedTokenAccounts,
-    toAddress,
-    amount,
-) {
+function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount) {
     amount = bn(amount);
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
-    const inputLamports = sumUpLamports(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const changeAmount = inputAmount.sub(amount);
     validateSufficientBalance(changeAmount);
     if (changeAmount.eq(bn(0)) && inputLamports.eq(bn(0))) {
@@ -1857,9 +1913,7 @@ function createTransferOutputState(
         ];
     }
     /// validates token program
-    validateSameOwner(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     validateSameTokenOwner(inputCompressedTokenAccounts);
     const outputCompressedAccounts = [
         {
@@ -1886,9 +1940,7 @@ function createTransferOutputState(
  */
 function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
     amount = bn(amount);
-    const inputLamports = sumUpLamports(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
     const changeAmount = inputAmount.sub(amount);
     validateSufficientBalance(changeAmount);
@@ -1896,9 +1948,7 @@ function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
     if (changeAmount.eq(bn(0)) && inputLamports.eq(bn(0))) {
         return [];
     }
-    validateSameOwner(
-        inputCompressedTokenAccounts.map(acc => acc.compressedAccount),
-    );
+    validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
     validateSameTokenOwner(inputCompressedTokenAccounts);
     const tokenTransferOutputs = [
         {
@@ -1914,13 +1964,11 @@ class CompressedTokenProgram {
     /**
      * @internal
      */
-    constructor() {}
+    constructor() { }
     /**
      * Public key that identifies the CompressedPda program
      */
-    static programId = new PublicKey(
-        'cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m',
-    );
+    static programId = new PublicKey('cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m');
     /**
      * Set a custom programId via PublicKey or base58 encoded string.
      * This method is not required for regular usage.
@@ -1953,15 +2001,8 @@ class CompressedTokenProgram {
             /// program only for serde and building instructions, not for
             /// interacting with the network.
             const mockKeypair = Keypair.generate();
-            const mockConnection = new Connection(
-                'http://127.0.0.1:8899',
-                'confirmed',
-            );
-            const mockProvider = new AnchorProvider(
-                mockConnection,
-                useWallet(mockKeypair),
-                confirmConfig,
-            );
+            const mockConnection = new Connection('http://127.0.0.1:8899', 'confirmed');
+            const mockProvider = new AnchorProvider(mockConnection, useWallet(mockKeypair), confirmConfig);
             setProvider(mockProvider);
             this._program = new Program(IDL, this.programId, mockProvider);
         }
@@ -1969,63 +2010,61 @@ class CompressedTokenProgram {
     /** @internal */
     static deriveTokenPoolPda(mint) {
         const seeds = [POOL_SEED, mint.toBuffer()];
-        const [address, _] = PublicKey.findProgramAddressSync(
-            seeds,
-            this.programId,
-        );
+        const [address, _] = PublicKey.findProgramAddressSync(seeds, this.programId);
         return address;
     }
     /** @internal */
     static get deriveCpiAuthorityPda() {
-        const [address, _] = PublicKey.findProgramAddressSync(
-            [CPI_AUTHORITY_SEED],
-            this.programId,
-        );
+        const [address, _] = 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 ?? TOKEN_PROGRAM_ID;
         /// Create and initialize SPL Mint account
         const createMintAccountInstruction = SystemProgram.createAccount({
             fromPubkey: feePayer,
             lamports: rentExemptBalance,
             newAccountPubkey: mint,
-            programId: TOKEN_PROGRAM_ID,
-            space: MINT_SIZE,
+            programId: tokenProgram,
+            space: mintSize ?? MINT_SIZE,
         });
-        const initializeMintInstruction = createInitializeMint2Instruction(
-            mint,
-            params.decimals,
-            authority,
-            params.freezeAuthority,
-            TOKEN_PROGRAM_ID,
-        );
-        const ix = await this.createTokenPool({
+        const initializeMintInstruction = 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 ?? TOKEN_PROGRAM_ID;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
         const ix = await this.program.methods
             .createTokenPool()
             .accounts({
-                mint,
-                feePayer,
-                tokenPoolPda,
-                systemProgram: SystemProgram.programId,
-                tokenProgram: TOKEN_PROGRAM_ID,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            })
+            mint,
+            feePayer,
+            tokenPoolPda,
+            systemProgram: SystemProgram.programId,
+            tokenProgram,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+        })
             .instruction();
         return ix;
     }
@@ -2034,60 +2073,43 @@ class CompressedTokenProgram {
      */
     static async mintTo(params) {
         const systemKeys = defaultStaticAccountsStruct();
-        const { mint, feePayer, authority, merkleTree, toPubkey, amount } =
-            params;
+        const { mint, feePayer, authority, merkleTree, toPubkey, amount, tokenProgramId, } = params;
+        const tokenProgram = tokenProgramId ?? TOKEN_PROGRAM_ID;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
         const amounts = toArray(amount).map(amount => bn(amount));
         const toPubkeys = 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: TOKEN_PROGRAM_ID,
-                lightSystemProgram: LightSystemProgram.programId,
-                registeredProgramPda: systemKeys.registeredProgramPda,
-                noopProgram: systemKeys.noopProgram,
-                accountCompressionAuthority:
-                    systemKeys.accountCompressionAuthority,
-                accountCompressionProgram: systemKeys.accountCompressionProgram,
-                merkleTree:
-                    merkleTree ?? defaultTestStateTreeAccounts().merkleTree,
-                selfProgram: this.programId,
-                solPoolPda: null,
-            })
+            feePayer,
+            authority,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            mint,
+            tokenPoolPda,
+            tokenProgram,
+            lightSystemProgram: LightSystemProgram.programId,
+            registeredProgramPda: systemKeys.registeredProgramPda,
+            noopProgram: systemKeys.noopProgram,
+            accountCompressionAuthority: systemKeys.accountCompressionAuthority,
+            accountCompressionProgram: systemKeys.accountCompressionProgram,
+            merkleTree: merkleTree ?? 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 = createMintToInstruction(
-            mint,
-            authorityTokenAccount,
-            authority,
-            amount,
-        );
+        const splMintToInstruction = createMintToInstruction(mint, authorityTokenAccount, authority, amount, [], tokenProgramId);
         /// 2. Compress from mint authority ATA to recipient compressed account
         const compressInstruction = await this.compress({
             payer: feePayer,
@@ -2097,6 +2119,7 @@ class CompressedTokenProgram {
             mint,
             amount: params.amount,
             outputStateTree: merkleTree,
+            tokenProgramId,
         });
         return [splMintToInstruction, compressInstruction];
     }
@@ -2104,33 +2127,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,
@@ -2142,32 +2147,24 @@ class CompressedTokenProgram {
             cpiContext: null,
             lamportsChangeAccountMerkleTreeIndex: null,
         };
-        const encodedData = this.program.coder.types.encode(
-            'CompressedTokenInstructionDataTransfer',
-            data,
-        );
-        const {
-            accountCompressionAuthority,
-            noopProgram,
-            registeredProgramPda,
-            accountCompressionProgram,
-        } = defaultStaticAccountsStruct();
+        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
+        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: currentOwner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: 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: LightSystemProgram.programId,
+            registeredProgramPda: registeredProgramPda,
+            noopProgram: noopProgram,
+            accountCompressionAuthority: accountCompressionAuthority,
+            accountCompressionProgram: accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: null,
+            compressOrDecompressTokenAccount: null,
+            tokenProgram: null,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
@@ -2176,14 +2173,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] =
-            AddressLookupTableProgram.createLookupTable({
-                authority,
-                payer: authority,
-                recentSlot,
-            });
+        const { authority, mints, recentSlot, payer, remainingAccounts } = params;
+        const [createInstruction, lookupTableAddress] = AddressLookupTableProgram.createLookupTable({
+            authority,
+            payer: authority,
+            recentSlot,
+        });
         let optionalMintKeys = [];
         if (mints) {
             optionalMintKeys = [
@@ -2208,6 +2203,7 @@ class CompressedTokenProgram {
                 defaultTestStateTreeAccounts().addressQueue,
                 this.programId,
                 TOKEN_PROGRAM_ID,
+                TOKEN_2022_PROGRAM_ID,
                 authority,
                 ...optionalMintKeys,
                 ...(remainingAccounts ?? []),
@@ -2223,19 +2219,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 = bn(amt);
@@ -2246,7 +2237,8 @@ class CompressedTokenProgram {
                     tlv: null,
                 };
             });
-        } else {
+        }
+        else {
             tokenTransferOutputs = [
                 {
                     owner: toAddress,
@@ -2256,11 +2248,7 @@ class CompressedTokenProgram {
                 },
             ];
         }
-        const {
-            inputTokenDataWithContext,
-            packedOutputTokenData,
-            remainingAccountMetas,
-        } = packCompressedTokenAccounts({
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts: [],
             outputStateTrees: outputStateTree,
             rootIndices: [],
@@ -2274,36 +2262,31 @@ class CompressedTokenProgram {
             outputCompressedAccounts: packedOutputTokenData,
             compressOrDecompressAmount: Array.isArray(params.amount)
                 ? params.amount
-                      .map(amt => new BN(amt))
-                      .reduce((sum, amt) => sum.add(amt), new BN(0))
+                    .map(amt => new BN(amt))
+                    .reduce((sum, amt) => sum.add(amt), new BN(0))
                 : new 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 ?? TOKEN_PROGRAM_ID;
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: owner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: LightSystemProgram.programId,
-                registeredProgramPda:
-                    defaultStaticAccountsStruct().registeredProgramPda,
-                noopProgram: defaultStaticAccountsStruct().noopProgram,
-                accountCompressionAuthority:
-                    defaultStaticAccountsStruct().accountCompressionAuthority,
-                accountCompressionProgram:
-                    defaultStaticAccountsStruct().accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: source, // token
-                tokenProgram: TOKEN_PROGRAM_ID,
-            })
+            feePayer: payer,
+            authority: owner,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: LightSystemProgram.programId,
+            registeredProgramPda: defaultStaticAccountsStruct().registeredProgramPda,
+            noopProgram: defaultStaticAccountsStruct().noopProgram,
+            accountCompressionAuthority: defaultStaticAccountsStruct().accountCompressionAuthority,
+            accountCompressionProgram: defaultStaticAccountsStruct().accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: this.deriveTokenPoolPda(mint),
+            compressOrDecompressTokenAccount: source, // token
+            tokenProgram,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
@@ -2312,33 +2295,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 = 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,
@@ -2350,45 +2317,31 @@ class CompressedTokenProgram {
             cpiContext: null,
             lamportsChangeAccountMerkleTreeIndex: null,
         };
-        const encodedData = this.program.coder.types.encode(
-            'CompressedTokenInstructionDataTransfer',
-            data,
-        );
-        const {
-            accountCompressionAuthority,
-            noopProgram,
-            registeredProgramPda,
-            accountCompressionProgram,
-        } = defaultStaticAccountsStruct();
+        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
+        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
+        const tokenProgram = tokenProgramId ?? TOKEN_PROGRAM_ID;
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
-                feePayer: payer,
-                authority: currentOwner,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: LightSystemProgram.programId,
-                registeredProgramPda: registeredProgramPda,
-                noopProgram: noopProgram,
-                accountCompressionAuthority: accountCompressionAuthority,
-                accountCompressionProgram: accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: toAddress,
-                tokenProgram: TOKEN_PROGRAM_ID,
-            })
+            feePayer: payer,
+            authority: currentOwner,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: 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');
         }
@@ -2396,10 +2349,7 @@ class CompressedTokenProgram {
             payer,
             inputCompressedTokenAccounts,
             toAddress: owner,
-            amount: inputCompressedTokenAccounts.reduce(
-                (sum, account) => sum.add(account.parsed.amount),
-                new BN(0),
-            ),
+            amount: inputCompressedTokenAccounts.reduce((sum, account) => sum.add(account.parsed.amount), new BN(0)),
             outputStateTrees: outputStateTree,
             recentInputStateRootIndices,
             recentValidityProof,
@@ -2407,14 +2357,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 ?? TOKEN_PROGRAM_ID;
         const remainingAccountMetas = [
             {
                 pubkey: outputStateTree,
@@ -2425,27 +2369,27 @@ class CompressedTokenProgram {
         const instruction = await this.program.methods
             .compressSplTokenAccount(authority, remainingAmount ?? null, null)
             .accounts({
-                feePayer,
-                authority,
-                cpiAuthorityPda: this.deriveCpiAuthorityPda,
-                lightSystemProgram: LightSystemProgram.programId,
-                registeredProgramPda:
-                    defaultStaticAccountsStruct().registeredProgramPda,
-                noopProgram: defaultStaticAccountsStruct().noopProgram,
-                accountCompressionAuthority:
-                    defaultStaticAccountsStruct().accountCompressionAuthority,
-                accountCompressionProgram:
-                    defaultStaticAccountsStruct().accountCompressionProgram,
-                selfProgram: this.programId,
-                tokenPoolPda: this.deriveTokenPoolPda(mint),
-                compressOrDecompressTokenAccount: tokenAccount,
-                tokenProgram: TOKEN_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-            })
+            feePayer,
+            authority,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+            lightSystemProgram: LightSystemProgram.programId,
+            registeredProgramPda: defaultStaticAccountsStruct().registeredProgramPda,
+            noopProgram: defaultStaticAccountsStruct().noopProgram,
+            accountCompressionAuthority: defaultStaticAccountsStruct().accountCompressionAuthority,
+            accountCompressionProgram: defaultStaticAccountsStruct().accountCompressionProgram,
+            selfProgram: this.programId,
+            tokenPoolPda: this.deriveTokenPoolPda(mint),
+            compressOrDecompressTokenAccount: tokenAccount,
+            tokenProgram,
+            systemProgram: SystemProgram.programId,
+        })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
         return instruction;
     }
+    static async get_mint_program_id(mint, connection) {
+        return (await connection.getAccountInfo(mint))?.owner;
+    }
 }
 
 /**
@@ -2463,22 +2407,11 @@ class CompressedTokenProgram {
  *
  * @return Signature of the confirmed transaction
  */
-async function approveAndMintTo(
-    rpc,
-    payer,
-    mint,
-    destination,
-    authority,
-    amount,
-    merkleTree,
-    confirmOptions,
-) {
-    const authorityTokenAccount = await 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 getOrCreateAssociatedTokenAccount(rpc, payer, mint, authority.publicKey, undefined, undefined, confirmOptions, tokenProgramId);
     const ixs = await CompressedTokenProgram.approveAndMintTo({
         feePayer: payer.publicKey,
         mint,
@@ -2487,18 +2420,14 @@ async function approveAndMintTo(
         amount,
         toPubkey: destination,
         merkleTree,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [authority]);
-    const tx = buildAndSignTx(
-        [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }),
-            ...ixs,
-        ],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const tx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }),
+        ...ixs,
+    ], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
     return txId;
 }
@@ -2521,17 +2450,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,
@@ -2540,26 +2462,17 @@ async function compress(
         amount,
         mint,
         outputStateTree: merkleTree,
+        tokenProgramId,
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(
-        [
-            ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1_000_000,
-            }),
-            compressIx,
-        ],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
-    const txId = await sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-        blockhashCtx,
-    );
+    const signedTx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1_000_000,
+        }),
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
 
@@ -2580,31 +2493,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 = bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(
-        owner.publicKey,
-        {
-            mint,
-        },
-    );
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(
-        compressedTokenAccounts.items,
-        amount,
-    );
-    const proof = await rpc.getValidityProof(
-        inputAccounts.map(account => 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 => bn(account.compressedAccount.hash)));
     const ix = await CompressedTokenProgram.transfer({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
@@ -2616,12 +2513,7 @@ async function transfer(
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(
-        [ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -2638,17 +2530,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(bn(transferAmount))) break;
+        if (accumulatedAmount.gte(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(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,
@@ -2675,32 +2564,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 = 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 => bn(account.compressedAccount.hash)),
-    );
+    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts.items, amount);
+    const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
     const ix = await CompressedTokenProgram.decompress({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
@@ -2709,15 +2585,11 @@ async function decompress(
         outputStateTree: merkleTree,
         recentInputStateRootIndices: proof.rootIndices,
         recentValidityProof: proof.compressedProof,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(
-        [ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -2731,19 +2603,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 = Keypair.generate(),
-    confirmOptions,
-) {
-    const rentExemptBalance =
-        await rpc.getMinimumBalanceForRentExemption(MINT_SIZE);
+async function createMint(rpc, payer, mintAuthority, decimals, keypair = Keypair.generate(), confirmOptions, isToken22 = false) {
+    const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(MINT_SIZE);
+    const tokenProgramId = isToken22 ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
     const ixs = await CompressedTokenProgram.createMint({
         feePayer: payer.publicKey,
         mint: keypair.publicKey,
@@ -2751,6 +2617,7 @@ async function createMint(
         authority: mintAuthority,
         freezeAuthority: null, // TODO: add feature
         rentExemptBalance,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [keypair]);
@@ -2776,16 +2643,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 = dedupeSigner(payer, [authority]);
     const ix = await CompressedTokenProgram.mintTo({
         feePayer: payer.publicKey,
@@ -2794,14 +2655,10 @@ async function mintTo(
         amount: amount,
         toPubkey: destination,
         merkleTree,
+        tokenProgramId,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = buildAndSignTx(
-        [ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix],
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const tx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
     return txId;
 }
@@ -2819,60 +2676,34 @@ 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 = [
         ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }),
     ];
-    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 => 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 => 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 = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(
-        instructions,
-        payer,
-        blockhash,
-        additionalSigners,
-    );
+    const signedTx = buildAndSignTx(instructions, payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -2888,10 +2719,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 = buildAndSignTx([ix], payer, blockhash);
@@ -2912,50 +2747,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 = dedupeSigner(payer, [authority]);
     const blockhashCtx = await rpc.getLatestBlockhash();
-    const signedTx = buildAndSignTx(
-        [instructions[0]],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
+    const signedTx = buildAndSignTx([instructions[0]], payer, blockhashCtx.blockhash, additionalSigners);
     /// Must wait for the first instruction to be finalized.
-    const txId = await sendAndConfirmTx(
-        rpc,
-        signedTx,
-        { commitment: 'finalized' },
-        blockhashCtx,
-    );
+    const txId = await sendAndConfirmTx(rpc, signedTx, { commitment: 'finalized' }, blockhashCtx);
     const blockhashCtx2 = await rpc.getLatestBlockhash();
-    const signedTx2 = buildAndSignTx(
-        [instructions[1]],
-        payer,
-        blockhashCtx2.blockhash,
-        additionalSigners,
-    );
-    const txId2 = await sendAndConfirmTx(
-        rpc,
-        signedTx2,
-        { commitment: 'finalized' },
-        blockhashCtx2,
-    );
+    const signedTx2 = buildAndSignTx([instructions[1]], payer, blockhashCtx2.blockhash, additionalSigners);
+    const txId2 = await sendAndConfirmTx(rpc, signedTx2, { commitment: 'finalized' }, blockhashCtx2);
     return { txIds: [txId, txId2], address };
 }
 
@@ -2973,16 +2781,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,
@@ -2990,51 +2792,19 @@ async function compressSplTokenAccount(
         mint,
         remainingAmount,
         outputStateTree,
+        tokenProgramId,
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(
-        [
-            ComputeBudgetProgram.setComputeUnitLimit({
-                units: 1_000_000,
-            }),
-            compressIx,
-        ],
-        payer,
-        blockhashCtx.blockhash,
-        additionalSigners,
-    );
-    const txId = await sendAndConfirmTx(
-        rpc,
-        signedTx,
-        confirmOptions,
-        blockhashCtx,
-    );
+    const signedTx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1_000_000,
+        }),
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
 
-export {
-    CPI_AUTHORITY_SEED,
-    CompressedTokenProgram,
-    IDL,
-    POOL_SEED,
-    SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE,
-    approveAndMintTo,
-    compress,
-    compressSplTokenAccount,
-    createDecompressOutputState,
-    createMint,
-    createTokenPool,
-    createTokenProgramLookupTable,
-    createTransferOutputState,
-    decompress,
-    mergeTokenAccounts,
-    mintTo,
-    packCompressedTokenAccounts,
-    parseTokenData,
-    selectMinCompressedTokenAccountsForTransfer,
-    sumUpTokenAmount,
-    transfer,
-    validateSameTokenOwner,
-};
+export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, approveAndMintTo, compress, compressSplTokenAccount, createDecompressOutputState, createMint, createTokenPool, createTokenProgramLookupTable, createTransferOutputState, decompress, mergeTokenAccounts, mintTo, packCompressedTokenAccounts, parseTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
 //# sourceMappingURL=index.js.map