@ocap/resolver 1.28.8 → 1.29.0

package/lib/migration-chain.js

@@ -1,144 +0,0 @@
-const { isEthereumDid } = require('@arcblock/did');
-
-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.getRootAddress(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(this.formatAddress(toAddr), rootAddr);
-  }
-
-  /**
-   * Find the valid address at a specific timestamp
-   * @param {string} address - Address to look up
-   * @param {Date} timestamp - Timestamp to check
-   * @returns {string} Valid address at the timestamp
-   */
-  findAddressAtTime(address, timestamp) {
-    const chains = this.getMigrationHistory(address);
-
-    if (!chains?.length) {
-      return address;
-    }
-
-    // Binary search for the correct address
-    let left = 0;
-    let right = chains.length - 1;
-
-    while (left <= right) {
-      const mid = Math.floor((left + right) / 2);
-      const node = chains[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 chains[chains.length - 1].address;
-  }
-
-  formatAddress(address) {
-    return isEthereumDid(address) ? address.toLowerCase() : address;
-  }
-
-  getRootAddress(address) {
-    const formattedAddress = this.formatAddress(address);
-    return this.rootAddresses.get(formattedAddress) || formattedAddress;
-  }
-
-  /**
-   * 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.getRootAddress(address);
-    return this.chains.get(rootAddr) || [];
-  }
-}
-
-module.exports = {
-  MigrationNode,
-  MigrationChainManager,
-};

package/lib/token-cache.js

@@ -1,40 +0,0 @@
-/**
- * 缓存 token 到内存
- */
-class Cache {
-  constructor(dbAdapter) {
-    this.dbAdapter = dbAdapter;
-    this.cache = new Map();
-  }
-
-  async get(address) {
-    if (this.cache.has(address)) {
-      return this.cache.get(address);
-    }
-
-    const token = await this.dbAdapter.get(address);
-    if (token) {
-      this.cache.set(address, token);
-    }
-
-    return token;
-  }
-
-  set(address, token) {
-    this.cache.set(address, token);
-    return token;
-  }
-}
-
-let cache = null;
-
-module.exports = {
-  getInstance: (dbAdapter) => {
-    if (cache !== null) {
-      return cache;
-    }
-
-    cache = new Cache(dbAdapter);
-    return cache;
-  },
-};

package/lib/token-distribution.js

@@ -1,358 +0,0 @@
-const { BN, isSameDid, fromTokenToUnit } = require('@ocap/util');
-const { toTypeInfo } = require('@arcblock/did');
-const {
-  types: { RoleType },
-} = require('@ocap/mcrypto');
-const { createIndexedTokenDistribution } = require('@ocap/indexdb/lib/util');
-const { eachReceipts } = require('@ocap/state/lib/states/tx');
-const { isGasStakeAddress } = require('@ocap/tx-protocols/lib/util');
-const omit = require('lodash/omit');
-
-const ZERO = new BN(0);
-
-class TokenDistributionManager {
-  constructor(resolver) {
-    this.resolver = resolver;
-    this.indexdb = resolver.indexdb;
-    this.isProcessing = false;
-  }
-
-  formatDistribution(distribution) {
-    const { tokenAddress, account, gas, fee, slashedVault, stake, revokedStake, gasStake, other, txTime } =
-      distribution;
-    return {
-      tokenAddress,
-      account: new BN(account || 0),
-      gas: new BN(gas || 0),
-      fee: new BN(fee || 0),
-      slashedVault: new BN(slashedVault || 0),
-      stake: new BN(stake || 0),
-      revokedStake: new BN(revokedStake || 0),
-      gasStake: new BN(gasStake || 0),
-      other: new BN(other || 0),
-      txTime: txTime || new Date(0).toISOString(),
-    };
-  }
-
-  async getDistribution(tokenAddress) {
-    const data = await this.indexdb.tokenDistribution.get(tokenAddress);
-    return data && createIndexedTokenDistribution(data);
-  }
-
-  async saveDistribution(distribution, isEnsureLatest = true) {
-    const data = createIndexedTokenDistribution(distribution);
-    const indexdbDistribution = await this.getDistribution(data.tokenAddress);
-
-    if (!indexdbDistribution) {
-      await this.indexdb.tokenDistribution.insert(data);
-    } else {
-      // ensure txTime is latest
-      if (isEnsureLatest) {
-        const latestTime = Math.max(new Date(indexdbDistribution.txTime).getTime(), new Date(data.txTime).getTime());
-        data.txTime = new Date(latestTime).toISOString();
-      }
-      await this.indexdb.tokenDistribution.update(data.tokenAddress, data);
-    }
-
-    return data;
-  }
-
-  /**
-   * Calculate token distribution based on all transaction data.
-   * This method is usually used to update historical token distribution data
-   *
-   * @param {string} tokenAddress Token address
-   * @param {boolean} force If force is false, only calculate distributions for new transactions after txTime in indexdb. default is false
-   * @returns {Promise<Object>}
-   */
-  async updateByToken(tokenAddress, force) {
-    const { logger, config } = this.resolver;
-
-    if (this.isProcessing) {
-      logger?.logger('Token distribution is already in progress', { tokenAddress, force });
-      return;
-    }
-
-    const distribution = force
-      ? this.formatDistribution({ tokenAddress })
-      : this.formatDistribution((await this.getDistribution(tokenAddress)) || { tokenAddress });
-    const isDefaultToken = tokenAddress === config.token.address;
-
-    logger?.info(`Update distribution by token (${tokenAddress})`, {
-      distribution: createIndexedTokenDistribution(distribution),
-    });
-
-    this.isProcessing = true;
-
-    try {
-      if (force && isDefaultToken) {
-        this.handleModerator(distribution);
-      }
-
-      const { next } = await this.resolver.listTransactionsChunks({
-        timeFilter: { startDateTime: distribution.txTime },
-        // Default token is used for gas payment and may appear in any transaction, so we cannot filter by tokenFilter
-        tokenFilter: isDefaultToken ? {} : { tokenFilter: { tokens: [tokenAddress] } },
-      });
-      let nextData = await next();
-
-      // Process transactions in chunks and update indexdb
-      while (nextData.length) {
-        logger?.info('Updating token distribution in chunks', {
-          chunkSize: nextData.length,
-          startTime: nextData[0].time,
-          startHash: nextData[0].hash,
-          endTime: nextData[nextData.length - 1].time,
-        });
-
-        const handlePromises = nextData.map((tx) => this.handleTx(tx, distribution));
-        await Promise.all(handlePromises);
-
-        // update indexdb
-        await this.saveDistribution(distribution, false);
-        nextData = await next();
-      }
-
-      // We cannot distinguish between revokedStake and stake from tx receipts here,
-      // so we need to read all stake transactions and recalculate token distribution based on their revokeTokens and tokens
-      await this.splitStake(distribution);
-      await this.saveDistribution(distribution, false);
-
-      const result = createIndexedTokenDistribution(distribution);
-
-      logger.info(`Token distribution update completed (${tokenAddress})`, { distribution: result });
-      return result;
-    } catch (e) {
-      logger?.error('Token distribution update failed', { error: e });
-      return null;
-    } finally {
-      this.isProcessing = false;
-    }
-  }
-
-  /**
-   * Split out revokedStake / gasStake from stake
-   *
-   * @param {Object} distribution
-   * @returns {Promise<Object>}
-   */
-  async splitStake(distribution) {
-    const { logger } = this.resolver;
-    const { tokenAddress } = distribution;
-
-    const { next } = await this.resolver.listStakeChunks();
-
-    let nextData = await next();
-
-    // Process transactions in chunks and update indexdb
-    while (nextData.length) {
-      logger?.info('Updating stake distribution in chunks', {
-        chunkSize: nextData.length,
-        startTime: nextData[0].renaissanceTime,
-        startAddress: nextData[0].address,
-        endTime: nextData[nextData.length - 1].renaissanceTime,
-      });
-
-      nextData.forEach((stakeState) => {
-        const isGasStake = this.isGasStake(stakeState);
-        const token = stakeState.tokens.find((x) => x.address === tokenAddress);
-        const revokedToken = stakeState.revokedTokens.find((x) => x.address === tokenAddress);
-        const revokedBalance = new BN(revokedToken?.balance || 0);
-        const balance = new BN(token?.balance || 0);
-
-        // stake -->> revokedStake
-        distribution.revokedStake = distribution.revokedStake.add(revokedBalance);
-        distribution.stake = distribution.stake.sub(revokedBalance);
-
-        // stake -->> gasStake
-        if (isGasStake) {
-          distribution.gasStake = distribution.gasStake.add(balance);
-          distribution.stake = distribution.stake.sub(balance);
-        }
-      });
-
-      // continue
-      nextData = await next();
-    }
-
-    return distribution;
-  }
-
-  /**
-   * Update token distribution by a single transaction.
-   * This method is usually used when a tx is completed.
-   *
-   * @param {Object} tx The transaction object
-   * @param {Object} context The transaction context
-   * @returns {Promise<Object>} The updated token distributions
-   */
-  async updateByTx(tx, context) {
-    const { logger } = this.resolver;
-    const ctx = omit(context, 'txn');
-
-    if (this.isProcessing) {
-      logger?.logger('Token distribution is already in progress', { tx });
-      return;
-    }
-
-    const formattedTx = await this.resolver.formatTx(tx);
-    const tokens = formattedTx.tokenSymbols.map(({ address }) => address);
-
-    // Parse all tokens in this transaction
-    const results = await Promise.all(
-      tokens.map(async (tokenAddress) => {
-        const distribution = this.formatDistribution((await this.getDistribution(tokenAddress)) || { tokenAddress });
-        await this.handleTx(tx, distribution, { context: ctx, isHandleStake: true });
-        const data = await this.saveDistribution(distribution);
-        return data;
-      })
-    );
-
-    return results;
-  }
-
-  /**
-   * Parse token distribution for a single transaction
-   * @param {Object} tx
-   * @param {String} distribution
-   * @param {Object} param
-   * @param {Object} param.context
-   * @param {Boolean} param.isHandleStake Whether to handle revoked / gas stake tokens
-   * @returns {Promise<Object>}  token distribution
-   */
-  async handleTx(tx, distribution, { context, isHandleStake = false } = {}) {
-    if (isHandleStake && !context) {
-      throw new Error('FORBIDDEN', 'context is missing, handle revoke stake is not supported without context');
-    }
-
-    const type = tx.tx?.itxJson?._type;
-    const receipts = tx.receipts || [];
-    const { tokenAddress } = distribution;
-
-    // Iterate through each transaction receipt and distribute tokens based on account type
-    const handlePromises = eachReceipts(receipts, async (address, change) => {
-      if (!isSameDid(change.target, tokenAddress)) return;
-      // In migrate tx, tokens are frozen for the old account and minted for the new account
-      // It behaves like minting new tokens in receipts
-      // So we should skip here
-      if (change.action === 'migrate') return;
-
-      const roleType = toTypeInfo(address).role;
-      const value = new BN(change.value);
-
-      // Stake
-      if (roleType === RoleType.ROLE_STAKE) {
-        if (isHandleStake) {
-          const stakeState = await this.getStakeState(address, context);
-          const isGasStake = this.isGasStake(stakeState);
-          // stake revokedTokens -->> account tokens
-          if (type === 'ClaimStakeTx') {
-            distribution.revokedStake = distribution.revokedStake.add(value);
-            return;
-          }
-          // stake tokens + stake revokedTokens  -->>  account tokens
-          if (type === 'SlashStakeTx') {
-            const beforeState = context.stateSnapshot[address];
-            const afterState = context.stakeState;
-            if (!beforeState || !afterState) {
-              throw new Error('INVALID_TOKEN_DISTRIBUTION', 'stake state is missing on slash stake tx');
-            }
-            const revokeTokenDiff = new BN(beforeState.revokedTokens[tokenAddress]).sub(
-              new BN(afterState.revokedTokens[tokenAddress])
-            );
-            const tokenDiff = new BN(beforeState.tokens[tokenAddress]).sub(new BN(afterState.tokens[tokenAddress]));
-
-            distribution.revokedStake = distribution.revokedStake.sub(revokeTokenDiff);
-            if (isGasStake) {
-              distribution.gasStake = distribution.gasStake.sub(tokenDiff);
-            } else {
-              distribution.stake = distribution.stake.sub(tokenDiff);
-            }
-            return;
-          }
-          // gasStake tokens -->> account tokens
-          if (isGasStake) {
-            distribution.gasStake = distribution.gasStake.add(value);
-            return;
-          }
-        }
-        distribution.stake = distribution.stake.add(value);
-      }
-      // Gas
-      else if (change.action === 'gas' && value.gt(ZERO)) {
-        distribution.gas = distribution.gas.add(value);
-      }
-      // Fee
-      else if (change.action === 'fee' && value.gt(ZERO)) {
-        distribution.fee = distribution.fee.add(value);
-      }
-      // SlashVault
-      else if (
-        type === 'SlashStakeTx' &&
-        value.gt(ZERO) &&
-        isSameDid(address, this.resolver.config.vaults.slashedStake)
-      ) {
-        distribution.slashedVault = distribution.slashedVault.add(value);
-      }
-      // Others: Account
-      else {
-        distribution.account = distribution.account.add(value);
-      }
-    });
-
-    await Promise.all(handlePromises);
-
-    if (isHandleStake && type === 'RevokeStakeTx') {
-      // RevokedStake has no receipts
-      // stake tokens -->> stake revokedTokens
-      const { address } = tx.tx.itxJson;
-      const stakeState = await this.getStakeState(address, context);
-      const isGasStake = this.isGasStake(stakeState);
-
-      tx.tx.itxJson.outputs.forEach((x) => {
-        x.tokens
-          .filter((change) => isSameDid(change.address, tokenAddress))
-          .forEach((change) => {
-            const value = new BN(change.value);
-            distribution.revokedStake = distribution.revokedStake.add(value);
-            if (isGasStake) {
-              distribution.gasStake = distribution.gasStake.sub(value);
-            } else {
-              distribution.stake = distribution.stake.sub(value);
-            }
-          });
-      });
-    }
-
-    distribution.txTime = tx.time;
-
-    return distribution;
-  }
-
-  handleModerator(distribution) {
-    const { config } = this.resolver;
-
-    if (distribution.tokenAddress !== config.token.address) {
-      return distribution;
-    }
-
-    const value = config.accounts
-      .filter((account) => account.balance > 0)
-      .map((account) => new BN(account.balance))
-      .reduce((cur, balance) => cur.add(balance), ZERO);
-
-    distribution.account = distribution.account.add(fromTokenToUnit(value.toString()));
-    return distribution;
-  }
-
-  async getStakeState(address, ctx) {
-    const stakeState = await this.resolver.statedb.stake.get(address, ctx);
-    return stakeState;
-  }
-
-  isGasStake(stakeState) {
-    return isGasStakeAddress(stakeState.sender, stakeState.address) && stakeState.message === 'stake-for-gas';
-  }
-}
-
-module.exports = { TokenDistributionManager };