@ocap/resolver 1.18.146 → 1.18.148

package/lib/hooks.js

@@ -285,11 +285,21 @@ const onClaimStake = async (tx, ctx, indexdb) => {
   }
 };
 
-const onCreateTx = async (tx, ctx, indexdb) => {
+const onAccountMigrate = async (tx, resolver) => {
+  try {
+    await resolver.buildMigrationChain();
+  } catch (e) {
+    console.error('build migration chain error', e);
+  }
+};
+
+const onCreateTx = async (tx, ctx, resolver) => {
   if (tx.code !== 'OK') {
     return;
   }
 
+  const { indexdb } = resolver;
+
   switch (tx.tx.itxJson.type_url) {
     case 'fg:t:stake':
       return onStake(tx, ctx, indexdb);
@@ -306,6 +316,8 @@ const onCreateTx = async (tx, ctx, indexdb) => {
     case 'fg:t:withdraw_token_v2':
       // totalWithdrawAmount does not include txFee
       return updateRollupStats(ctx.rollupState.address, tx.tx.itxJson.token.value, 'totalWithdrawAmount', indexdb);
+    case 'fg:t:account_migrate':
+      return onAccountMigrate(tx, resolver);
     default:
   }
 };

package/lib/index.js

@@ -47,6 +47,7 @@ const debug = require('debug')(require('../package.json').name);
 const hooks = require('./hooks');
 const tokenFlow = require('./token-flow');
 const { getInstance: getTokenCacheInstance } = require('./token-cache');
+const { MigrationChainManager } = require('./migration-chain');
 
 const noop = (x) => x;
 const CHAIN_ADDR = md5('OCAP_CHAIN_ADDR');
@@ -189,6 +190,8 @@ module.exports = class OCAPResolver {
       }
     }
 
+    this.buildMigrationChain();
+
     this.executor = createExecutor({
       filter,
       runAsLambda: typeof statedb.runAsLambda === 'function' ? statedb.runAsLambda.bind(statedb) : null,
@@ -819,7 +822,7 @@ module.exports = class OCAPResolver {
         const tx = await createIndexedTransaction(x, ctx, this.indexdb);
         await this.indexdb.tx.insert(tx);
         if (typeof hooks.onCreateTx === 'function') {
-          await hooks.onCreateTx(tx, ctx, this.indexdb);
+          await hooks.onCreateTx(tx, ctx, this);
         }
       } catch (error) {
         console.error('create tx index failed', { account: x, error });
@@ -959,15 +962,15 @@ module.exports = class OCAPResolver {
     }
 
     if (!tx.receipts) {
-      if (get(tx, 'tx.itxJson.type_url') === 'fg:t:revoke_withdraw') {
-        const withdrawHash = get(tx, 'tx.itxJson.withdraw_tx_hash');
-        // Avoid infinite loop by invalid data
-        if (withdrawHash && withdrawHash !== tx.hash) {
-          const withdrawTx = await this.getTx({ hash: withdrawHash }, ctx);
-          tx.receipts = getTxReceipts(tx, { config: this.config, withdrawTx });
-        }
-      } else {
-        tx.receipts = getTxReceipts(tx, { config: this.config });
+      tx.receipts = getTxReceipts(tx, { config: this.config });
+    }
+
+    if (get(tx, 'tx.itxJson.type_url') === 'fg:t:revoke_withdraw') {
+      const withdrawHash = get(tx, 'tx.itxJson.withdraw_tx_hash');
+      // Avoid infinite loop by invalid data
+      if (withdrawHash && withdrawHash !== tx.hash) {
+        const withdrawTx = await this.getTx({ hash: withdrawHash }, ctx);
+        tx.receipts = getTxReceipts(tx, { config: this.config, withdrawTx });
       }
     }
 
@@ -1137,6 +1140,19 @@ module.exports = class OCAPResolver {
 
     return state;
   }
+
+  async buildMigrationChain() {
+    const migrationTxs = await this._getAllResults('transactions', (paging) =>
+      this.listTransactions({
+        paging,
+        typeFilter: { types: ['account_migrate'] },
+        validityFilter: { validity: ['VALID'] },
+      })
+    );
+    const migrationChain = new MigrationChainManager();
+    migrationChain.buildChains(migrationTxs);
+    this.migrationChain = migrationChain;
+  }
 };
 
 module.exports.formatData = formatData;

package/lib/migration-chain.js

@@ -0,0 +1,137 @@
+/* eslint-disable max-classes-per-file */
+
+class MigrationNode {
+  constructor(address, validFrom, validUntil = null, nextAddress = null) {
+    this.address = address;
+    this.validFrom = validFrom;
+    this.validUntil = validUntil;
+    this.nextAddress = nextAddress;
+  }
+}
+
+class MigrationChainManager {
+  constructor() {
+    // Main storage for migration chains
+    this.chains = new Map();
+    // Index for quick root lookup
+    this.rootAddresses = new Map();
+  }
+
+  validateMigration(migration) {
+    if (!migration?.tx?.from || !migration?.tx?.itxJson?.address || !migration?.time) {
+      throw new Error('Invalid migration format');
+    }
+    if (new Date(migration.time).toString() === 'Invalid Date') {
+      throw new Error('Invalid timestamp');
+    }
+    return true;
+  }
+
+  /**
+   * Build migration chains from a list of migration transactions
+   * @param {Array} migrations - List of migration transactions
+   */
+  buildChains(migrations) {
+    if (!Array.isArray(migrations)) {
+      throw new Error('Migrations must be an array');
+    }
+
+    migrations.forEach((migration) => this.validateMigration(migration));
+
+    // Sort migrations by timestamp
+    const sortedMigrations = [...migrations].sort((a, b) => new Date(a.time) - new Date(b.time));
+
+    for (const migration of sortedMigrations) {
+      const fromAddr = migration.tx.from;
+      const toAddr = migration.tx.itxJson.address;
+      const timestamp = new Date(migration.time);
+
+      this._processMigration(fromAddr, toAddr, timestamp);
+    }
+  }
+
+  /**
+   * Process a single migration and update the chains
+   * @param {string} fromAddr - Source address
+   * @param {string} toAddr - Destination address
+   * @param {Date} timestamp - Migration timestamp
+   * @private
+   */
+  _processMigration(fromAddr, toAddr, timestamp) {
+    // Find or create the root address for this chain
+    const rootAddr = this.rootAddresses.get(fromAddr) || fromAddr;
+
+    // Get or create the chain
+    if (!this.chains.has(rootAddr)) {
+      this.chains.set(rootAddr, []);
+    }
+    const chain = this.chains.get(rootAddr);
+
+    if (chain.length === 0) {
+      // First migration in the chain
+      chain.push(new MigrationNode(fromAddr, new Date(0), timestamp));
+      chain.push(new MigrationNode(toAddr, timestamp));
+    } else {
+      // Update the previous node's valid_until and next_address
+      const lastNode = chain[chain.length - 1];
+      lastNode.validUntil = timestamp;
+      lastNode.nextAddress = toAddr;
+      // Add the new node
+      chain.push(new MigrationNode(toAddr, timestamp));
+    }
+
+    // Update root address mapping for the new address
+    this.rootAddresses.set(toAddr, rootAddr);
+  }
+
+  /**
+   * Find the valid address at a specific timestamp
+   * @param {string} initialAddress - Address to look up
+   * @param {Date} timestamp - Timestamp to check
+   * @returns {string} Valid address at the timestamp
+   */
+  findAddressAtTime(initialAddress, timestamp) {
+    // Get the root address
+    const rootAddr = this.rootAddresses.get(initialAddress) || initialAddress;
+    const chain = this.chains.get(rootAddr);
+
+    if (!chain) {
+      return initialAddress;
+    }
+
+    // Binary search for the correct address
+    let left = 0;
+    let right = chain.length - 1;
+
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const node = chain[mid];
+
+      if (node.validFrom <= timestamp && (!node.validUntil || timestamp < node.validUntil)) {
+        return node.address;
+      }
+      if (timestamp < node.validFrom) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    }
+
+    return chain[chain.length - 1].address;
+  }
+
+  /**
+   * Get the complete migration history for an address
+   * @param {string} address - Address to look up
+   * @returns {Array} List of migration nodes
+   */
+  getMigrationHistory(address) {
+    const rootAddr = this.rootAddresses.get(address) || address;
+    return this.chains.get(rootAddr) || [];
+  }
+}
+
+module.exports = {
+  MigrationNode,
+  MigrationChainManager,
+};

package/lib/token-flow.js

@@ -125,6 +125,21 @@ const getVaultAccounts = (config) => {
   return Object.values(config.vaults).flat();
 };
 
+const fixMigrateReceipts = async ({ accountAddress, tx }, resolver) => {
+  const { migrationChain } = resolver;
+  const address = migrationChain.findAddressAtTime(accountAddress, new Date(tx.time));
+  const migrations = migrationChain.getMigrationHistory(accountAddress);
+
+  // fix receipts address
+  if (address && migrations.length) {
+    tx.receipts.forEach((receipt) => {
+      if (migrations.some((x) => x.address === receipt.address)) {
+        receipt.address = address;
+      }
+    });
+  }
+};
+
 const verifyAccountRisk = async ({ accountAddress, tokenAddress }, resolver, ctx = {}) => {
   // validate request params
   const { error } = paramsSchema.validate({ accountAddress, tokenAddress, resolver });
@@ -159,6 +174,7 @@ const verifyAccountRisk = async ({ accountAddress, tokenAddress }, resolver, ctx
       resolver.listTransactions({ paging, accountFilter: { accounts: [address] } }, ctx)
     );
     const accountState = await resolver.getAccountState({ address, traceMigration: false }, ctx);
+
     if (!accountState) {
       throw new CustomError('INVALID_REQUEST', `Invalid address ${address}`);
     }
@@ -169,6 +185,10 @@ const verifyAccountRisk = async ({ accountAddress, tokenAddress }, resolver, ctx
 
     // Parse txs to get transfer amounts
     for (const tx of transactions) {
+      // fix migrate receipts
+      if (accountState.migratedFrom?.length || accountState.migratedTo?.length) {
+        await fixMigrateReceipts({ accountAddress: address, tx }, resolver, ctx);
+      }
       // cache tx
       if (!checkedTx.has(tx.hash)) {
         checkedTx.set(tx.hash, await getTransferList(tx, tokenAddress));
@@ -291,6 +311,8 @@ const listTokenFlows = async (
       let accountsToQueue = [];
 
       for (const tx of transactions) {
+        // fix migrate receipts
+        await fixMigrateReceipts({ accountAddress: address, tx }, resolver, ctx);
         // cache tx
         if (!checkedTx.has(tx.hash)) {
           checkedTx.set(tx.hash, await getTransferFlow(tx, tokenAddress));
@@ -340,4 +362,5 @@ module.exports = {
   getTransferFlow,
   verifyAccountRisk,
   listTokenFlows,
+  fixMigrateReceipts,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.18.146",
+  "version": "1.18.148",
   "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.146",
-    "@arcblock/did-util": "1.18.146",
-    "@arcblock/validator": "1.18.146",
-    "@ocap/config": "1.18.146",
-    "@ocap/indexdb": "1.18.146",
-    "@ocap/mcrypto": "1.18.146",
-    "@ocap/message": "1.18.146",
-    "@ocap/state": "1.18.146",
-    "@ocap/tx-protocols": "1.18.146",
-    "@ocap/util": "1.18.146",
+    "@arcblock/did": "1.18.148",
+    "@arcblock/did-util": "1.18.148",
+    "@arcblock/validator": "1.18.148",
+    "@ocap/config": "1.18.148",
+    "@ocap/indexdb": "1.18.148",
+    "@ocap/mcrypto": "1.18.148",
+    "@ocap/message": "1.18.148",
+    "@ocap/state": "1.18.148",
+    "@ocap/tx-protocols": "1.18.148",
+    "@ocap/util": "1.18.148",
     "debug": "^4.3.6",
     "lodash": "^4.17.21"
   },
-  "gitHead": "ea7f3d1ad606f277b89c390364f20bf295d9e4f9"
+  "gitHead": "5ba096b17be4f24fb47efce520525c96f8ff9660"
 }