refactor: improve code readability in activity-related routes and functions

Author: ShookLyngs

src/constants.ts

@@ -1,4 +1,4 @@
-import { isAdminMode } from './env';
+import { env, isAdminMode } from './env';
 import { BTCTestnetType } from '@rgbpp-sdk/ckb';
 
 export enum NetworkType {
@@ -41,3 +41,6 @@ export const BTC_SIGNET_SPV_START_BLOCK_HEIGHT = 199800;
 // estimate time: 2024-04-02 06:20:03
 // ref: https://mempool.space/block/0000000000000000000077d98a103858c7d7cbc5ba67a4135f348a436bec1748
 export const BTC_MAINNET_SPV_START_BLOCK_HEIGHT = 837300;
+
+export const IS_MAINNET = env.NETWORK === NetworkType.mainnet.toString();
+export const TESTNET_TYPE = TestnetTypeMap[env.NETWORK];

src/services/rgbpp.ts

@@ -5,21 +5,15 @@ import {
   IndexerCell,
   leToU128,
   isScriptEqual,
-  buildPreLockArgs,
   buildRgbppLockArgs,
   genRgbppLockScript,
-  getRgbppLockScript,
-  genBtcTimeLockArgs,
-  getBtcTimeLockScript,
   btcTxIdFromBtcTimeLockArgs,
-  calculateCommitment,
-  BTCTimeLock,
   RGBPP_TX_ID_PLACEHOLDER,
   RGBPP_TX_INPUTS_MAX_LENGTH,
 } from '@rgbpp-sdk/ckb';
 import { remove0x } from '@rgbpp-sdk/btc';
 import { unpackRgbppLockArgs } from '@rgbpp-sdk/btc/lib/ckb/molecule';
-import { groupBy, cloneDeep, uniq } from 'lodash';
+import { groupBy, uniq, findLastIndex } from 'lodash';
 import { z } from 'zod';
 import { Job } from 'bullmq';
 import { BI, RPC, Script } from '@ckb-lumos/lumos';
@@ -30,8 +24,9 @@ import { Transaction, UTXO } from './bitcoin/schema';
 import BaseQueueWorker from './base/queue-worker';
 import DataCache from './base/data-cache';
 import { Cradle } from '../container';
-import { TestnetTypeMap } from '../constants';
-import { tryGetCommitmentFromBtcTx } from '../utils/commitment';
+import { isCommitmentMatchToCkbTx, tryGetCommitmentFromBtcTx } from '../utils/commitment';
+import { getBtcTimeLock, isBtcTimeLock, isRgbppLock } from '../utils/lockscript';
+import { IS_MAINNET, TESTNET_TYPE } from '../constants';
 
 type GetCellsParams = Parameters<RPC['getCells']>;
 export type SearchKey = GetCellsParams[0];
@@ -92,30 +87,6 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
     this.limit = pLimit(100);
   }
 
-  private get isMainnet() {
-    return this.cradle.env.NETWORK === 'mainnet';
-  }
-
-  private get testnetType() {
-    return TestnetTypeMap[this.cradle.env.NETWORK];
-  }
-
-  private get rgbppLockScript() {
-    return getRgbppLockScript(this.isMainnet, this.testnetType);
-  }
-
-  private get btcTimeLockScript() {
-    return getBtcTimeLockScript(this.isMainnet, this.testnetType);
-  }
-
-  private isRgbppLock(lock: CKBComponents.Script) {
-    return lock.codeHash === this.rgbppLockScript.codeHash && lock.hashType === this.rgbppLockScript.hashType;
-  }
-
-  private isBtcTimeLock(lock: CKBComponents.Script) {
-    return lock.codeHash === this.btcTimeLockScript.codeHash && lock.hashType === this.btcTimeLockScript.hashType;
-  }
-
   /**
    * Capture the exception to the sentry scope with the btc address and utxos
    * @param job - the job that failed
@@ -189,7 +160,7 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
         const { txid, vout } = utxo;
         const args = buildRgbppLockArgs(vout, txid);
         const searchKey: SearchKey = {
-          script: genRgbppLockScript(args, this.isMainnet, this.testnetType),
+          script: genRgbppLockScript(args, IS_MAINNET, TESTNET_TYPE),
           scriptType: 'lock',
         };
         if (typeScript) {
@@ -277,7 +248,7 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
     const batchRequest = this.cradle.ckb.rpc.createBatchRequest(
       btcTx.vout.map((_, index) => {
         const args = buildRgbppLockArgs(index, btcTx.txid);
-        const lock = genRgbppLockScript(args, this.isMainnet, this.testnetType);
+        const lock = genRgbppLockScript(args, IS_MAINNET, TESTNET_TYPE);
         const searchKey: SearchKey = {
           script: lock,
           scriptType: 'lock',
@@ -291,7 +262,6 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
       for (const indexerTx of tx.objects) {
         const ckbTx = await this.cradle.ckb.rpc.getTransaction(indexerTx.txHash);
         const isIsomorphic = await this.isIsomorphicTx(btcTx, ckbTx.transaction);
-        // console.log('isIsomorphic', btcTx.txid, ckbTx.transaction.hash, isIsomorphic);
         if (isIsomorphic) {
           return indexerTx;
         }
@@ -302,21 +272,27 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
 
   public async queryBtcTimeLockTxByBtcTxId(btcTxId: string) {
     // XXX: unstable, need to be improved: https://github.com/ckb-cell/btc-assets-api/issues/45
-    const btcTimeLockTxs = await this.cradle.ckb.indexer.getTransactions({
-      script: {
-        ...this.btcTimeLockScript,
-        args: '0x',
+    const btcTimeLockTxs = await this.cradle.ckb.indexer.getTransactions(
+      {
+        script: {
+          ...getBtcTimeLock(),
+          args: '0x',
+        },
+        scriptType: 'lock',
+        groupByTransaction: true,
       },
-      scriptType: 'lock',
-    });
+      {
+        order: 'asc',
+      },
+    );
 
     const txHashes = uniq(btcTimeLockTxs.objects.map(({ txHash }) => txHash));
     const batchRequest = this.cradle.ckb.rpc.createBatchRequest(txHashes.map((txHash) => ['getTransaction', txHash]));
     const transactions: TransactionWithStatus[] = await batchRequest.exec();
     if (transactions.length > 0) {
       for (const tx of transactions) {
         const isBtcTimeLockTx = tx.transaction.outputs.some((output) => {
-          if (!isScriptEqual(output.lock, this.btcTimeLockScript)) {
+          if (!isScriptEqual(output.lock, getBtcTimeLock())) {
             return false;
           }
           const outputBtcTxId = btcTxIdFromBtcTimeLockArgs(output.lock.args);
@@ -330,18 +306,11 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
     return null;
   }
 
-  async isIsomorphicTx(btcTx: Transaction, ckbTx: CKBComponents.RawTransaction, validateCommitment?: boolean) {
-    const replaceLockArgsWithPlaceholder = (cell: CKBComponents.CellOutput, index: number) => {
-      if (this.isRgbppLock(cell.lock)) {
-        cell.lock.args = buildPreLockArgs(index + 1);
-      }
-      if (this.isBtcTimeLock(cell.lock)) {
-        const lockArgs = BTCTimeLock.unpack(cell.lock.args);
-        cell.lock.args = genBtcTimeLockArgs(lockArgs.lockScript, RGBPP_TX_ID_PLACEHOLDER, lockArgs.after);
-      }
-      return cell;
-    };
-
+  async isIsomorphicTx(
+    btcTx: Transaction,
+    ckbTx: CKBComponents.RawTransaction,
+    validateCommitment?: boolean,
+  ): Promise<boolean> {
     // Find the commitment from the btc_tx
     const btcTxCommitment = tryGetCommitmentFromBtcTx(btcTx);
     if (!btcTxCommitment) {
@@ -352,86 +321,68 @@ export default class RgbppCollector extends BaseQueueWorker<IRgbppCollectRequest
     // 1. Find the last index of the type inputs
     // 2. Check if all rgbpp_lock inputs can be found in the btc_tx.vin
     // 3. Check if the inputs contain at least one rgbpp_lock cell (as L1-L1 and L1-L2 transactions should have)
-    let lastTypeInputIndex = -1;
-    let foundRgbppLockInput = false;
-    const outPoints = ckbTx.inputs.map((input) => input.previousOutput!);
-    const inputs = await this.cradle.ckb.getInputCellsByOutPoint(outPoints);
-    for (let i = 0; i < inputs.length; i++) {
-      if (inputs[i].type) {
-        lastTypeInputIndex = i;
-        const isRgbppLock = this.isRgbppLock(inputs[i].lock);
-        if (isRgbppLock) {
-          foundRgbppLockInput = true;
-          const btcInput = btcTx.vin[i];
-          const rgbppLockArgs = unpackRgbppLockArgs(inputs[i].lock.args);
-          if (
-            !btcInput ||
-            btcInput.txid !== remove0x(rgbppLockArgs.btcTxid) ||
-            btcInput.vout !== rgbppLockArgs.outIndex
-          ) {
-            return false;
-          }
-        }
-      }
+    const inputs = await this.cradle.ckb.getInputCellsByOutPoint(ckbTx.inputs.map((input) => input.previousOutput!));
+    const lastTypeInputIndex = findLastIndex(inputs, (input) => !!input.cellOutput.type);
+    const anyRgbppLockInput = inputs.some((input) => isRgbppLock(input.cellOutput.lock));
+    if (!anyRgbppLockInput) {
+      return false;
     }
-    // XXX: In some type of RGB++ transactions, the inputs may not contain any rgbpp_lock cells
-    // We add this check to ensure this function only validates for L1-L1 and L1-L2 transactions
-    if (!foundRgbppLockInput) {
+    const allInputsValid = inputs.every((input, index) => {
+      if (!input.cellOutput.type) {
+        return true;
+      }
+      if (!isRgbppLock(input.cellOutput.lock)) {
+        return true;
+      }
+      const btcInput = btcTx.vin[index];
+      const rgbppLockArgs = unpackRgbppLockArgs(input.cellOutput.lock.args);
+      return btcInput && btcInput.txid === remove0x(rgbppLockArgs.btcTxid) && btcInput.vout === rgbppLockArgs.outIndex;
+    });
+    if (!allInputsValid) {
       return false;
     }
 
     // Check outputs:
-    // 1. Find the last index of the type outputs
-    // 2. Check if all type outputs are rgbpp_lock/btc_time_lock cells
-    // 3. Check if each rgbpp_lock cell has an isomorphic UTXO in the btc_tx.vout
-    // 4. Check if each btc_time_lock cell contains the corresponding btc_txid in the lock args
-    // 5. Check if the outputs contain at least one rgbpp_lock/btc_time_lock cell
-    let lastTypeOutputIndex = -1;
-    for (let i = 0; i < ckbTx.outputs.length; i++) {
-      const ckbOutput = ckbTx.outputs[i];
-      const isRgbppLock = this.isRgbppLock(ckbOutput.lock);
-      const isBtcTimeLock = this.isBtcTimeLock(ckbOutput.lock);
-      if (isRgbppLock) {
-        const rgbppLockArgs = unpackRgbppLockArgs(ckbOutput.lock.args);
+    // 1. Find the last index of the type outputs, and check if at least one type output exists
+    // 2. Check if all type outputs are rgbpp_lock or btc_time_lock cells
+    // 4. Check if each rgbpp_lock cell has an isomorphic UTXO in the btc_tx.vout
+    // 5. Check if each btc_time_lock cell contains the corresponding btc_txid in the lock args
+    const lastTypeOutputIndex = findLastIndex(ckbTx.outputs, (output) => !!output.type);
+    if (lastTypeOutputIndex < 0) {
+      return false;
+    }
+    const anyRelatedLockToTypeOutput = ckbTx.outputs.some(
+      (output) => output.type && (isRgbppLock(output.lock) || isBtcTimeLock(output.lock)),
+    );
+    if (!anyRelatedLockToTypeOutput) {
+      return false;
+    }
+    const allOutputsValid = ckbTx.outputs.every((output) => {
+      if (isRgbppLock(output.lock)) {
+        const rgbppLockArgs = unpackRgbppLockArgs(output.lock.args);
         const btcTxId = remove0x(rgbppLockArgs.btcTxid);
         if (btcTxId !== RGBPP_TX_ID_PLACEHOLDER && (btcTxId !== btcTx.txid || !btcTx.vout[rgbppLockArgs.outIndex])) {
           return false;
         }
       }
-      if (isBtcTimeLock) {
-        const btcTxId = remove0x(btcTxIdFromBtcTimeLockArgs(ckbOutput.lock.args));
+      if (isBtcTimeLock(output.lock)) {
+        const btcTxId = remove0x(btcTxIdFromBtcTimeLockArgs(output.lock.args));
         if (btcTxId !== RGBPP_TX_ID_PLACEHOLDER && btcTx.txid !== btcTxId) {
           return false;
         }
       }
-      if (ckbOutput.type) {
-        lastTypeOutputIndex = i;
-      }
-    }
-    if (lastTypeOutputIndex < 0) {
+      return true;
+    });
+    if (!allOutputsValid) {
       return false;
     }
 
-    // Cut the ckb_tx to simulate how the ckb_virtual_tx looks like
-    const ckbVirtualTx = cloneDeep(ckbTx);
-    ckbVirtualTx.inputs = ckbVirtualTx.inputs.slice(0, Math.max(lastTypeInputIndex, 0) + 1);
-    ckbVirtualTx.outputs = ckbVirtualTx.outputs.slice(0, lastTypeOutputIndex + 1).map(replaceLockArgsWithPlaceholder);
-
-    // Copy ckb_tx and change output lock args to placeholder args
-    const ckbPlaceholderTx = cloneDeep(ckbTx);
-    ckbPlaceholderTx.outputs = ckbPlaceholderTx.outputs.map(replaceLockArgsWithPlaceholder);
+    // Compare commitment between btc_tx and ckb_tx
     if (!validateCommitment) {
       return true;
     }
-
-    // Generate commitment with the ckb_tx/ckb_virtual_tx, then compare it with the btc_tx commitment.
-    // If both commitments don't match the btc_tx commitment:
-    // 1. The ckb_tx is not the isomorphic transaction of the btc_tx (this is the usual case)
-    // 2. The commitment calculation logic differs from the one used in the btc_tx/ckb_tx
-    const ckbTxCommitment = calculateCommitment(ckbPlaceholderTx);
-    const ckbVirtualTxCommitment = calculateCommitment(ckbVirtualTx);
     const btcTxCommitmentHex = btcTxCommitment.toString('hex');
-    return btcTxCommitmentHex === ckbVirtualTxCommitment || btcTxCommitmentHex === ckbTxCommitment;
+    return isCommitmentMatchToCkbTx(btcTxCommitmentHex, ckbTx, lastTypeInputIndex, lastTypeOutputIndex);
   }
 
   /**

src/utils/commitment.ts

@@ -1,5 +1,9 @@
+import { cloneDeep } from 'lodash';
 import { opReturnScriptPubKeyToData } from '@rgbpp-sdk/btc';
+import { calculateCommitment } from '@rgbpp-sdk/ckb/lib/utils/rgbpp';
+import { RGBPP_TX_ID_PLACEHOLDER, BTCTimeLock, buildPreLockArgs, genBtcTimeLockArgs } from '@rgbpp-sdk/ckb';
 import { Transaction } from '../routes/bitcoin/types';
+import { isBtcTimeLock, isRgbppLock } from './lockscript';
 
 export class OpReturnNotFoundError extends Error {
   constructor(txid: string) {
@@ -9,11 +13,11 @@ export class OpReturnNotFoundError extends Error {
 }
 
 /**
- * Get commitment from Bitcoin transactions
+ * Get commitment from the Bitcoin transaction
  * depended on @rgbpp-sdk/btc opReturnScriptPubKeyToData method
  * @param tx - Bitcoin transaction
  */
-export function getCommitmentFromBtcTx(tx: Transaction) {
+export function getCommitmentFromBtcTx(tx: Transaction): Buffer {
   const opReturn = tx.vout.find((vout) => vout.scriptpubkey_type === 'op_return');
   if (!opReturn) {
     throw new OpReturnNotFoundError(tx.txid);
@@ -22,7 +26,12 @@ export function getCommitmentFromBtcTx(tx: Transaction) {
   return opReturnScriptPubKeyToData(buffer);
 }
 
-export function tryGetCommitmentFromBtcTx(tx: Transaction) {
+/**
+ * Try to get commitment from the Bitcoin transactions, returns null if OP_RETURN output not found
+ * depended on @rgbpp-sdk/btc opReturnScriptPubKeyToData method
+ * @param tx - Bitcoin transaction
+ */
+export function tryGetCommitmentFromBtcTx(tx: Transaction): Buffer | null {
   try {
     return getCommitmentFromBtcTx(tx);
   } catch (error) {
@@ -32,3 +41,50 @@ export function tryGetCommitmentFromBtcTx(tx: Transaction) {
     throw error;
   }
 }
+
+/**
+ * Validate if the commitment matches the CKB transaction
+ * @param commitment - The expected commitment from a Bitcoin transaction
+ * @param ckbTx - The target CKB transaction or RawTransaction to compare with
+ * @param lastTypeInputIndex - The last index of type script input in the ckbTx
+ * @param lastTypeOutputIndex - The last index of type script output in the ckbTx
+ */
+export function isCommitmentMatchToCkbTx(
+  commitment: string,
+  ckbTx: CKBComponents.RawTransaction,
+  lastTypeInputIndex: number,
+  lastTypeOutputIndex: number,
+) {
+  function replaceLockArgsWithPlaceholder(cell: CKBComponents.CellOutput, outputIndex: number) {
+    if (isRgbppLock(cell.lock)) {
+      cell.lock.args = buildPreLockArgs(outputIndex + 1);
+    }
+    if (isBtcTimeLock(cell.lock)) {
+      const lockArgs = BTCTimeLock.unpack(cell.lock.args);
+      cell.lock.args = genBtcTimeLockArgs(lockArgs.lockScript, RGBPP_TX_ID_PLACEHOLDER, lockArgs.after);
+    }
+    return cell;
+  }
+
+  // Use the ckb_tx to compare with the btc_tx commitment directly
+  const finalTx = cloneDeep(ckbTx);
+  finalTx.outputs = finalTx.outputs.map(replaceLockArgsWithPlaceholder);
+  const finalTxCommitment = calculateCommitment(finalTx);
+  if (commitment === finalTxCommitment) {
+    return true;
+  }
+
+  // Slice inputs and outputs of the ckb_tx to simulate how the original ckb_virtual_result looks like
+  const slicedTx = cloneDeep(ckbTx);
+  slicedTx.inputs = slicedTx.inputs.slice(0, Math.max(lastTypeInputIndex, 0) + 1);
+  slicedTx.outputs = slicedTx.outputs.slice(0, lastTypeOutputIndex + 1).map(replaceLockArgsWithPlaceholder);
+  const slicedTxCommitment = calculateCommitment(slicedTx);
+  if (commitment === slicedTxCommitment) {
+    return true;
+  }
+
+  // If both commitments don't match the btc_tx commitment:
+  // 1. The ckb_tx does not match to the commitment from the btc_tx (the usual case)
+  // 2. The provided btc_tx commitment calculation is different from this function
+  return false;
+}