@ocap/resolver 1.18.142 → 1.18.144

package/lib/index.js

@@ -20,6 +20,7 @@ const { BN, toBN, fromTokenToUnit, toAddress } = require('@ocap/util');
 const { DEFAULT_TOKEN_DECIMAL } = require('@ocap/util/lib/constant');
 const { createExecutor } = require('@ocap/tx-protocols');
 const { decodeAnySafe } = require('@ocap/tx-protocols/lib/util');
+
 const {
   createIndexedAccount,
   createIndexedAsset,
@@ -44,6 +45,7 @@ const {
 
 const debug = require('debug')(require('../package.json').name);
 const hooks = require('./hooks');
+const tokenFlow = require('./token-flow');
 const { getInstance: getTokenCacheInstance } = require('./token-cache');
 
 const noop = (x) => x;
@@ -677,6 +679,14 @@ module.exports = class OCAPResolver {
     return this._doPaginatedSearch('listDelegations', args, 'delegations', 'data', ctx);
   }
 
+  async verifyAccountRisk(args, ctx) {
+    return tokenFlow.verifyAccountRisk(args, this, ctx);
+  }
+
+  async listTokenFlows(args, ctx) {
+    return tokenFlow.listTokenFlows(args, this, ctx);
+  }
+
   async search(args) {
     if (!args.keyword) {
       return { results: [] };
@@ -966,6 +976,27 @@ module.exports = class OCAPResolver {
     return attachPaidTxGas(tx);
   }
 
+  async _getAllResults(dataKey, fn) {
+    const results = [];
+    const pageSize = 100;
+
+    const { paging, [dataKey]: firstPage } = await fn({ size: pageSize });
+    if (paging.total < pageSize) {
+      return firstPage;
+    }
+
+    results.push(...firstPage);
+
+    const total = Math.floor(paging.total / pageSize);
+    for (let i = 1; i <= total; i++) {
+      // eslint-disable-next-line no-await-in-loop
+      const { [dataKey]: nextPage } = await fn({ size: pageSize, cursor: i * pageSize });
+      results.push(...nextPage);
+    }
+
+    return results;
+  }
+
   async formatTokenArray(tokens) {
     const uniqTokens = uniqBy(tokens, 'address');
     const tokenStates = await Promise.all(uniqTokens.map((token) => this.tokenCache.get(token.address)));

package/lib/token-flow.js

@@ -0,0 +1,330 @@
+/* eslint-disable no-await-in-loop */
+
+const { BN, fromTokenToUnit } = require('@ocap/util');
+const { schemas, Joi } = require('@arcblock/validator');
+const { CustomError } = require('@ocap/util/lib/error');
+const uniq = require('lodash/uniq');
+const debug = require('debug')(require('../package.json').name);
+
+const ZERO = new BN(0);
+const paramsSchema = Joi.object({
+  accountAddress: schemas.tokenHolder.required(),
+  tokenAddress: Joi.DID().prefix().role('ROLE_TOKEN').required(),
+  resolver: Joi.object().required(),
+});
+
+/**
+ * Parse transfer in/out list from transaction
+ * @param {*} tx
+ * @param {String} tokenAddress
+ * @returns {{
+ *  transferInList: { address: String, value: BN, action: String }[],
+ *  transferOutList: { address: String, value: BN, action: String }[]
+ * }}
+ */
+const getTransferList = (tx, tokenAddress) => {
+  const transferInList = [];
+  const transferOutList = [];
+
+  // Parse receipt to get transfer in/out accounts
+  for (const receipt of tx.receipts || []) {
+    const changes = receipt.changes.filter((item) => item.target === tokenAddress && item.value !== '0');
+
+    for (const change of changes) {
+      const value = new BN(change.value);
+      const item = {
+        address: receipt.address,
+        value: value.abs(),
+        action: change.action,
+      };
+      if (value.lt(ZERO)) {
+        transferOutList.push(item);
+      } else {
+        transferInList.push(item);
+      }
+    }
+  }
+
+  return { transferInList, transferOutList };
+};
+
+/**
+ * Parse transfer flow from transaction
+ * @param {*} tx
+ * @param {String} tokenAddress
+ * @returns {{ from: String, to: String, value: BN, hash: String }[]}
+ */
+const getTransferFlow = (tx, tokenAddress) => {
+  const { transferInList, transferOutList } = getTransferList(tx, tokenAddress);
+  const txTransfers = [];
+
+  // Match transfers between accounts
+  for (const outItem of transferOutList) {
+    if (outItem.archived) continue;
+
+    // Try to match accounts with exactly equal transfer in/out amounts
+    const matchedInItem = transferInList.find((x) => x.value.eq(outItem.value));
+    if (matchedInItem) {
+      txTransfers.push({
+        from: outItem.address,
+        to: matchedInItem.address,
+        value: outItem.value,
+        hash: tx.hash,
+      });
+      matchedInItem.archived = true;
+      outItem.archived = true;
+      continue;
+    }
+
+    for (const inItem of transferInList) {
+      if (inItem.archived) continue;
+      if (outItem.archived) continue;
+
+      if (outItem.value.gt(inItem.value)) {
+        txTransfers.push({
+          from: outItem.address,
+          to: inItem.address,
+          value: inItem.value,
+          hash: tx.hash,
+        });
+        inItem.archived = true;
+        outItem.value = outItem.value.sub(inItem.value);
+        continue;
+      }
+
+      if (outItem.value.lt(inItem.value)) {
+        txTransfers.push({
+          from: outItem.address,
+          to: inItem.address,
+          value: outItem.value,
+          hash: tx.hash,
+        });
+        outItem.archived = true;
+        inItem.value = inItem.value.sub(outItem.value);
+        continue;
+      }
+
+      if (outItem.value.eq(inItem.value)) {
+        txTransfers.push({
+          from: outItem.address,
+          to: inItem.address,
+          value: inItem.value,
+          hash: tx.hash,
+        });
+        inItem.archived = true;
+        outItem.archived = true;
+        continue;
+      }
+    }
+  }
+
+  return txTransfers;
+};
+
+const verifyAccountRisk = async ({ accountAddress, tokenAddress }, resolver, ctx = {}) => {
+  // validate request params
+  const { error } = paramsSchema.validate({ accountAddress, tokenAddress, resolver });
+  if (error) {
+    throw new CustomError('INVALID_PARAMS', error.message);
+  }
+
+  const checkedAccounts = new Map();
+  const checkedTx = new Map();
+  const accountQueue = [accountAddress];
+  const maxAccountSize = 400;
+
+  while (accountQueue.length) {
+    // limit
+    if (checkedAccounts.size >= maxAccountSize) {
+      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 transactions = await resolver._getAllResults('transactions', (paging) =>
+      resolver.listTransactions({ paging, accountFilter: { accounts: [address] } }, ctx)
+    );
+    const accountState = await resolver.getAccountState({ address }, ctx);
+    if (!accountState) {
+      throw new CustomError('INVALID_REQUEST', `Invalid address ${address}`);
+    }
+    const balance = accountState.tokens.find((item) => item.address === tokenAddress)?.value || 0;
+
+    let transferIn = ZERO;
+    let transferOut = ZERO;
+
+    // Parse txs to get transfer amounts
+    for (const tx of transactions) {
+      // cache tx
+      if (!checkedTx.has(tx.hash)) {
+        checkedTx.set(tx.hash, await 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) => item.address === address)
+          .map((item) => item.value)
+          .reduce((prev, cur) => prev.add(cur), ZERO)
+      );
+
+      transferOut = transferOut.add(
+        transferOutList
+          .filter((item) => item.address === address)
+          .map((item) => item.value)
+          .reduce((prev, cur) => prev.add(cur), ZERO)
+      );
+
+      // push transferIn accounts to queue for next time check
+      if (transferInList.some((item) => item.address === address)) {
+        const accountsToQueue = transferOutList
+          .filter((item) => {
+            if (accountQueue.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.eq(transferOut.add(new BN(balance)))) {
+      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: {
+          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 listTokenFlows = async (
+  { accountAddress, tokenAddress, paging = {}, depth = 2, direction = 'OUT' },
+  resolver,
+  ctx = {}
+) => {
+  // validate request params
+  const { error } = paramsSchema.validate({ accountAddress, tokenAddress, resolver });
+  if (error) {
+    throw new CustomError('INVALID_PARAMS', error.message);
+  }
+
+  const tokenState = await resolver.tokenCache.get(tokenAddress);
+  const minAmount = fromTokenToUnit(1, tokenState?.decimal || 18);
+  const maxAccountSize = Math.min(400, paging.size || 400);
+  const maxDepth = Math.min(6, depth);
+
+  const tokenFlows = [];
+  const checkedAccounts = new Map();
+  const checkedTx = new Map();
+
+  let curDepth = 1;
+
+  const depthQueue = {
+    [curDepth]: [accountAddress],
+  };
+
+  while (depthQueue[curDepth]?.length && curDepth <= maxDepth && checkedAccounts.size < maxAccountSize) {
+    for (const address of depthQueue[curDepth]) {
+      // Avoid circular query
+      if (checkedAccounts.has(address)) continue;
+      // Skip not token holders
+      if (schemas.tokenHolder.validate(address).error) continue;
+
+      const transactions = await resolver._getAllResults('transactions', (page) =>
+        resolver.listTransactions(
+          { paging: page, accountFilter: { accounts: [address] }, tokenFilter: { tokens: [tokenAddress] } },
+          ctx
+        )
+      );
+      let accountsToQueue = [];
+
+      for (const tx of transactions) {
+        // cache tx
+        if (!checkedTx.has(tx.hash)) {
+          checkedTx.set(tx.hash, await getTransferFlow(tx, tokenAddress));
+        }
+        const txTransfers = checkedTx.get(tx.hash).filter((item) => {
+          if (direction === 'OUT' && item.from !== address) return false;
+          if (direction === 'IN' && item.to !== address) return false;
+          return true;
+        });
+
+        // push to result
+        tokenFlows.push(...txTransfers.map((item) => ({ ...item, value: item.value.toString() })));
+
+        // push to end of queue
+        accountsToQueue = accountsToQueue.concat(
+          txTransfers
+            .filter((item) => item.value.gte(minAmount))
+            .map((item) => (direction === 'IN' ? item.from : item.to))
+        );
+      }
+
+      // cache account
+      checkedAccounts.set(address, true);
+      // limit
+      if (checkedAccounts.size >= maxAccountSize) {
+        break;
+      }
+
+      // push to queue for next depth
+      if (!depthQueue[curDepth + 1]) {
+        depthQueue[curDepth + 1] = [];
+      }
+      depthQueue[curDepth + 1].push(...uniq(accountsToQueue));
+    }
+
+    curDepth++;
+  }
+
+  return tokenFlows;
+};
+
+module.exports = {
+  getTransferList,
+  getTransferFlow,
+  verifyAccountRisk,
+  listTokenFlows,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.18.142",
+  "version": "1.18.144",
   "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.142",
-    "@arcblock/did-util": "1.18.142",
-    "@arcblock/validator": "1.18.142",
-    "@ocap/config": "1.18.142",
-    "@ocap/indexdb": "1.18.142",
-    "@ocap/mcrypto": "1.18.142",
-    "@ocap/message": "1.18.142",
-    "@ocap/state": "1.18.142",
-    "@ocap/tx-protocols": "1.18.142",
-    "@ocap/util": "1.18.142",
+    "@arcblock/did": "1.18.144",
+    "@arcblock/did-util": "1.18.144",
+    "@arcblock/validator": "1.18.144",
+    "@ocap/config": "1.18.144",
+    "@ocap/indexdb": "1.18.144",
+    "@ocap/mcrypto": "1.18.144",
+    "@ocap/message": "1.18.144",
+    "@ocap/state": "1.18.144",
+    "@ocap/tx-protocols": "1.18.144",
+    "@ocap/util": "1.18.144",
     "debug": "^4.3.6",
     "lodash": "^4.17.21"
   },
-  "gitHead": "fa18a9eddbb0cad69398c69c7930018593f4fb31"
+  "gitHead": "541c65e8f06b20c6182d335a7f2ed6e09c1e289d"
 }