@ocap/resolver 1.18.159 → 1.18.160

package/lib/index.js

@@ -756,9 +756,9 @@ module.exports = class OCAPResolver {
     }
   }
 
-  runAsLambda(fn) {
+  runAsLambda(fn, args) {
     if (typeof this.statedb.runAsLambda === 'function') {
-      return this.statedb.runAsLambda((txn) => fn(txn));
+      return this.statedb.runAsLambda((txn) => fn(txn), args);
     }
 
     return fn();
@@ -1036,7 +1036,7 @@ module.exports = class OCAPResolver {
 
     const totalPage = Math.floor(paging.total / pageSize);
     const cursors = new Array(totalPage).fill(true).map((_, i) => (i + 1) * pageSize);
-    const step = 3;
+    const step = process.env.RESOLVER_BATCH_CONCURRENCY || 3;
     let results = firstPage;
 
     for (let i = 0; i < cursors.length; i += step) {

package/lib/token-flow.js

@@ -1,3 +1,4 @@
+/* eslint-disable consistent-return */
 /* eslint-disable no-await-in-loop */
 
 const { BN, fromTokenToUnit, isSameDid } = require('@ocap/util');
@@ -131,6 +132,15 @@ const getInitialBalance = (address, config) => {
   return account ? fromTokenToUnit(account.balance) : ZERO;
 };
 
+const getBalance = async (address, tokenAddress, { resolver, txn }) => {
+  const state = await resolver.statedb.account.get(address, { txn, traceMigration: false });
+  if (!state) {
+    throw new CustomError('INVALID_REQUEST', `Invalid address ${address}`);
+  }
+  const balance = state.tokens[tokenAddress] || 0;
+  return balance;
+};
+
 const fixMigrateReceipts = async (tx, resolver) => {
   const migrationChain = await resolver.getMigrationChain();
   const txTime = new Date(tx.time);
@@ -146,9 +156,9 @@ const verifyAccountRisk = async (
   ctx = {}
 ) => {
   // validate request params
-  const { error } = paramsSchema.validate({ accountAddress, tokenAddress, resolver });
-  if (error) {
-    throw new CustomError('INVALID_PARAMS', error.message);
+  const validation = paramsSchema.validate({ accountAddress, tokenAddress, resolver });
+  if (validation.error) {
+    throw new CustomError('INVALID_PARAMS', validation.error.message);
   }
 
   const checkedAccounts = new Map();
@@ -158,138 +168,152 @@ const verifyAccountRisk = async (
   const toleranceUnit = fromTokenToUnit(tolerance, tokenState?.decimal);
   const vaultAccounts = getVaultAccounts(resolver.config);
 
-  while (accountQueue.length) {
-    // limit
-    if (checkedAccounts.size >= accountLimit) {
-      return {
-        isRisky: false,
-        reason: 'MAX_ACCOUNT_SIZE_LIMIT',
-        data: {
-          accountCount: checkedAccounts.size,
-          txCount: checkedTx.size,
-        },
-      };
+  let executeCount = 0;
+
+  const execute = async (txn) => {
+    if (executeCount > 1) {
+      throw new CustomError('INVALID_REQUEST', 'verifyAccountRisk should not retry');
     }
+    while (accountQueue.length) {
+      // limit
+      if (checkedAccounts.size >= accountLimit) {
+        return {
+          isRisky: false,
+          reason: 'MAX_ACCOUNT_SIZE_LIMIT',
+          data: {
+            accountCount: checkedAccounts.size,
+            txCount: checkedTx.size,
+          },
+        };
+      }
 
-    const address = accountQueue.pop();
-    // Avoid circular query
-    if (checkedAccounts.has(address)) continue;
+      const address = accountQueue.pop();
 
-    const trustedConfig = await resolver.filter?.getTrustedAccountConfig(address);
-    // Skip trusted accounts that do not have tolerance configured
-    if (trustedConfig && !trustedConfig.tolerance) {
-      checkedAccounts.set(address, true);
-      continue;
-    }
+      // Avoid circular query
+      if (checkedAccounts.has(address)) continue;
 
-    let transactions = [];
-    try {
-      transactions = await resolver._getAllResults(
-        'transactions',
-        (paging) => resolver.listTransactions({ paging, accountFilter: { accounts: [address] } }, ctx),
-        txLimit
-      );
-    } catch (e) {
-      // skip if tx limit exceeded
-      if (e.code === 'EXCEED_LIMIT') {
+      const trustedConfig = await resolver.filter?.getTrustedAccountConfig(address);
+      // Skip trusted accounts that do not have tolerance configured
+      if (trustedConfig && !trustedConfig.tolerance) {
         checkedAccounts.set(address, true);
         continue;
       }
-      throw e;
-    }
 
-    const accountState = await resolver.getAccountState({ address, traceMigration: false, expandContext: false }, ctx);
-    if (!accountState) {
-      throw new CustomError('INVALID_REQUEST', `Invalid address ${address}`);
-    }
-    const balance = accountState.tokens.find((item) => isSameDid(item.address, tokenAddress))?.value || 0;
+      const balance = await getBalance(address, tokenAddress, { resolver, txn });
 
-    let transferIn = getInitialBalance(address, resolver.config);
-    let transferOut = ZERO;
-
-    // Parse txs to get transfer amounts
-    for (const tx of transactions) {
-      // cache tx
-      if (!checkedTx.has(tx.hash)) {
-        await fixMigrateReceipts(tx, resolver, ctx);
-        checkedTx.set(tx.hash, getTransferList(tx, tokenAddress));
+      let transactions = [];
+      try {
+        transactions = await resolver._getAllResults(
+          'transactions',
+          (paging) => resolver.listTransactions({ paging, accountFilter: { accounts: [address] } }, ctx),
+          txLimit
+        );
+      } catch (e) {
+        // skip if tx limit exceeded
+        if (e.code === 'EXCEED_LIMIT') {
+          checkedAccounts.set(address, true);
+          continue;
+        }
+        throw e;
       }
-      const { transferInList, transferOutList } = checkedTx.get(tx.hash);
-
-      // Calculate the total amount of transfer for this address
-      transferIn = transferIn.add(
-        transferInList
-          .filter((item) => isSameDid(item.address, address))
-          .map((item) => item.value)
-          .reduce((prev, cur) => prev.add(cur), ZERO)
-      );
 
-      transferOut = transferOut.add(
-        transferOutList
-          .filter((item) => isSameDid(item.address, address))
-          .map((item) => item.value)
-          .reduce((prev, cur) => prev.add(cur), ZERO)
-      );
+      let transferIn = getInitialBalance(address, resolver.config);
+      let transferOut = ZERO;
 
-      // push transferIn accounts to queue for next time check
-      if (transferInList.some((item) => isSameDid(item.address, address))) {
-        const accountsToQueue = transferOutList
-          .filter((item) => {
-            if (accountQueue.includes(item.address)) return false;
-            // Skip vault accounts
-            if (vaultAccounts.includes(item.address)) return false;
-            // skip gas、fee
-            if (['gas', 'fee'].includes(item.action)) return false;
-            // Skip not token holders
-            if (schemas.tokenHolder.validate(item.address).error) return false;
+      // Parse txs to get transfer amounts
+      for (const tx of transactions) {
+        // cache tx
+        if (!checkedTx.has(tx.hash)) {
+          await fixMigrateReceipts(tx, resolver, ctx);
+          checkedTx.set(tx.hash, getTransferList(tx, tokenAddress));
+        }
+        const { transferInList, transferOutList } = checkedTx.get(tx.hash);
+
+        // Calculate the total amount of transfer for this address
+        transferIn = transferIn.add(
+          transferInList
+            .filter((item) => isSameDid(item.address, address))
+            .map((item) => item.value)
+            .reduce((prev, cur) => prev.add(cur), ZERO)
+        );
 
-            return true;
-          })
-          .map((item) => item.address);
+        transferOut = transferOut.add(
+          transferOutList
+            .filter((item) => isSameDid(item.address, address))
+            .map((item) => item.value)
+            .reduce((prev, cur) => prev.add(cur), ZERO)
+        );
 
-        accountQueue.push(...uniq(accountsToQueue));
+        // push transferIn accounts to queue for next time check
+        if (transferInList.some((item) => isSameDid(item.address, address))) {
+          const accountsToQueue = transferOutList
+            .filter((item) => {
+              if (accountQueue.includes(item.address)) return false;
+              // Skip vault accounts
+              if (vaultAccounts.includes(item.address)) return false;
+              // skip gas、fee
+              if (['gas', 'fee'].includes(item.action)) return false;
+              // Skip not token holders
+              if (schemas.tokenHolder.validate(item.address).error) return false;
+
+              return true;
+            })
+            .map((item) => item.address);
+
+          accountQueue.push(...uniq(accountsToQueue));
+        }
       }
-    }
 
-    checkedAccounts.set(address, true);
-
-    // Check if the balance not matches the transfer records
-    if (
-      transferIn
-        .sub(transferOut.add(new BN(balance)))
-        .add(fromTokenToUnit(trustedConfig?.tolerance || 0))
-        .abs()
-        .gt(toleranceUnit)
-    ) {
-      debug('Account balance does not match transfer records', {
-        address,
-        transferIn: transferIn.toString(),
-        transferOut: transferOut.toString(),
-        balance,
-        sourceAccount: accountAddress,
-      });
-      return {
-        isRisky: true,
-        reason: 'INVALID_BALANCE',
-        data: {
+      checkedAccounts.set(address, true);
+
+      // Check if the balance not matches the transfer records
+      if (
+        transferIn
+          .sub(transferOut.add(new BN(balance)))
+          .add(fromTokenToUnit(trustedConfig?.tolerance || 0))
+          .abs()
+          .gt(toleranceUnit)
+      ) {
+        debug('Account balance does not match transfer records', {
           address,
-          balance,
           transferIn: transferIn.toString(),
           transferOut: transferOut.toString(),
-          accountCount: checkedAccounts.size,
-          txCount: checkedTx.size,
-        },
-      };
+          balance,
+          sourceAccount: accountAddress,
+        });
+        return {
+          isRisky: true,
+          reason: 'INVALID_BALANCE',
+          data: {
+            address,
+            balance,
+            transferIn: transferIn.toString(),
+            transferOut: transferOut.toString(),
+            accountCount: checkedAccounts.size,
+            txCount: checkedTx.size,
+          },
+        };
+      }
     }
-  }
+  };
 
-  return {
-    isRisky: false,
-    data: {
-      accountCount: checkedAccounts.size,
-      txCount: checkedTx.size,
+  const result = await resolver.runAsLambda(
+    () => {
+      executeCount++;
+      return execute();
     },
-  };
+    { retryLimit: 0 }
+  );
+
+  return (
+    result || {
+      isRisky: false,
+      data: {
+        accountCount: checkedAccounts.size,
+        txCount: checkedTx.size,
+      },
+    }
+  );
 };
 
 const listTokenFlows = async (

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.18.159",
+  "version": "1.18.160",
   "description": "GraphQL resolver built upon ocap statedb and GQL layer",
   "main": "lib/index.js",
   "files": [
@@ -22,18 +22,18 @@
     "jest": "^29.7.0"
   },
   "dependencies": {
-    "@arcblock/did": "1.18.159",
-    "@arcblock/did-util": "1.18.159",
-    "@arcblock/validator": "1.18.159",
-    "@ocap/config": "1.18.159",
-    "@ocap/indexdb": "1.18.159",
-    "@ocap/mcrypto": "1.18.159",
-    "@ocap/message": "1.18.159",
-    "@ocap/state": "1.18.159",
-    "@ocap/tx-protocols": "1.18.159",
-    "@ocap/util": "1.18.159",
+    "@arcblock/did": "1.18.160",
+    "@arcblock/did-util": "1.18.160",
+    "@arcblock/validator": "1.18.160",
+    "@ocap/config": "1.18.160",
+    "@ocap/indexdb": "1.18.160",
+    "@ocap/mcrypto": "1.18.160",
+    "@ocap/message": "1.18.160",
+    "@ocap/state": "1.18.160",
+    "@ocap/tx-protocols": "1.18.160",
+    "@ocap/util": "1.18.160",
     "debug": "^4.3.6",
     "lodash": "^4.17.21"
   },
-  "gitHead": "a3afce50d8c10223be711b86417b75fc59672e12"
+  "gitHead": "fe8f69251a9aa924e64895ac83307b2852e90def"
 }