@lightprotocol/compressed-token 0.3.4 → 0.5.0

package/dist/types/index.d.ts

@@ -3,22 +3,23 @@ import { PublicKey, AccountMeta, TransactionInstruction, Signer, ConfirmOptions,
 import { BN, Program } from '@coral-xyz/anchor';
 
 type LightCompressedToken = {
-    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';
@@ -54,13 +55,17 @@ type LightCompressedToken = {
                 '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 @@ type LightCompressedToken = {
                     name: 'tokenPoolPda';
                     isMut: true;
                     isSigner: false;
+                    docs: [
+                        'account to a token account of a different mint will fail'
+                    ];
                 },
                 {
                     name: 'tokenProgram';
@@ -101,6 +109,7 @@ type LightCompressedToken = {
                     name: 'noopProgram';
                     isMut: false;
                     isSigner: false;
+                    docs: ['programs'];
                 },
                 {
                     name: 'accountCompressionAuthority';
@@ -126,6 +135,12 @@ type LightCompressedToken = {
                     name: 'systemProgram';
                     isMut: false;
                     isSigner: false;
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
                 }
             ];
             args: [
@@ -140,21 +155,43 @@ type LightCompressedToken = {
                     type: {
                         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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
         },
         {
             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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
         },
         {
             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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
         },
         {
             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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
         },
         {
             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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
         },
         {
             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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
                     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 @@ type LightCompressedToken = {
             ];
         }
     ];
-    accounts: [
-        {
-            name: 'RegisteredProgram';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
-                        name: 'registeredProgramId';
-                        type: 'publicKey';
-                    },
-                    {
-                        name: 'groupAuthorityPda';
-                        type: 'publicKey';
-                    }
-                ];
-            };
-        }
-    ];
     types: [
         {
             name: 'AccessMetadata';
@@ -662,7 +771,7 @@ type LightCompressedToken = {
                     {
                         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 @@ type LightCompressedToken = {
                     {
                         name: 'delegatedTransfer';
                         docs: [
-                            'If the signer is a delegate, the delegate index is index 0 of remaining accounts.',
-                            'owner = Some(owner) is the owner of the token account.',
-                            'Is set if the signer is delegate'
+                            'Is required if the signer is delegate,',
+                            '-> delegate is authority account,',
+                            'owner = Some(owner) is the owner of the token account.'
                         ];
                         type: {
                             option: {
@@ -859,12 +968,21 @@ type LightCompressedToken = {
                                 defined: 'CompressedCpiContext';
                             };
                         };
+                    },
+                    {
+                        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 @@ type LightCompressedToken = {
                     },
                     {
                         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';
+                        };
                     }
                 ];
             };
@@ -909,6 +1035,15 @@ type LightCompressedToken = {
                         type: {
                             option: 'u64';
                         };
+                    },
+                    {
+                        name: 'tlv';
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                        ];
+                        type: {
+                            option: 'bytes';
+                        };
                     }
                 ];
             };
@@ -1170,6 +1305,18 @@ type LightCompressedToken = {
                     {
                         name: 'leafIndex';
                         type: 'u32';
+                    },
+                    {
+                        name: 'queueIndex';
+                        docs: [
+                            'Index of leaf in queue. Placeholder of batched Merkle tree updates',
+                            'currently unimplemented.'
+                        ];
+                        type: {
+                            option: {
+                                defined: 'QueueIndex';
+                            };
+                        };
                     }
                 ];
             };
@@ -1196,6 +1343,15 @@ type LightCompressedToken = {
                     {
                         name: 'merkleTreeIndex';
                         type: 'u8';
+                    },
+                    {
+                        name: 'tlv';
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                        ];
+                        type: {
+                            option: 'bytes';
+                        };
                     }
                 ];
             };
@@ -1274,6 +1430,24 @@ type LightCompressedToken = {
                 ];
             };
         },
+        {
+            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: {
@@ -1359,6 +1533,15 @@ type LightCompressedToken = {
                         type: {
                             defined: 'AccountState';
                         };
+                    },
+                    {
+                        name: 'tlv';
+                        docs: [
+                            'Placeholder for TokenExtension tlv data (unimplemented)'
+                        ];
+                        type: {
+                            option: 'bytes';
+                        };
                     }
                 ];
             };
@@ -1367,23 +1550,107 @@ type LightCompressedToken = {
     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';
         }
     ];
 };
@@ -1402,6 +1669,10 @@ type TokenTransferOutputData = {
      * lamports associated with the output token account
      */
     lamports: BN | null;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
 };
 type PackedTokenTransferOutputData = {
     /**
@@ -1420,6 +1691,10 @@ type PackedTokenTransferOutputData = {
      * Merkle tree pubkey index in remaining accounts
      */
     merkleTreeIndex: number;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
 };
 type InputTokenDataWithContext = {
     /**
@@ -1446,6 +1721,10 @@ type InputTokenDataWithContext = {
      * Lamports in the input token account.
      */
     lamports: BN | null;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
 };
 type CompressedTokenInstructionDataInvoke = {
     /**
@@ -1478,6 +1757,10 @@ type CompressedTokenInstructionDataInvoke = {
      * accounts'
      */
     outputStateMerkleTreeAccountIndices: Buffer;
+    /**
+     * The index of the Merkle tree for a lamport change account.
+     */
+    lamportsChangeAccountMerkleTreeIndex: number | null;
 };
 type TokenData = {
     /**
@@ -1501,6 +1784,10 @@ type TokenData = {
      * The account's state
      */
     state: number;
+    /**
+     * TokenExtension tlv
+     */
+    tlv: Buffer | null;
 };
 
 type PackCompressedTokenAccountsParams = {
@@ -1812,10 +2099,10 @@ declare class CompressedTokenProgram {
      */
     static transfer(params: TransferParams): Promise<TransactionInstruction>;
     /**
-     * Construct approve and compress instructions
-     * @returns [approveInstruction, compressInstruction]
+     * Construct compress instruction
+     * @returns compressInstruction
      */
-    static compress(params: CompressParams): Promise<TransactionInstruction[]>;
+    static compress(params: CompressParams): Promise<TransactionInstruction>;
     /**
      * Construct decompress instruction
      */