@lightprotocol/compressed-token 0.12.0 → 0.14.0

package/dist/cjs/node/index.cjs

@@ -6,7 +6,7 @@ var anchor = require('@coral-xyz/anchor');
 var require$$0 = require('buffer');
 
 const IDL = {
-    version: '1.0.0',
+    version: '1.2.0',
     name: 'light_compressed_token',
     instructions: [
         {
@@ -1556,128 +1556,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: 'ComputeInputSumFailed',
-            msg: 'ComputeInputSumFailed',
+            name: 'CreateTransferInstructionFailed',
+            msg: 'Create transfer instruction failed',
         },
         {
             code: 6002,
-            name: 'ComputeOutputSumFailed',
-            msg: 'ComputeOutputSumFailed',
+            name: 'AccountNotFound',
+            msg: 'Account not found',
         },
         {
             code: 6003,
-            name: 'ComputeCompressSumFailed',
-            msg: 'ComputeCompressSumFailed',
-        },
-        {
-            code: 6004,
-            name: 'ComputeDecompressSumFailed',
-            msg: 'ComputeDecompressSumFailed',
-        },
-        {
-            code: 6005,
-            name: 'SumCheckFailed',
-            msg: 'SumCheckFailed',
-        },
-        {
-            code: 6006,
-            name: 'DecompressRecipientUndefinedForDecompress',
-            msg: 'DecompressRecipientUndefinedForDecompress',
-        },
-        {
-            code: 6007,
-            name: 'CompressedPdaUndefinedForDecompress',
-            msg: 'CompressedPdaUndefinedForDecompress',
-        },
-        {
-            code: 6008,
-            name: 'DeCompressAmountUndefinedForDecompress',
-            msg: 'DeCompressAmountUndefinedForDecompress',
-        },
-        {
-            code: 6009,
-            name: 'CompressedPdaUndefinedForCompress',
-            msg: 'CompressedPdaUndefinedForCompress',
-        },
-        {
-            code: 6010,
-            name: 'DeCompressAmountUndefinedForCompress',
-            msg: 'DeCompressAmountUndefinedForCompress',
-        },
-        {
-            code: 6011,
-            name: 'DelegateSignerCheckFailed',
-            msg: 'DelegateSignerCheckFailed',
-        },
-        {
-            code: 6012,
-            name: 'MintTooLarge',
-            msg: 'Minted amount greater than u64::MAX',
-        },
-        {
-            code: 6013,
-            name: 'SplTokenSupplyMismatch',
-            msg: 'SplTokenSupplyMismatch',
-        },
-        {
-            code: 6014,
-            name: 'HeapMemoryCheckFailed',
-            msg: 'HeapMemoryCheckFailed',
-        },
-        {
-            code: 6015,
-            name: 'InstructionNotCallable',
-            msg: 'The instruction is not callable',
-        },
-        {
-            code: 6016,
-            name: 'ArithmeticUnderflow',
-            msg: 'ArithmeticUnderflow',
-        },
-        {
-            code: 6017,
-            name: 'HashToFieldError',
-            msg: 'HashToFieldError',
-        },
-        {
-            code: 6018,
-            name: 'InvalidAuthorityMint',
-            msg: 'Expected the authority to be also a mint authority',
-        },
-        {
-            code: 6019,
-            name: 'InvalidFreezeAuthority',
-            msg: 'Provided authority is not the freeze authority',
-        },
-        {
-            code: 6020,
-            name: 'InvalidDelegateIndex',
-        },
-        {
-            code: 6021,
-            name: 'TokenPoolPdaUndefined',
-        },
-        {
-            code: 6022,
-            name: 'IsTokenPoolPda',
-            msg: 'Compress or decompress recipient is the same account as the token pool pda.',
-        },
-        {
-            code: 6023,
-            name: 'InvalidTokenPoolPda',
-        },
-        {
-            code: 6024,
-            name: 'NoInputTokenAccountsProvided',
-        },
-        {
-            code: 6025,
-            name: 'NoInputsProvided',
+            name: 'SerializationError',
+            msg: 'Serialization error',
         },
     ],
 };
@@ -5033,6 +4928,22 @@ class CompressedTokenProgram {
             .instruction();
         return instruction;
     }
+    static async mergeTokenAccounts(params) {
+        const { payer, owner, inputCompressedTokenAccounts, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
+        if (inputCompressedTokenAccounts.length > 3) {
+            throw new Error('Cannot merge more than 3 token accounts at once');
+        }
+        const ix = await this.transfer({
+            payer,
+            inputCompressedTokenAccounts,
+            toAddress: owner,
+            amount: inputCompressedTokenAccounts.reduce((sum, account) => sum.add(account.parsed.amount), new anchor.BN(0)),
+            outputStateTrees: outputStateTree,
+            recentInputStateRootIndices,
+            recentValidityProof,
+        });
+        return [ix];
+    }
 }
 /**
  * Public key that identifies the CompressedPda program
@@ -5292,6 +5203,51 @@ async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTr
     return txId;
 }
 
+/**
+ * Merge multiple compressed token accounts for a given mint into a single
+ * account
+ *
+ * @param rpc             RPC to use
+ * @param payer           Payer of the transaction fees
+ * @param mint            Public key of the token's mint
+ * @param owner           Owner of the token accounts to be merged
+ * @param merkleTree      Optional merkle tree for compressed tokens
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Array of transaction signatures
+ */
+async function mergeTokenAccounts(rpc, payer, mint, owner, merkleTree, confirmOptions) {
+    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, { mint });
+    if (compressedTokenAccounts.items.length === 0) {
+        throw new Error(`No compressed token accounts found for mint ${mint.toBase58()}`);
+    }
+    if (compressedTokenAccounts.items.length >= 6) {
+        throw new Error(`Too many compressed token accounts used for mint ${mint.toBase58()}`);
+    }
+    const instructions = [
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+    ];
+    for (let i = 0; i < compressedTokenAccounts.items.slice(0, 6).length; i += 3) {
+        const batch = compressedTokenAccounts.items.slice(i, i + 3);
+        const proof = await rpc.getValidityProof(batch.map(account => stateless_js.bn(account.compressedAccount.hash)));
+        const batchInstructions = await CompressedTokenProgram.mergeTokenAccounts({
+            payer: payer.publicKey,
+            owner: owner.publicKey,
+            mint,
+            inputCompressedTokenAccounts: batch,
+            outputStateTree: merkleTree,
+            recentValidityProof: proof.compressedProof,
+            recentInputStateRootIndices: proof.rootIndices,
+        });
+        instructions.push(...batchInstructions);
+    }
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
+    const signedTx = stateless_js.buildAndSignTx(instructions, payer, blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
+    return txId;
+}
+
 /**
  * Register an existing mint with the CompressedToken program
  *
@@ -5360,6 +5316,7 @@ exports.createTokenPool = createTokenPool;
 exports.createTokenProgramLookupTable = createTokenProgramLookupTable;
 exports.createTransferOutputState = createTransferOutputState;
 exports.decompress = decompress;
+exports.mergeTokenAccounts = mergeTokenAccounts;
 exports.mintTo = mintTo;
 exports.packCompressedTokenAccounts = packCompressedTokenAccounts;
 exports.parseTokenData = parseTokenData;