@lightprotocol/compressed-token 0.3.4 → 0.4.0

package/dist/es/browser/index.js

@@ -1,5 +1,5 @@
 import { getIndexOrAdd, bn, padOutputStateMerkleTrees, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, defaultTestStateTreeAccounts, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx } from '@lightprotocol/stateless.js';
-import { PublicKey, TransactionInstruction, SystemProgram, Transaction, sendAndConfirmTransaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
+import { PublicKey, SystemProgram, TransactionInstruction, Transaction, sendAndConfirmTransaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
 import { AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
 
 const IDL = {
@@ -9,16 +9,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',
@@ -54,13 +55,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',
@@ -81,6 +86,9 @@ const IDL = {
                     name: 'tokenPoolPda',
                     isMut: true,
                     isSigner: false,
+                    docs: [
+                        'account to a token account of a different mint will fail',
+                    ],
                 },
                 {
                     name: 'tokenProgram',
@@ -101,6 +109,7 @@ const IDL = {
                     name: 'noopProgram',
                     isMut: false,
                     isSigner: false,
+                    docs: ['programs'],
                 },
                 {
                     name: 'accountCompressionAuthority',
@@ -127,6 +136,12 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'solPoolPda',
+                    isMut: true,
+                    isSigner: false,
+                    isOptional: true,
+                },
             ],
             args: [
                 {
@@ -141,20 +156,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',
@@ -190,6 +227,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',
@@ -224,16 +265,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',
@@ -269,6 +324,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',
@@ -285,16 +344,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',
@@ -330,6 +399,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',
@@ -346,11 +419,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',
@@ -391,6 +469,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',
@@ -412,11 +494,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',
@@ -457,6 +544,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',
@@ -478,22 +569,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,
@@ -549,11 +666,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',
@@ -589,6 +712,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',
@@ -630,24 +757,6 @@ const IDL = {
             ],
         },
     ],
-    accounts: [
-        {
-            name: 'RegisteredProgram',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'registeredProgramId',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'groupAuthorityPda',
-                        type: 'publicKey',
-                    },
-                ],
-            },
-        },
-    ],
     types: [
         {
             name: 'AccessMetadata',
@@ -662,7 +771,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',
                     },
@@ -816,9 +925,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: {
@@ -860,11 +969,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: [
@@ -874,7 +992,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',
+                        },
                     },
                 ],
             },
@@ -910,6 +1036,15 @@ const IDL = {
                             option: 'u64',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1171,6 +1306,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',
+                            },
+                        },
+                    },
                 ],
             },
         },
@@ -1197,6 +1344,15 @@ const IDL = {
                         name: 'merkleTreeIndex',
                         type: 'u8',
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1274,6 +1430,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: {
@@ -1360,6 +1534,15 @@ const IDL = {
                             defined: 'AccountState',
                         },
                     },
+                    {
+                        name: 'tlv',
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)',
+                        ],
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
                 ],
             },
         },
@@ -1414,11 +1597,13 @@ function packCompressedTokenAccounts(params) {
                 merkleTreePubkeyIndex,
                 nullifierQueuePubkeyIndex,
                 leafIndex: account.compressedAccount.leafIndex,
+                queueIndex: null,
             },
             rootIndex: rootIndices[index],
             lamports: account.compressedAccount.lamports.eq(bn(0))
                 ? null
                 : account.compressedAccount.lamports,
+            tlv: null,
         });
     });
     /// pack output state trees
@@ -1433,6 +1618,7 @@ function packCompressedTokenAccounts(params) {
                 ? null
                 : tokenTransferOutputs[index].lamports,
             merkleTreeIndex,
+            tlv: null,
         });
     });
     // to meta
@@ -6005,33 +6191,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 TransactionInstruction({ keys, programId, data });
-}
-
 var AccountType;
 (function (AccountType) {
     AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
@@ -6355,6 +6514,7 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
                 owner: toAddress,
                 amount,
                 lamports: inputLamports,
+                tlv: null,
             },
         ];
     }
@@ -6366,11 +6526,13 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
             owner: inputCompressedTokenAccounts[0].parsed.owner,
             amount: changeAmount,
             lamports: inputLamports,
+            tlv: null,
         },
         {
             owner: toAddress,
             amount,
             lamports: bn(0),
+            tlv: null,
         },
     ];
     return outputCompressedAccounts;
@@ -6399,6 +6561,7 @@ function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
             owner: inputCompressedTokenAccounts[0].parsed.owner,
             amount: changeAmount,
             lamports: inputLamports,
+            tlv: null,
         },
     ];
     return tokenTransferOutputs;
@@ -6497,7 +6660,7 @@ class CompressedTokenProgram {
         const amounts = toArray(amount).map(amount => bn(amount));
         const toPubkeys = toArray(toPubkey);
         const instruction = await this.program.methods
-            .mintTo(toPubkeys, amounts)
+            .mintTo(toPubkeys, amounts, null)
             .accounts({
             feePayer,
             authority,
@@ -6512,6 +6675,7 @@ class CompressedTokenProgram {
             accountCompressionProgram: systemKeys.accountCompressionProgram,
             merkleTree: merkleTree ?? defaultTestStateTreeAccounts().merkleTree,
             selfProgram: this.programId,
+            solPoolPda: null,
         })
             .instruction();
         return instruction;
@@ -6526,7 +6690,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,
@@ -6535,7 +6699,7 @@ class CompressedTokenProgram {
             amount: params.amount,
             outputStateTree: merkleTree,
         });
-        return [splMintToInstruction, approveInstruction, compressInstruction];
+        return [splMintToInstruction, compressInstruction];
     }
     /**
      * Construct transfer instruction for compressed tokens
@@ -6559,6 +6723,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, } = defaultStaticAccountsStruct();
@@ -6583,8 +6748,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;
@@ -6594,6 +6759,7 @@ class CompressedTokenProgram {
                 owner: toAddress,
                 amount,
                 lamports: bn(0),
+                tlv: null,
             },
         ];
         const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
@@ -6611,10 +6777,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, } = defaultStaticAccountsStruct();
-        const approveInstruction = createApproveInstruction(source, this.deriveCpiAuthorityPda, owner, BigInt(amount.toString()));
         const instruction = await this.program.methods
             .transfer(encodedData)
             .accounts({
@@ -6633,7 +6799,7 @@ class CompressedTokenProgram {
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [approveInstruction, instruction];
+        return instruction;
     }
     /**
      * Construct decompress instruction
@@ -6659,6 +6825,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, } = defaultStaticAccountsStruct();
@@ -6740,7 +6907,7 @@ async function approveAndMintTo(rpc, payer, mint, destination, authority, amount
  */
 async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions) {
     amount = bn(amount);
-    const [approveIx, compressIx] = await CompressedTokenProgram.compress({
+    const compressIx = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
         source: sourceTokenAccount,
@@ -6755,7 +6922,6 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
         ComputeBudgetProgram.setComputeUnitLimit({
             units: 1_000_000,
         }),
-        approveIx,
         compressIx,
     ], payer, blockhashCtx.blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);