@lightprotocol/compressed-token 0.3.4 → 0.5.0

package/dist/cjs/browser/index.cjs

@@ -5,22 +5,23 @@ var web3_js = require('@solana/web3.js');
 var anchor = require('@coral-xyz/anchor');
 
 const IDL = {
-    version: '0.4.1',
+    version: '0.5.0',
     name: 'light_compressed_token',
     instructions: [
         {
             name: 'createTokenPool',
             docs: [
-                'This instruction expects a mint account to be created in a separate',
-                'token program instruction with token authority as mint authority. This',
-                'instruction creates a token pool account for that mint owned by token',
-                'authority.',
+                'This instruction creates a token pool for a given mint. Every spl mint',
+                'can have one token pool. When a token is compressed the tokens are',
+                'transferrred to the token pool, and their compressed equivalent is',
+                'minted into a Merkle tree.',
             ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'tokenPoolPda',
@@ -56,13 +57,17 @@ const IDL = {
                 'Mints tokens from an spl token mint to a list of compressed accounts.',
                 'Minted tokens are transferred to a pool account owned by the compressed',
                 'token program. The instruction creates one compressed output account for',
-                'every amount and pubkey input pair one output compressed account.',
+                'every amount and pubkey input pair. A constant amount of lamports can be',
+                'transferred to each output account to enable. A use case to add lamports',
+                'to a compressed token account is to prevent spam. This is the only way',
+                'to add lamports to a compressed token account.',
             ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
@@ -83,6 +88,9 @@ const IDL = {
                     name: 'tokenPoolPda',
                     isMut: true,
                     isSigner: false,
+                    docs: [
+                        'account to a token account of a different mint will fail',
+                    ],
                 },
                 {
                     name: 'tokenProgram',
@@ -103,6 +111,7 @@ const IDL = {
                     name: 'noopProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: ['programs'],
                 },
                 {
                     name: 'accountCompressionAuthority',
@@ -129,6 +138,12 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'solPoolPda',
+                    isMut: true,
+                    isSigner: false,
+                    isOptional: true,
+                },
             ],
             args: [
                 {
@@ -143,20 +158,42 @@ const IDL = {
                         vec: 'u64',
                     },
                 },
+                {
+                    name: 'lamports',
+                    type: {
+                        option: 'u64',
+                    },
+                },
             ],
         },
         {
             name: 'transfer',
+            docs: [
+                'Transfers compressed tokens from one account to another. All accounts',
+                'must be of the same mint. Additional spl tokens can be compressed or',
+                'decompressed. In one transaction only compression or decompression is',
+                'possible. Lamports can be transferred alongside tokens. If output token',
+                'accounts specify less lamports than inputs the remaining lamports are',
+                'transferred to an output compressed account. Signer must be owner or',
+                'delegate. If a delegated token account is transferred the delegate is',
+                'not preserved.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
                     isMut: false,
                     isSigner: true,
+                    docs: [
+                        'Authority is verified through proof since both owner and delegate',
+                        'are included in the token data hash, which is a public input to the',
+                        'validity proof.',
+                    ],
                 },
                 {
                     name: 'cpiAuthorityPda',
@@ -192,6 +229,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'tokenPoolPda',
@@ -226,16 +267,30 @@ const IDL = {
         },
         {
             name: 'approve',
+            docs: [
+                'Delegates an amount to a delegate. A compressed token account is either',
+                'completely delegated or not. Prior delegates are not preserved. Cannot',
+                'be called by a delegate.',
+                'The instruction creates two output accounts:',
+                '1. one account with delegated amount',
+                '2. one account with remaining(change) amount',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
                     isMut: false,
                     isSigner: true,
+                    docs: [
+                        'Authority is verified through proof since both owner and delegate',
+                        'are included in the token data hash, which is a public input to the',
+                        'validity proof.',
+                    ],
                 },
                 {
                     name: 'cpiAuthorityPda',
@@ -271,6 +326,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'systemProgram',
@@ -287,16 +346,26 @@ const IDL = {
         },
         {
             name: 'revoke',
+            docs: [
+                'Revokes a delegation. The instruction merges all inputs into one output',
+                'account. Cannot be called by a delegate. Delegates are not preserved.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
                     isMut: false,
                     isSigner: true,
+                    docs: [
+                        'Authority is verified through proof since both owner and delegate',
+                        'are included in the token data hash, which is a public input to the',
+                        'validity proof.',
+                    ],
                 },
                 {
                     name: 'cpiAuthorityPda',
@@ -332,6 +401,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'systemProgram',
@@ -348,11 +421,16 @@ const IDL = {
         },
         {
             name: 'freeze',
+            docs: [
+                'Freezes compressed token accounts. Inputs must not be frozen. Creates as',
+                'many outputs as inputs. Balances and delegates are preserved.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
@@ -393,6 +471,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'systemProgram',
@@ -414,11 +496,16 @@ const IDL = {
         },
         {
             name: 'thaw',
+            docs: [
+                'Thaws frozen compressed token accounts. Inputs must be frozen. Creates',
+                'as many outputs as inputs. Balances and delegates are preserved.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
@@ -459,6 +546,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'systemProgram',
@@ -480,22 +571,48 @@ const IDL = {
         },
         {
             name: 'burn',
+            docs: [
+                'Burns compressed tokens and spl tokens from the pool account. Delegates',
+                'can burn tokens. The output compressed token account remains delegated.',
+                'Creates one output compressed token account.',
+            ],
             accounts: [
                 {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
                     isMut: false,
                     isSigner: true,
+                    docs: [
+                        'Authority is verified through proof since both owner and delegate',
+                        'are included in the token data hash, which is a public input to the',
+                        'validity proof.',
+                    ],
                 },
                 {
                     name: 'cpiAuthorityPda',
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'mint',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenPoolPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
                 {
                     name: 'lightSystemProgram',
                     isMut: false,
@@ -551,11 +668,17 @@ const IDL = {
                     name: 'feePayer',
                     isMut: true,
                     isSigner: true,
+                    docs: ['UNCHECKED: only pays fees.'],
                 },
                 {
                     name: 'authority',
                     isMut: false,
                     isSigner: true,
+                    docs: [
+                        'Authority is verified through proof since both owner and delegate',
+                        'are included in the token data hash, which is a public input to the',
+                        'validity proof.',
+                    ],
                 },
                 {
                     name: 'cpiAuthorityPda',
@@ -591,6 +714,10 @@ const IDL = {
                     name: 'selfProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: [
+                        '(different program) checked in light system program to derive',
+                        'cpi_authority_pda and check that this program is the signer of the cpi.',
+                    ],
                 },
                 {
                     name: 'tokenPoolPda',
@@ -632,24 +759,6 @@ const IDL = {
             ],
         },
     ],
-    accounts: [
-        {
-            name: 'RegisteredProgram',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'registeredProgramId',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'groupAuthorityPda',
-                        type: 'publicKey',
-                    },
-                ],
-            },
-        },
-    ],
     types: [
         {
             name: 'AccessMetadata',
@@ -664,7 +773,7 @@ const IDL = {
                     {
                         name: 'programOwner',
                         docs: [
-                            'Delegate of the Merkle tree. This will be used for program owned Merkle trees.',
+                            'Program owner of the Merkle tree. This will be used for program owned Merkle trees.',
                         ],
                         type: 'publicKey',
                     },
@@ -818,9 +927,9 @@ const IDL = {
                     {
                         name: 'delegatedTransfer',
                         docs: [
-                            'If the signer is a delegate, the delegate index is index 0 of remaining accounts.',
+                            'Is required if the signer is delegate,',
+                            '-> delegate is authority account,',
                             'owner = Some(owner) is the owner of the token account.',
-                            'Is set if the signer is delegate',
                         ],
                         type: {
                             option: {
@@ -862,11 +971,20 @@ const IDL = {
                             },
                         },
                     },
+                    {
+                        name: 'lamportsChangeAccountMerkleTreeIndex',
+                        type: {
+                            option: 'u8',
+                        },
+                    },
                 ],
             },
         },
         {
             name: 'DelegatedTransfer',
+            docs: [
+                'Struct to provide the owner when the delegate is signer of the transaction.',
+            ],
             type: {
                 kind: 'struct',
                 fields: [
@@ -876,7 +994,15 @@ const IDL = {
                     },
                     {
                         name: 'delegateChangeAccountIndex',
-                        type: 'u8',
+                        docs: [
+                            'Index of change compressed account in output compressed accounts. In',
+                            "case that the delegate didn't spend the complete delegated compressed",
+                            'account balance the change compressed account will be delegated to her',
+                            'as well.',
+                        ],
+                        type: {
+                            option: 'u8',
+                        },
                     },
                 ],
             },
@@ -912,6 +1038,15 @@ const IDL = {
                             option: 'u64',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1173,6 +1308,18 @@ const IDL = {
                         name: 'leafIndex',
                         type: 'u32',
                     },
+                    {
+                        name: 'queueIndex',
+                        docs: [
+                            'Index of leaf in queue. Placeholder of batched Merkle tree updates',
+                            'currently unimplemented.',
+                        ],
+                        type: {
+                            option: {
+                                defined: 'QueueIndex',
+                            },
+                        },
+                    },
                 ],
             },
         },
@@ -1199,6 +1346,15 @@ const IDL = {
                         name: 'merkleTreeIndex',
                         type: 'u8',
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1276,6 +1432,24 @@ const IDL = {
                 ],
             },
         },
+        {
+            name: 'QueueIndex',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'queueId',
+                        docs: ['Id of queue in queue account.'],
+                        type: 'u8',
+                    },
+                    {
+                        name: 'index',
+                        docs: ['Index of compressed account hash in queue.'],
+                        type: 'u16',
+                    },
+                ],
+            },
+        },
         {
             name: 'RolloverMetadata',
             type: {
@@ -1362,6 +1536,15 @@ const IDL = {
                             defined: 'AccountState',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1369,23 +1552,107 @@ 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',
         },
     ],
 };
@@ -1416,11 +1683,13 @@ function packCompressedTokenAccounts(params) {
                 merkleTreePubkeyIndex,
                 nullifierQueuePubkeyIndex,
                 leafIndex: account.compressedAccount.leafIndex,
+                queueIndex: null,
             },
             rootIndex: rootIndices[index],
             lamports: account.compressedAccount.lamports.eq(stateless_js.bn(0))
                 ? null
                 : account.compressedAccount.lamports,
+            tlv: null,
         });
     });
     /// pack output state trees
@@ -1436,6 +1705,7 @@ function packCompressedTokenAccounts(params) {
                 ? null
                 : tokenTransferOutputs[index].lamports,
             merkleTreeIndex,
+            tlv: null,
         });
     });
     // to meta
@@ -6008,33 +6278,6 @@ function addSigners(keys, ownerOrAuthority, multiSigners) {
     return keys;
 }
 
-/** TODO: docs */
-const approveInstructionData = struct([u8('instruction'), u64('amount')]);
-/**
- * Construct an Approve instruction
- *
- * @param account      Account to set the delegate for
- * @param delegate     Account authorized to transfer tokens from the account
- * @param owner        Owner of the account
- * @param amount       Maximum number of tokens the delegate may transfer
- * @param multiSigners Signing accounts if `owner` is a multisig
- * @param programId    SPL Token program account
- *
- * @return Instruction to add to a transaction
- */
-function createApproveInstruction(account, delegate, owner, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
-    const keys = addSigners([
-        { pubkey: account, isSigner: false, isWritable: true },
-        { pubkey: delegate, isSigner: false, isWritable: false },
-    ], owner, multiSigners);
-    const data = Buffer.alloc(approveInstructionData.span);
-    approveInstructionData.encode({
-        instruction: TokenInstruction.Approve,
-        amount: BigInt(amount),
-    }, data);
-    return new web3_js.TransactionInstruction({ keys, programId, data });
-}
-
 var AccountType;
 (function (AccountType) {
     AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
@@ -6358,6 +6601,7 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
                 owner: toAddress,
                 amount,
                 lamports: inputLamports,
+                tlv: null,
             },
         ];
     }
@@ -6369,11 +6613,13 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
             owner: inputCompressedTokenAccounts[0].parsed.owner,
             amount: changeAmount,
             lamports: inputLamports,
+            tlv: null,
         },
         {
             owner: toAddress,
             amount,
             lamports: stateless_js.bn(0),
+            tlv: null,
         },
     ];
     return outputCompressedAccounts;
@@ -6402,6 +6648,7 @@ function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
             owner: inputCompressedTokenAccounts[0].parsed.owner,
             amount: changeAmount,
             lamports: inputLamports,
+            tlv: null,
         },
     ];
     return tokenTransferOutputs;
@@ -6495,7 +6742,7 @@ class CompressedTokenProgram {
         const amounts = stateless_js.toArray(amount).map(amount => stateless_js.bn(amount));
         const toPubkeys = stateless_js.toArray(toPubkey);
         const instruction = await this.program.methods
-            .mintTo(toPubkeys, amounts)
+            .mintTo(toPubkeys, amounts, null)
             .accounts({
             feePayer,
             authority,
@@ -6510,6 +6757,7 @@ class CompressedTokenProgram {
             accountCompressionProgram: systemKeys.accountCompressionProgram,
             merkleTree: merkleTree !== null && merkleTree !== void 0 ? merkleTree : stateless_js.defaultTestStateTreeAccounts().merkleTree,
             selfProgram: this.programId,
+            solPoolPda: null,
         })
             .instruction();
         return instruction;
@@ -6524,7 +6772,7 @@ class CompressedTokenProgram {
         /// 1. Mint to existing ATA of mintAuthority.
         const splMintToInstruction = createMintToInstruction(mint, authorityTokenAccount, authority, amount);
         /// 2. Compress from mint authority ATA to recipient compressed account
-        const [approveInstruction, compressInstruction] = await this.compress({
+        const compressInstruction = await this.compress({
             payer: feePayer,
             owner: authority,
             source: authorityTokenAccount,
@@ -6533,7 +6781,7 @@ class CompressedTokenProgram {
             amount: params.amount,
             outputStateTree: merkleTree,
         });
-        return [splMintToInstruction, approveInstruction, compressInstruction];
+        return [splMintToInstruction, compressInstruction];
     }
     /**
      * Construct transfer instruction for compressed tokens
@@ -6557,6 +6805,7 @@ class CompressedTokenProgram {
             compressOrDecompressAmount: null,
             isCompress: false,
             cpiContext: null,
+            lamportsChangeAccountMerkleTreeIndex: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
@@ -6581,8 +6830,8 @@ class CompressedTokenProgram {
         return instruction;
     }
     /**
-     * Construct approve and compress instructions
-     * @returns [approveInstruction, compressInstruction]
+     * Construct compress instruction
+     * @returns compressInstruction
      */
     static async compress(params) {
         const { payer, owner, source, toAddress, mint, outputStateTree } = params;
@@ -6592,6 +6841,7 @@ class CompressedTokenProgram {
                 owner: toAddress,
                 amount,
                 lamports: stateless_js.bn(0),
+                tlv: null,
             },
         ];
         const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
@@ -6609,10 +6859,10 @@ class CompressedTokenProgram {
             compressOrDecompressAmount: amount,
             isCompress: true,
             cpiContext: null,
+            lamportsChangeAccountMerkleTreeIndex: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
-        const approveInstruction = createApproveInstruction(source, this.deriveCpiAuthorityPda, owner, BigInt(amount.toString()));
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
@@ -6631,7 +6881,7 @@ class CompressedTokenProgram {
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [approveInstruction, instruction];
+        return instruction;
     }
     /**
      * Construct decompress instruction
@@ -6657,6 +6907,7 @@ class CompressedTokenProgram {
             compressOrDecompressAmount: amount,
             isCompress: false,
             cpiContext: null,
+            lamportsChangeAccountMerkleTreeIndex: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
@@ -6743,7 +6994,7 @@ async function approveAndMintTo(rpc, payer, mint, destination, authority, amount
  */
 async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions) {
     amount = stateless_js.bn(amount);
-    const [approveIx, compressIx] = await CompressedTokenProgram.compress({
+    const compressIx = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
         source: sourceTokenAccount,
@@ -6758,7 +7009,6 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
         web3_js.ComputeBudgetProgram.setComputeUnitLimit({
             units: 1000000,
         }),
-        approveIx,
         compressIx,
     ], payer, blockhashCtx.blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);