@lightprotocol/compressed-token 0.3.3 → 0.4.0

package/dist/cjs/node/index.cjs

@@ -12,16 +12,17 @@ const IDL = {
         {
             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',
@@ -57,13 +58,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',
@@ -84,6 +89,9 @@ const IDL = {
                     name: 'tokenPoolPda',
                     isMut: true,
                     isSigner: false,
+                    docs: [
+                        'account to a token account of a different mint will fail',
+                    ],
                 },
                 {
                     name: 'tokenProgram',
@@ -104,6 +112,7 @@ const IDL = {
                     name: 'noopProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: ['programs'],
                 },
                 {
                     name: 'accountCompressionAuthority',
@@ -130,6 +139,12 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'solPoolPda',
+                    isMut: true,
+                    isSigner: false,
+                    isOptional: true,
+                },
             ],
             args: [
                 {
@@ -144,20 +159,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',
@@ -193,6 +230,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',
@@ -227,16 +268,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',
@@ -272,6 +327,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',
@@ -288,16 +347,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',
@@ -333,6 +402,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',
@@ -349,11 +422,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',
@@ -394,6 +472,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',
@@ -415,11 +497,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',
@@ -460,6 +547,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',
@@ -481,22 +572,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,
@@ -552,11 +669,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',
@@ -592,6 +715,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',
@@ -633,24 +760,6 @@ const IDL = {
             ],
         },
     ],
-    accounts: [
-        {
-            name: 'RegisteredProgram',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'registeredProgramId',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'groupAuthorityPda',
-                        type: 'publicKey',
-                    },
-                ],
-            },
-        },
-    ],
     types: [
         {
             name: 'AccessMetadata',
@@ -665,7 +774,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',
                     },
@@ -749,10 +858,25 @@ const IDL = {
                 fields: [
                     {
                         name: 'setContext',
+                        docs: [
+                            'Is set by the program that is invoking the CPI to signal that is should',
+                            'set the cpi context.',
+                        ],
+                        type: 'bool',
+                    },
+                    {
+                        name: 'firstSetContext',
+                        docs: [
+                            'Is set to wipe the cpi context since someone could have set it before',
+                            'with unrelated data.',
+                        ],
                         type: 'bool',
                     },
                     {
                         name: 'cpiContextAccountIndex',
+                        docs: [
+                            'Index of cpi context account in remaining accounts.',
+                        ],
                         type: 'u8',
                     },
                 ],
@@ -804,9 +928,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: {
@@ -848,11 +972,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: [
@@ -862,7 +995,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',
+                        },
                     },
                 ],
             },
@@ -898,6 +1039,15 @@ const IDL = {
                             option: 'u64',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1159,6 +1309,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',
+                            },
+                        },
+                    },
                 ],
             },
         },
@@ -1185,6 +1347,15 @@ const IDL = {
                         name: 'merkleTreeIndex',
                         type: 'u8',
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1262,6 +1433,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: {
@@ -1348,6 +1537,15 @@ const IDL = {
                             defined: 'AccountState',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1355,108 +1553,23 @@ const IDL = {
     errors: [
         {
             code: 6000,
-            name: 'PublicKeyAmountMissmatch',
-            msg: 'public keys and amounts must be of same length',
+            name: 'SignerCheckFailed',
+            msg: 'Signer check failed',
         },
         {
             code: 6001,
-            name: 'SignerCheckFailed',
-            msg: 'SignerCheckFailed',
+            name: 'CreateTransferInstructionFailed',
+            msg: 'Create transfer instruction failed',
         },
         {
             code: 6002,
-            name: 'ComputeInputSumFailed',
-            msg: 'ComputeInputSumFailed',
+            name: 'AccountNotFound',
+            msg: 'Account not found',
         },
         {
             code: 6003,
-            name: 'ComputeOutputSumFailed',
-            msg: 'ComputeOutputSumFailed',
-        },
-        {
-            code: 6004,
-            name: 'ComputeCompressSumFailed',
-            msg: 'ComputeCompressSumFailed',
-        },
-        {
-            code: 6005,
-            name: 'ComputeDecompressSumFailed',
-            msg: 'ComputeDecompressSumFailed',
-        },
-        {
-            code: 6006,
-            name: 'SumCheckFailed',
-            msg: 'SumCheckFailed',
-        },
-        {
-            code: 6007,
-            name: 'DecompressRecipientUndefinedForDecompress',
-            msg: 'DecompressRecipientUndefinedForDecompress',
-        },
-        {
-            code: 6008,
-            name: 'CompressedPdaUndefinedForDecompress',
-            msg: 'CompressedPdaUndefinedForDecompress',
-        },
-        {
-            code: 6009,
-            name: 'DeCompressAmountUndefinedForDecompress',
-            msg: 'DeCompressAmountUndefinedForDecompress',
-        },
-        {
-            code: 6010,
-            name: 'CompressedPdaUndefinedForCompress',
-            msg: 'CompressedPdaUndefinedForCompress',
-        },
-        {
-            code: 6011,
-            name: 'DeCompressAmountUndefinedForCompress',
-            msg: 'DeCompressAmountUndefinedForCompress',
-        },
-        {
-            code: 6012,
-            name: 'DelegateUndefined',
-            msg: 'DelegateUndefined while delegated amount is defined',
-        },
-        {
-            code: 6013,
-            name: 'DelegateSignerCheckFailed',
-            msg: 'DelegateSignerCheckFailed',
-        },
-        {
-            code: 6014,
-            name: 'SplTokenSupplyMismatch',
-            msg: 'SplTokenSupplyMismatch',
-        },
-        {
-            code: 6015,
-            name: 'HeapMemoryCheckFailed',
-            msg: 'HeapMemoryCheckFailed',
-        },
-        {
-            code: 6016,
-            name: 'InstructionNotCallable',
-            msg: 'The instruction is not callable',
-        },
-        {
-            code: 6017,
-            name: 'ArithmeticUnderflow',
-            msg: 'ArithmeticUnderflow',
-        },
-        {
-            code: 6018,
-            name: 'InvalidDelegate',
-            msg: 'InvalidDelegate',
-        },
-        {
-            code: 6019,
-            name: 'HashToFieldError',
-            msg: 'HashToFieldError',
-        },
-        {
-            code: 6020,
-            name: 'InvalidMint',
-            msg: 'InvalidMint',
+            name: 'SerializationError',
+            msg: 'Serialization error',
         },
     ],
 };
@@ -1487,11 +1600,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
@@ -1507,6 +1622,7 @@ function packCompressedTokenAccounts(params) {
                 ? null
                 : tokenTransferOutputs[index].lamports,
             merkleTreeIndex,
+            tlv: null,
         });
     });
     // to meta
@@ -4055,33 +4171,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";
@@ -4405,6 +4494,7 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
                 owner: toAddress,
                 amount,
                 lamports: inputLamports,
+                tlv: null,
             },
         ];
     }
@@ -4416,11 +4506,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;
@@ -4449,6 +4541,7 @@ function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
             owner: inputCompressedTokenAccounts[0].parsed.owner,
             amount: changeAmount,
             lamports: inputLamports,
+            tlv: null,
         },
     ];
     return tokenTransferOutputs;
@@ -4542,7 +4635,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,
@@ -4557,6 +4650,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;
@@ -4571,7 +4665,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,
@@ -4580,7 +4674,7 @@ class CompressedTokenProgram {
             amount: params.amount,
             outputStateTree: merkleTree,
         });
-        return [splMintToInstruction, approveInstruction, compressInstruction];
+        return [splMintToInstruction, compressInstruction];
     }
     /**
      * Construct transfer instruction for compressed tokens
@@ -4604,6 +4698,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();
@@ -4628,8 +4723,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;
@@ -4639,6 +4734,7 @@ class CompressedTokenProgram {
                 owner: toAddress,
                 amount,
                 lamports: stateless_js.bn(0),
+                tlv: null,
             },
         ];
         const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
@@ -4656,10 +4752,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({
@@ -4678,7 +4774,7 @@ class CompressedTokenProgram {
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [approveInstruction, instruction];
+        return instruction;
     }
     /**
      * Construct decompress instruction
@@ -4704,6 +4800,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();
@@ -4790,7 +4887,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,
@@ -4805,7 +4902,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);