@ocap/resolver 1.28.8 → 1.29.0

package/lib/index.js

@@ -1,1486 +0,0 @@
-const get = require('lodash/get');
-const set = require('lodash/set');
-const uniq = require('lodash/uniq');
-const pick = require('lodash/pick');
-const isEmpty = require('lodash/isEmpty');
-const isEqual = require('lodash/isEqual');
-const uniqBy = require('lodash/unionBy');
-const omit = require('lodash/omit');
-const Config = require('@ocap/config');
-const states = require('@ocap/state');
-const { patterns } = require('@arcblock/validator');
-const { md5 } = require('@ocap/util/lib/md5');
-const { CustomError } = require('@ocap/util/lib/error');
-const { types } = require('@ocap/mcrypto');
-const { fromTypeUrl } = require('@ocap/message');
-const { toStakeAddress } = require('@arcblock/did-util');
-const { fromPublicKey, toTypeInfo, isValid: isValidDid } = require('@arcblock/did');
-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 { Joi } = require('@arcblock/validator');
-const Queue = require('queue');
-
-const {
-  createIndexedAccount,
-  createIndexedAsset,
-  createIndexedFactory,
-  createIndexedDelegation,
-  createIndexedToken,
-  createIndexedTransaction,
-  createIndexedStake,
-  createIndexedRollup,
-  createIndexedRollupBlock,
-  isDefaultTokenChanged,
-  createIndexedTokenFactory,
-} = require('@ocap/indexdb/lib/util');
-const { formatTxType } = require('@ocap/util');
-
-const {
-  getTxReceipts,
-  mergeTxReceipts,
-  getTxSender,
-  getTxReceiver,
-  attachPaidTxGas,
-} = require('@ocap/state/lib/states/tx');
-
-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 { TokenDistributionManager } = require('./token-distribution');
-
-const noop = (x) => x;
-const CHAIN_ADDR = md5('OCAP_CHAIN_ADDR');
-
-const maxGasOps = {
-  'fg:t:account_migrate': { create: 2, update: 1 },
-  'fg:t:delegate': { create: 3, update: 1 },
-  'fg:t:revoke_delegate': { create: 1, update: 2 },
-
-  'fg:t:create_asset': { create: 2, update: 2 },
-  'fg:t:update_asset': { create: 1, update: 2 },
-  'fg:t:consume_asset': { create: 1, update: 2 },
-
-  'fg:t:create_factory': { create: 2, update: 2 },
-  'fg:t:acquire_asset_v2': { create: 2, update: 12 },
-  'fg:t:acquire_asset_v3': { create: 3, update: 12 },
-  'fg:t:mint_asset': { create: 3, update: 10 },
-
-  'fg:t:create_token': { create: 2, update: 3 },
-  'fg:t:deposit_token_v2': { create: 3, update: 3 },
-  'fg:t:withdraw_token_v2': { create: 2, update: 3 },
-
-  'fg:t:stake': { create: 2, update: 18 },
-  'fg:t:revoke_stake': { create: 1, update: 2 },
-  'fg:t:claim_stake': { create: 2, update: 18 },
-  'fg:t:slash_stake': { update: 18 },
-  'fg:t:return_stake': { update: 8 },
-
-  'fg:t:transfer': { create: 2, update: 20 },
-  'fg:t:transfer_v2': { create: 2, update: 20 },
-  'fg:t:transfer_v3': { create: 9, update: 16 },
-  'fg:t:exchange_v2': { create: 1, update: 18 },
-
-  'fg:t:create_token_factory': { create: 2, update: 3 },
-  'fg:t:update_token_factory': { create: 0, update: 3 },
-  'fg:t:mint_token': { create: 2, update: 13 },
-  'fg:t:burn_token': { create: 2, update: 13 },
-
-  'fg:t:create_rollup': { create: 2, update: 2 },
-  'fg:t:update_rollup': { create: 1, update: 2 },
-  'fg:t:pause_rollup': { create: 1, update: 2 },
-  'fg:t:close_rollup': { create: 1, update: 26 },
-  'fg:t:resume_rollup': { create: 1, update: 2 },
-  'fg:t:join_rollup': { create: 2, update: 3 },
-  'fg:t:leave_rollup': { create: 2, update: 3 },
-  'fg:t:migrate_rollup': { create: 1, update: 2 },
-  'fg:t:create_rollup_block': { create: 2, update: 38 },
-  'fg:t:claim_block_reward': { create: 2, update: 38 },
-};
-
-const txRequestConfig = {
-  maxRequest: Number(process.env.TX_MAX_REQUEST) || 200,
-  concurrent: Number(process.env.TX_CONCURRENCY) || 10,
-  timeout: Number(process.env.TX_TIMEOUT) || 1000 * 30,
-};
-
-const formatData = (data) => {
-  if (!data) {
-    return data;
-  }
-  if (data.type_url) {
-    return data;
-  }
-
-  // For legacy compatibility
-  // If we can successfully parse the value, it must be valid JSON
-  if (data.typeUrl && ['json', 'vc'].includes(data.typeUrl)) {
-    try {
-      JSON.parse(data.value);
-      data.type_url = data.typeUrl;
-      return data;
-    } catch (_err) {
-      // Some legacy data contains escaped back slashes
-      try {
-        JSON.parse(data.value.replace(/\\"/g, '"'));
-        data.type_url = data.typeUrl;
-        data.value = data.value.replace(/\\"/g, '"');
-        return data;
-      } catch (_e) {
-        // do nothing
-      }
-    }
-  }
-
-  const decoded = data.typeUrl ? decodeAnySafe(data) : data;
-  if (['json', 'vc', 'AssetFactory'].includes(decoded.type)) {
-    return { typeUrl: decoded.type, type_url: decoded.type, value: JSON.stringify(decoded.value) };
-  }
-
-  return { typeUrl: decoded.type, type_url: decoded.type, value: decoded.value };
-};
-
-const formatDelegationOps = (state) => {
-  if (state?.ops && typeof state.ops === 'object') {
-    state.ops = Object.keys(state.ops).map((x) => ({ key: x, value: state.ops[x] }));
-  }
-  return state;
-};
-
-const extractTokenMeta = (address, tokenStates) => {
-  const tokenState = tokenStates.filter(Boolean).find((t) => t.address === address);
-  if (!tokenState) {
-    return {};
-  }
-
-  return {
-    address,
-    decimal: typeof tokenState.decimal === 'undefined' ? DEFAULT_TOKEN_DECIMAL : tokenState.decimal,
-    unit: tokenState.unit,
-    symbol: tokenState.symbol,
-    foreignToken: tokenState.foreignToken,
-  };
-};
-
-module.exports = class OCAPResolver {
-  /**
-   * Creates an instance of OCAPResolver.
-   * @param {object} params Parameters to bootstrap the resolver
-   * @param {object} params.statedb @ocap/statedb adapter
-   * @param {object} params.indexdb @ocap/indexdb adapter
-   * @param {object} params.config @ocap/config object
-   * @param {object} params.filter bloom filter to do anti-replay check
-   * @param {bool} params.validateTokenConfig should we validate token supply and token-holder balance, should be disabled when starting an existing chain
-   */
-  constructor({ statedb, indexdb, config, filter, validateTokenConfig = true, logger }) {
-    if (!statedb) {
-      throw new Error('OCAP Resolver requires a valid statedb implementation to work');
-    }
-    if (!indexdb) {
-      throw new Error('OCAP Resolver requires a valid indexdb implementation to work');
-    }
-
-    this.logger = logger || console;
-
-    this.statedb = statedb;
-    this.indexdb = indexdb;
-    this.filter = filter;
-
-    this.config = Object.freeze(Config.validate(config));
-    this.chainAddr = md5(config.chainId);
-    this.tokenItx = Config.genTokenItx(this.config);
-    this.consensus = `${statedb.name} v${statedb.version}`;
-    this.queue = new Queue({
-      autostart: true,
-      concurrency: txRequestConfig.concurrent,
-      timeout: txRequestConfig.timeout,
-    });
-
-    if (indexdb) {
-      this.tokenCache = getTokenCacheInstance(indexdb.token);
-      this.tokenDistribution = new TokenDistributionManager(this);
-    }
-
-    if (this.tokenItx) {
-      this.config.token.address = this.tokenItx.address;
-      if (this.tokenCache) {
-        this.tokenCache.set(this.tokenItx.address, this.tokenItx);
-      }
-    }
-
-    this.executor = createExecutor({
-      filter,
-      runAsLambda: typeof statedb.runAsLambda === 'function' ? statedb.runAsLambda.bind(statedb) : null,
-    });
-    this.formatTx = this._formatTx.bind(this);
-
-    if (validateTokenConfig) {
-      this.validateTokenConfig();
-    }
-
-    this.connectIndexDB();
-    this.initializeStateDB().catch((err) => {
-      this.logger.error('Failed to initialize statedb:', err.message);
-      process.exit(1);
-    });
-  }
-
-  sendTx({ tx: txBase64, extra }, ctx = {}) {
-    debug('sendTx', { txBase64, request: ctx.request });
-
-    if (process.env.CHAIN_MODE === 'readonly') {
-      throw new CustomError('FORBIDDEN', 'This chain node is running in readonly mode');
-    }
-    if (this.queue.length >= txRequestConfig.maxRequest) {
-      throw new CustomError('FORBIDDEN', 'Chain is busy');
-    }
-
-    // 0. create new context
-    // NOTE: if you add more fields here, please remember to change core/tx-protocols/lib/execute.js
-    const context = {
-      txBase64,
-      statedb: this.statedb,
-      indexdb: this.indexdb,
-      config: this.config,
-      filter: this.filter,
-      logger: this.logger,
-      extra: {
-        ...ctx,
-        txExtra: extra,
-      },
-    };
-
-    return new Promise((resolve, reject) => {
-      const task = async () => {
-        try {
-          const result = await this.executor.execute(context);
-          resolve(result.txHash);
-        } catch (err) {
-          reject(err);
-        }
-      };
-      this.queue.push(task);
-    });
-  }
-
-  getTx({ hash }, ctx) {
-    if (patterns.txHash.test(hash)) {
-      return this._getState({
-        table: 'tx',
-        id: hash.toUpperCase(),
-        dataKey: 'tx.itxJson.data',
-        onRead: (tx) => this.formatTx(tx, ctx),
-        expandContext: false,
-        ctx,
-      });
-    }
-
-    return null;
-  }
-
-  getBlock() {
-    return null;
-  }
-
-  getBlocks() {
-    return [];
-  }
-
-  getUnconfirmedTxs() {
-    return [];
-  }
-
-  async getChainInfo() {
-    return Promise.resolve({
-      id: this.chainAddr,
-      totalTxs: await this.indexdb.tx.count(),
-      blockHash: md5(''),
-      blockHeight: 0,
-      blockTime: '',
-      version: this.config.version,
-      address: this.chainAddr,
-      appHash: md5(new Date().toISOString()),
-      consensusVersion: this.consensus,
-      forgeAppsVersion: [],
-      moniker: this.config.chainId,
-      network: this.config.chainId,
-      supportedTxs: this.config.transaction.supportedTxs,
-      synced: true,
-      votingPower: '10',
-    });
-  }
-
-  getNodeInfo() {
-    return Promise.resolve({
-      address: this.chainAddr,
-      appHash: md5(new Date().toISOString()),
-      consensusVersion: this.consensus,
-      forgeAppsVersion: [],
-      geoInfo: {
-        city: 'Unknown',
-        country: 'Unknown',
-        latitude: 0,
-        longitude: 0,
-      },
-      id: this.chainAddr,
-      ip: '',
-      moniker: this.config.chainId,
-      network: this.config.chainId,
-      p2pAddress: '',
-      supportedTxs: this.config.transaction.supportedTxs,
-      synced: true,
-      votingPower: '10',
-    });
-  }
-
-  getNetInfo() {
-    return Promise.resolve({
-      listeners: [],
-      listening: true,
-      nPeers: 0,
-      peers: [],
-    });
-  }
-
-  getValidatorsInfo() {
-    return Promise.resolve({
-      blockHeight: 0,
-      validators: [
-        {
-          address: fromPublicKey(this.chainAddr),
-          name: '',
-          proposerPriority: '0',
-          votingPower: '10',
-        },
-      ],
-    });
-  }
-
-  getConfig() {
-    return JSON.stringify(this.config);
-  }
-
-  getAccountState({ address, traceMigration = true, expandContext = true }, ctx) {
-    return this._getState({
-      table: 'account',
-      id: address,
-      dataKey: 'data',
-      extraParams: { traceMigration },
-      expandContext,
-      onRead: async (state) => {
-        if (state) {
-          if (state.tokens) {
-            state.tokens = await this.formatTokenMap(state.tokens);
-          }
-        }
-
-        return state;
-      },
-      ctx,
-    });
-  }
-
-  getStakeState({ address }, ctx) {
-    return this._getState({
-      table: 'stake',
-      id: address,
-      dataKey: 'data',
-      onRead: async (state) => {
-        if (state) {
-          if (state.tokens) {
-            state.tokens = await this.formatTokenMap(state.tokens);
-          }
-          if (state.revokedTokens) {
-            state.revokedTokens = await this.formatTokenMap(state.revokedTokens);
-          }
-        }
-
-        return state;
-      },
-      ctx,
-    });
-  }
-
-  async getRollupState({ address }, ctx) {
-    const rollup = await this._getState({
-      table: 'rollup',
-      id: address,
-      dataKey: 'data',
-      onRead: async (state) => {
-        if (state) {
-          const tokens = await this.formatTokenMap({ [state.tokenAddress]: '0' });
-          state.tokenInfo = tokens.find((x) => x.address === state.tokenAddress);
-          state.foreignToken = state.tokenInfo.foreignToken;
-        }
-
-        return state;
-      },
-      ctx,
-    });
-
-    if (!rollup) {
-      return null;
-    }
-
-    const indexed = await this.indexdb.rollup.get(address);
-    if (indexed) {
-      rollup.totalDepositAmount = indexed.totalDepositAmount || '0';
-      rollup.totalWithdrawAmount = indexed.totalWithdrawAmount || '0';
-    }
-
-    return rollup;
-  }
-
-  async getRollupBlock({ hash, height, rollupAddress }, ctx) {
-    if (hash) {
-      return this._getState({ table: 'rollupBlock', id: hash, dataKey: 'data', ctx });
-    }
-
-    const blockHeight = Number(height || 0);
-    if (blockHeight > 0 && rollupAddress) {
-      const { blocks } = await this._doPaginatedSearch(
-        'listRollupBlocks',
-        { height: blockHeight, rollupAddress },
-        'blocks',
-        'data',
-        ctx
-      );
-
-      if (blocks.length) {
-        return this._getState({ table: 'rollupBlock', id: blocks[0].hash, dataKey: 'data', ctx });
-      }
-
-      return null;
-    }
-
-    throw new Error('Can not get rollup block without hash or height + rollup');
-  }
-
-  getAssetState({ address }, ctx) {
-    return this._getState({
-      table: 'asset',
-      id: address,
-      dataKey: 'data',
-      onRead: (state) => {
-        if (state && Array.isArray(state.tagsList)) {
-          state.tags = state.tagsList;
-        }
-
-        return state;
-      },
-      ctx,
-    });
-  }
-
-  getEvidenceState({ hash }, ctx) {
-    return this._getState({ table: 'evidence', id: hash, dataKey: null, ctx });
-  }
-
-  getFactoryState({ address }, ctx) {
-    return this._getState({
-      table: 'factory',
-      id: address,
-      dataKey: 'data',
-      onRead: async (state) => {
-        if (state) {
-          state.tokens = await this.formatTokenMap(state.tokens);
-          if (Array.isArray(state.input.tokens) && state.input.tokens.length > 0) {
-            state.input.tokens = await this.formatTokenArray(state.input.tokens || []);
-          }
-
-          state.output.data = formatData(state.output.data);
-        }
-
-        return state;
-      },
-      ctx,
-    });
-  }
-
-  async getTokenState({ address }, ctx) {
-    const state = await this._getState({ table: 'token', id: address, dataKey: 'data', ctx });
-    if (state) {
-      if (typeof state.decimal === 'undefined') {
-        state.decimal = DEFAULT_TOKEN_DECIMAL;
-      }
-      if (state.metadata) {
-        state.metadata = formatData(state.metadata);
-      }
-    }
-
-    return state;
-  }
-
-  getTokenFactoryState(args, ctx) {
-    return this._getState({
-      table: 'tokenFactory',
-      id: args.address,
-      dataKey: 'data',
-      ctx,
-      onRead: async (state) => {
-        if (state) {
-          const [token, reserveToken] = await Promise.all([
-            this.getTokenState({ address: state.tokenAddress }),
-            this.getTokenState({ address: state.reserveAddress }),
-          ]);
-          state.token = { ...token, metadata: formatData(token.metadata) };
-          state.reserveToken = { ...reserveToken, metadata: formatData(reserveToken.metadata) };
-        }
-
-        return state;
-      },
-    });
-  }
-
-  getDelegateState({ address }, ctx) {
-    return this._getState({
-      table: 'delegation',
-      id: address,
-      dataKey: 'data',
-      onRead: async (state) => {
-        if (state) {
-          formatDelegationOps(state);
-          await this.formatDelegateState(state);
-        }
-
-        return state;
-      },
-      ctx,
-    });
-  }
-
-  async getAccountTokens({ address, token }, ctx) {
-    if (!address) {
-      return [];
-    }
-
-    let state = null;
-
-    const type = toTypeInfo(address);
-    if (type.role === types.RoleType.ROLE_ASSET) {
-      state = await this._getState({ table: 'factory', id: address, dataKey: 'data', expandContext: false, ctx });
-    } else {
-      state = await this._getState({ table: 'account', id: address, dataKey: 'data', expandContext: false, ctx });
-    }
-
-    if (!state || !state.tokens) {
-      return [];
-    }
-
-    const allTokens = Object.keys(state.tokens);
-    const wantedTokens = token ? allTokens.filter((x) => x === token) : allTokens;
-
-    const tokens = await Promise.all(
-      wantedTokens.map((x) => this._getState({ table: 'token', id: x, dataKey: 'data', expandContext: false, ctx }))
-    );
-    const tokensInfo = tokens.reduce((acc, x) => {
-      acc[x.address] = { symbol: x.symbol, decimal: x.decimal || DEFAULT_TOKEN_DECIMAL, unit: x.util }; // 兼容没有 decimal 的 token
-      return acc;
-    }, {});
-
-    return wantedTokens.map((x) => ({
-      address: x,
-      ...tokensInfo[x],
-      balance: state.tokens[x],
-    }));
-  }
-
-  getForgeState() {
-    const { accounts, token, transaction, vaults } = this.config;
-    return Promise.resolve({
-      accountConfig: accounts,
-      address: 'forge_state',
-      consensus: {
-        maxBytes: '150000',
-        maxCandidates: 256,
-        maxGas: '-1',
-        maxValidators: 64,
-        paramChanged: false,
-        validatorChanged: false,
-      },
-      data: null,
-      tasks: [],
-      token,
-      vaults,
-      txConfig: {
-        ...transaction,
-        txGas: {
-          ...transaction.txGas,
-          minStake: fromTokenToUnit(transaction.txGas.minStake, token.decimal).toString(10),
-          maxStake: fromTokenToUnit(transaction.txGas.maxStake, token.decimal).toString(10),
-        },
-        txStake: {
-          ...transaction.txStake,
-          createToken: fromTokenToUnit(transaction.txStake.createToken, token.decimal).toString(10),
-          createCreditToken: fromTokenToUnit(transaction.txStake.createCreditToken, token.decimal).toString(10),
-        },
-        txFee: Object.keys(transaction.txFee)
-          .filter((x) => x !== 'default')
-          .map((x) => ({ typeUrl: x, fee: fromTokenToUnit(transaction.txFee[x], token.decimal).toString(10) })),
-      },
-      upgradeInfo: null,
-      reservedSymbols: this.config.reservedSymbols,
-    });
-  }
-
-  async getForgeStats() {
-    const [accountCount, assetCount, txCount] = await Promise.all([
-      this.indexdb.account.count(),
-      this.indexdb.asset.count(),
-      this.indexdb.tx.count(),
-    ]);
-
-    return {
-      avgBlockTime: 1,
-      avgTps: 0,
-      maxTps: 0,
-      numAccountMigrateTxs: ['0'],
-      numBlocks: [txCount],
-      numConsensusUpgradeTxs: [0],
-      numConsumeAssetTxs: ['0'],
-      numCreateAssetTxs: [assetCount],
-      numDeclareFileTxs: ['0'],
-      numDeclareTxs: [accountCount],
-      numExchangeTxs: ['0'],
-      numPokeTxs: ['0'],
-      numStakeTxs: ['0'],
-      numStakes: ['0'],
-      numSysUpgradeTxs: [0],
-      numTransferTxs: ['0'],
-      numTxs: [txCount],
-      numUpdateAssetTxs: ['0'],
-      numValidators: [1],
-      tps: [0],
-    };
-  }
-
-  async listTransactions(args, ctx) {
-    const data = await this._doPaginatedSearch('listTransactions', args, 'transactions', 'tx.itxJson.data', ctx);
-    return data;
-  }
-
-  listAssets(args, ctx) {
-    return this._doPaginatedSearch('listAssets', args, 'assets', 'data', ctx);
-  }
-
-  listAssetTransactions(args = {}, ctx = {}) {
-    if (!args.address) {
-      return { transactions: [] };
-    }
-
-    return this._doPaginatedSearch(
-      'listTransactions',
-      { ...args, assetFilter: { assets: [args.address] } },
-      'transactions',
-      'tx.itxJson.data',
-      ctx
-    );
-  }
-
-  async listFactories(args, ctx) {
-    const result = await this._doPaginatedSearch('listFactories', args, 'factories', 'data', ctx);
-    result.factories = result.factories.map((x) => {
-      x.output.data = formatData(x.output.data);
-      return x;
-    });
-
-    return result;
-  }
-
-  listTopAccounts(args) {
-    if (!args.tokenAddress) {
-      args.tokenAddress = this.tokenItx.address;
-    }
-
-    return this._doPaginatedSearch('listTopAccounts', args, 'accounts');
-  }
-
-  listTokens(args, ctx) {
-    return this._doPaginatedSearch('listTokens', args, 'tokens', ['data', 'metadata'], ctx);
-  }
-
-  listTokenFactories(args, ctx) {
-    return this._doPaginatedSearch('listTokenFactories', args, 'tokenFactories', 'data', ctx);
-  }
-
-  listStakes(args, ctx) {
-    return this._doPaginatedSearch('listStakes', args, 'stakes', 'data', ctx);
-  }
-
-  listRollups(args, ctx) {
-    return this._doPaginatedSearch('listRollups', args, 'rollups', 'data', ctx);
-  }
-
-  listRollupBlocks(args, ctx) {
-    return this._doPaginatedSearch('listRollupBlocks', args, 'blocks', 'data', ctx);
-  }
-
-  async listRollupValidators(args, ctx) {
-    if (!args.rollupAddress) {
-      return { validators: [] };
-    }
-
-    const rollup = await this.statedb.rollup.get(args.rollupAddress);
-    if (!rollup) {
-      return { validators: [] };
-    }
-
-    const result = await this._doPaginatedSearch('listRollupValidators', args, 'validators', null, ctx);
-    const stakes = (
-      await Promise.all(
-        result.validators.map((x) => {
-          const stakeAddress = toStakeAddress(x.address, args.rollupAddress);
-          return this.statedb.stake.get(stakeAddress);
-        })
-      )
-    ).filter(Boolean);
-    result.validators.forEach((x) => {
-      const stakeAddress = toStakeAddress(x.address, args.rollupAddress);
-      const stake = stakes.find((s) => s.address === stakeAddress);
-      x.availableStake = stake ? stake.tokens[rollup.tokenAddress] : '0';
-    });
-
-    return result;
-  }
-
-  listDelegations(args, ctx) {
-    return this._doPaginatedSearch('listDelegations', args, 'delegations', 'data', ctx);
-  }
-
-  verifyAccountRisk(args, ctx) {
-    if (process.env.TOKEN_FLOW_ENABLED === 'true') {
-      return tokenFlow.verifyAccountRisk(
-        {
-          ...args,
-          tokenAddress: toAddress(args.tokenAddress || this.config.token.address),
-          accountAddress: toAddress(args.accountAddress || ''),
-          accountLimit: process.env.VERIFY_RISK_ACCOUNT_LIMIT,
-          txLimit: process.env.VERIFY_RISK_TX_LIMIT,
-          tolerance: process.env.VERIFY_RISK_TOLERANCE,
-        },
-        this,
-        ctx
-      );
-    }
-    return null;
-  }
-
-  listTokenFlows(args, ctx) {
-    if (process.env.TOKEN_FLOW_ENABLED === 'true') {
-      return tokenFlow.listTokenFlows(args, this, ctx);
-    }
-    return [];
-  }
-
-  async search(args) {
-    if (!args.keyword) {
-      return { results: [] };
-    }
-
-    const doSearch = async (type, keyword) => {
-      const result = await this.indexdb[type].get(keyword);
-      return result ? { type, id: keyword } : null;
-    };
-
-    if (patterns.txHash.test(args.keyword)) {
-      const results = await Promise.all([
-        doSearch('tx', args.keyword.toUpperCase()),
-        doSearch('rollupBlock', args.keyword),
-      ]);
-      return { results: results.filter(Boolean) };
-    }
-
-    const entitiesByDid = ['account', 'asset', 'delegation', 'factory', 'token', 'stake', 'rollup', 'tokenFactory'];
-    if (isValidDid(args.keyword)) {
-      const keyword = toAddress(args.keyword);
-      const results = await Promise.all(entitiesByDid.map((type) => doSearch(type, keyword)));
-      return { results: results.filter(Boolean) };
-    }
-
-    return { results: [] };
-  }
-
-  estimateGas(args = {}) {
-    const { typeUrl = '' } = args;
-    if (!typeUrl || !maxGasOps[typeUrl]) {
-      throw new CustomError('INVALID_REQUEST', 'Unknown tx typeUrl');
-    }
-
-    const { txGas, maxTxSize } = this.config.transaction;
-    const estimate = maxGasOps[args.typeUrl];
-    let totalGas = new BN(txGas.price).mul(new BN(txGas.dataStorage)).mul(new BN(maxTxSize[args.typeUrl]));
-    totalGas = totalGas.add(new BN(txGas.price).mul(new BN(txGas.createState)).mul(new BN(estimate.create + 1))); // 1 = tx insert
-    totalGas = totalGas.add(new BN(txGas.price).mul(new BN(txGas.updateState)).mul(new BN(estimate.update)));
-    return { estimate: { max: totalGas.toString(10) } };
-  }
-
-  listBlocks() {
-    return { blocks: [] };
-  }
-
-  validateTokenConfig() {
-    const { accounts, token } = this.config;
-    const sum = accounts.reduce((acc, x) => acc.add(toBN(x.balance)), toBN(0));
-    const initialSupply = toBN(token.initialSupply);
-    if (!sum.eq(initialSupply)) {
-      throw new Error('Invalid config, account balance sum does not equal to token supply');
-    }
-  }
-
-  runAsLambda(fn, args) {
-    if (typeof this.statedb.runAsLambda === 'function') {
-      return this.statedb.runAsLambda((txn) => fn(txn), args);
-    }
-
-    return fn();
-  }
-
-  getChain() {
-    return this.statedb.chain.get(CHAIN_ADDR);
-  }
-
-  getToken(id) {
-    return this.statedb.token.get(id);
-  }
-
-  async initializeStateDB() {
-    const { accounts, token } = this.config;
-    const { account: accountDB, chain: chainDB, token: tokenDB } = this.statedb;
-    const { account: accountState, chain: chainState, token: tokenState } = states;
-
-    const context = { txTime: new Date().toISOString(), txHash: '' };
-
-    // Auto persist config to chain state
-    // Will throw error if immutable chain config are updated
-    await this.runAsLambda(
-      async (txn) => {
-        const info = await this.statedb.chain.get(CHAIN_ADDR, { txn });
-        const config = omit(this.config, ['reservedSymbols']);
-
-        if (!info) {
-          const state = chainState.create({ ...config, address: CHAIN_ADDR }, context);
-          const result = await chainDB.create(CHAIN_ADDR, state, { txn });
-          this.logger.debug('create chain state', { result });
-        } else if (isEqual(pick(info, Object.keys(config)), config) === false) {
-          const state = chainState.update(info, config, context);
-          const result = await chainDB.update(CHAIN_ADDR, state, { txn });
-          this.logger.debug('update chain state', { result });
-        }
-      },
-      { commitMessage: 'initialize chain' }
-    );
-
-    // Auto persist token state, just once
-    // Since the token info should not be changed after restart
-    if (this.tokenItx) {
-      await this.runAsLambda(
-        async (txn) => {
-          const existToken = await this.statedb.token.get(this.tokenItx.address);
-
-          if (!existToken) {
-            const state = tokenState.create(this.tokenItx, context);
-            const result = await tokenDB.create(this.tokenItx.address, state, { txn });
-            tokenDB.emit('create', result, { txn });
-            this.logger.debug('create token state', { address: result?.address });
-          } else {
-            // update token state if metadata are changed
-            const changedKeys = ['icon', 'website', 'metadata'];
-            const pickStateToken = pick(existToken, changedKeys);
-            const pickConfigToken = pick(this.tokenItx, changedKeys);
-
-            if (!isEqual(pickStateToken, pickConfigToken)) {
-              const state = tokenState.update(existToken, pickConfigToken, context);
-              const result = await tokenDB.update(this.tokenItx.address, state, { txn });
-              tokenDB.emit('update', result, { txn });
-              this.logger.info('update token state', { result });
-            }
-          }
-        },
-        { commitMessage: 'initialize token' }
-      );
-
-      // Auto populate token holder accounts if not exist
-      await this.runAsLambda(
-        async (txn) => {
-          for (let i = 0; i < accounts.length; i++) {
-            const { address, balance, moniker, pk } = accounts[i];
-            try {
-              const existAccount = await accountDB.get(address, { txn });
-              if (!existAccount) {
-                const balanceStr = fromTokenToUnit(balance, token.decimal).toString(10);
-                const state = accountState.create(
-                  { address, tokens: { [this.tokenItx.address]: balanceStr }, moniker: moniker || 'token-holder', pk },
-                  context
-                );
-                const result = await accountDB.create(address, state, { txn });
-                accountDB.emit('create', result, { txn });
-                this.logger.info('create account done', { address });
-              }
-            } catch (err) {
-              this.logger.error('Failed to initialize initial token holders', err);
-            }
-          }
-        },
-        { commitMessage: 'initialize accounts' }
-      );
-    }
-  }
-
-  connectIndexDB() {
-    const getToken = this.getToken.bind(this);
-
-    this.statedb.tx.on('create', async (x, ctx) => {
-      try {
-        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);
-        }
-      } catch (error) {
-        this.logger.error('create tx index failed', { account: x, error });
-      }
-    });
-
-    this.statedb.account.on('create', async (x) => {
-      try {
-        await this.indexdb.account.insert(await createIndexedAccount(x, getToken));
-      } catch (error) {
-        this.logger.error('create account index failed', { account: x, error });
-      }
-    });
-    this.statedb.account.on('update', async (x) => {
-      try {
-        await this.indexdb.account.update(x.address, await createIndexedAccount(x, getToken));
-      } catch (error) {
-        this.logger.error('update account index failed', { account: x, error });
-      }
-    });
-
-    const mapping = {
-      asset: [createIndexedAsset, 'address'],
-      delegation: [createIndexedDelegation, 'address'],
-      token: [createIndexedToken, 'address', null, hooks.onUpdateToken],
-      factory: [createIndexedFactory, 'address'],
-      stake: [createIndexedStake, 'address'],
-      rollup: [createIndexedRollup, 'address', hooks.onCreateRollup],
-      rollupBlock: [createIndexedRollupBlock, 'hash', hooks.onCreateRollupBlock],
-      tokenFactory: [createIndexedTokenFactory, 'address'],
-    };
-    Object.keys(mapping).forEach((table) => {
-      const [fn, key, onCreate, onUpdate] = mapping[table];
-
-      this.statedb[table].on('create', async (x, _ctx) => {
-        try {
-          const ctx = this.enrichIndexContext(_ctx);
-          const doc = await fn(x, ctx, this.indexdb);
-          await this.indexdb[table].insert(doc);
-          if (typeof onCreate === 'function') {
-            await onCreate(doc, ctx, this.indexdb, this);
-          }
-        } catch (error) {
-          this.logger.error(`create ${table} index failed`, { [table]: x, error });
-        }
-      });
-
-      this.statedb[table].on('update', async (x, _ctx) => {
-        try {
-          const ctx = this.enrichIndexContext(_ctx);
-          const doc = await fn(x, ctx, this.indexdb);
-          await this.indexdb[table].update(doc[key], doc);
-          if (typeof onUpdate === 'function') {
-            await onUpdate(doc, ctx, this.indexdb, this);
-          }
-        } catch (error) {
-          this.logger.error(`update ${table} index failed`, { [table]: x, error });
-        }
-      });
-    });
-  }
-
-  async _getState({ table, id, dataKey, extraParams = {}, onRead = noop, expandContext = true, ctx }) {
-    if (!id) {
-      throw new CustomError('INVALID_REQUEST', `Missing required parameter to read ${table} state`);
-    }
-
-    const unified = isValidDid(id) ? toAddress(id) : id;
-    const state = await this.statedb[table].get(unified, { ...extraParams });
-    if (state) {
-      if (dataKey) {
-        set(state, dataKey, formatData(get(state, dataKey)));
-      }
-
-      // expand context transactions
-      if (expandContext && state.context) {
-        const { genesisTx, renaissanceTx } = state.context;
-        const txs = (
-          await Promise.all(
-            uniq([genesisTx, renaissanceTx])
-              .filter(Boolean)
-              .map((x) => this.getTx({ hash: x }, ctx))
-          )
-        ).filter(Boolean);
-        state.context.genesisTx = txs.find((x) => x.hash === genesisTx);
-        state.context.renaissanceTx = txs.find((x) => x.hash === renaissanceTx);
-
-        if (!state.context.genesisTx) {
-          state.context.genesisTx = { hash: genesisTx };
-        }
-        if (!state.context.renaissanceTx) {
-          state.context.renaissanceTx = { hash: renaissanceTx };
-        }
-      }
-    }
-
-    return onRead(state);
-  }
-
-  async _doPaginatedSearch(fn, args, listKey, dataKey, ctx) {
-    const result = await this.indexdb[fn](args);
-    const { [listKey]: items = [], ...rest } = result;
-    let data = items;
-
-    if (dataKey) {
-      data = await Promise.all(
-        items.map(async (x) => {
-          let tx = x;
-          // dataKey can be an array or string
-          [].concat(dataKey).forEach((key) => {
-            tx = set(tx, key, formatData(get(tx, key)));
-          });
-          if (listKey === 'transactions') {
-            tx = await this.formatTx(tx, ctx);
-          }
-          if (listKey === 'delegations') {
-            tx = await this.formatDelegateState(tx);
-          }
-
-          return tx;
-        })
-      );
-    }
-
-    const final = { [listKey]: data, ...rest };
-    if (!final.paging) {
-      final.paging = { cursor: '0', next: false, total: 0 };
-    }
-
-    return final;
-  }
-
-  async _formatTx(tx, ctx) {
-    if (!tx) {
-      return tx;
-    }
-
-    if (!tx.sender && !tx.receiver) {
-      const typeUrl = fromTypeUrl(tx.tx.itx.typeUrl);
-      tx.sender = getTxSender({ tx: tx.tx, itx: tx.tx.itxJson, typeUrl });
-      tx.receiver = getTxReceiver({ tx: tx.tx, itx: tx.tx.itxJson, typeUrl });
-    }
-
-    if (!tx.receipts) {
-      tx.receipts = getTxReceipts(tx, { config: this.config });
-    }
-
-    const typeUrl = get(tx, 'tx.itxJson.type_url');
-
-    if (typeUrl === 'fg:t:revoke_withdraw' || typeUrl === 'fg:t:approve_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 });
-      }
-    }
-
-    if (
-      [
-        // https://github.com/blocklet/abt-wallet/issues/681
-        'fg:t:deposit_token',
-        'fg:t:withdraw_token',
-        'fg:t:revoke_swap',
-      ].includes(typeUrl)
-    ) {
-      tx.receipts = getTxReceipts(tx, { config: this.config });
-    }
-
-    if (typeUrl === 'fg:t:account_migrate') {
-      const fromState = await this.statedb.account.get(tx.tx.from, { traceMigration: false });
-      if (fromState) {
-        tx.receipts = getTxReceipts(tx, { config: this.config, fromState });
-      }
-    }
-
-    if (typeUrl === 'fg:t:declare') {
-      tx.receipts = getTxReceipts(tx, { config: this.config, time: tx.time });
-    }
-
-    tx.receipts = mergeTxReceipts(tx.receipts);
-    tx.tokenSymbols = await this.getTxTokenSymbols(tx);
-
-    this.fixReceiptTokens(tx, ctx);
-    this.fixTokenSymbols(tx, ctx);
-
-    return attachPaidTxGas(tx);
-  }
-
-  async _getAllResults(dataKey, fn, limit) {
-    const pageSize = 100;
-    const { paging, [dataKey]: firstPage } = await fn({ size: pageSize });
-
-    // Skip if total exceeds limit cause we cannot query full data
-    if (limit && paging.total > limit) {
-      throw new CustomError('EXCEED_LIMIT', `Total exceeds limit ${limit}`);
-    }
-    if (paging.total <= pageSize) {
-      return firstPage;
-    }
-
-    const totalPage = Math.ceil(paging.total / pageSize) - 1;
-    const cursors = new Array(totalPage).fill(true).map((_, i) => (i + 1) * pageSize);
-    const step = process.env.RESOLVER_BATCH_CONCURRENCY || 3;
-    let results = firstPage;
-
-    for (let i = 0; i < cursors.length; i += step) {
-      const batchResults = await Promise.all(
-        cursors.slice(i, i + step).map(async (cursor) => {
-          const { [dataKey]: list } = await fn({ size: pageSize, cursor });
-          return list;
-        })
-      );
-      results = results.concat(batchResults.flat());
-    }
-
-    return results;
-  }
-
-  async formatTokenArray(tokens) {
-    const uniqTokens = uniqBy(tokens, 'address');
-    const tokenStates = await Promise.all(uniqTokens.map((token) => this.tokenCache.get(token.address)));
-
-    return uniqTokens.map((token) => ({ ...token, ...extractTokenMeta(token.address, tokenStates) }));
-  }
-
-  async formatTokenMap(tokens) {
-    if (isEmpty(tokens)) {
-      return [];
-    }
-
-    const tasks = Object.keys(tokens).map((address) => this.tokenCache.get(address));
-    const tokenStates = await Promise.all(tasks);
-
-    return Object.keys(tokens).map((address) => ({
-      value: tokens[address],
-      ...extractTokenMeta(address, tokenStates),
-    }));
-  }
-
-  async getTxTokenSymbols(tx) {
-    if (!tx) {
-      return [];
-    }
-
-    const rollupTxs = [
-      'DepositTokenV2Tx',
-      'WithdrawTokenV2Tx',
-      'JoinRollupTx',
-      'LeaveRollupTx',
-      'CreateRollupBlockTx',
-      'ClaimBlockRewardTx',
-    ];
-    const typeUrl = formatTxType(tx.tx.itxJson._type);
-    const tokens = [];
-
-    if (isDefaultTokenChanged(tx, this.config.token)) {
-      tokens.push(this.tokenItx);
-    }
-
-    if (typeUrl === 'AcquireAssetV2Tx') {
-      const factory = await this.indexdb.factory.get(tx.tx.itxJson.factory);
-      tokens.push(...factory.input.tokens);
-    } else if (typeUrl === 'ExchangeV2Tx') {
-      tokens.push(...tx.tx.itxJson.sender.tokens);
-      tokens.push(...tx.tx.itxJson.receiver.tokens);
-    } else if (typeUrl === 'TransferV2Tx') {
-      tokens.push(...tx.tx.itxJson.tokens);
-    } else if (['TransferV3Tx', 'AcquireAssetV3Tx', 'StakeTx'].includes(typeUrl)) {
-      tokens.push(
-        ...uniqBy(
-          tx.tx.itxJson.inputs.reduce((acc, x) => acc.concat(x.tokens), []),
-          'address'
-        ).filter((x) => x.address)
-      );
-    } else if (['RevokeStakeTx', 'SlashStakeTx', 'ReturnStakeTx'].includes(typeUrl)) {
-      tokens.push(
-        ...uniqBy(
-          tx.tx.itxJson.outputs.reduce((acc, x) => acc.concat(x.tokens), []),
-          'address'
-        ).filter((x) => x.address)
-      );
-    } else if (typeUrl === 'ClaimStakeTx') {
-      const revokeTx = await this.indexdb.tx.get(tx.tx.itxJson.evidence.hash);
-      if (revokeTx) {
-        tokens.push(
-          ...uniqBy(
-            revokeTx.tx.itxJson.outputs.reduce((acc, x) => acc.concat(x.tokens), []),
-            'address'
-          ).filter((x) => x.address)
-        );
-      } else {
-        this.logger.warn('Revoke stake tx not found', { tx });
-      }
-    } else if (rollupTxs.includes(typeUrl)) {
-      const rollup = await this.indexdb.rollup.get(tx.tx.itxJson.rollup);
-      tokens.push({ address: rollup.tokenAddress, value: '0' });
-    } else if (typeUrl === 'CreateTokenTx') {
-      return [extractTokenMeta(tx.tx.itxJson.address, [tx.tx.itxJson])];
-    } else if (typeUrl === 'MintTokenTx' || typeUrl === 'BurnTokenTx') {
-      const token = await this.indexdb.tokenFactory.get(tx.tx.itxJson.tokenFactory);
-      tokens.push({ address: token.tokenAddress });
-    } else if (typeUrl === 'CreateTokenFactoryTx') {
-      tokens.push({ address: tx.tx.itxJson.token.address });
-    }
-
-    if (tokens.length > 0) {
-      return this.formatTokenArray(tokens);
-    }
-
-    return [];
-  }
-
-  fixReceiptTokens(tx) {
-    // Auto populate initial token address in tx receipts
-    tx.receipts.forEach((receipt) =>
-      receipt.changes.forEach((x) => {
-        if (x.target === '') {
-          x.target = this.tokenItx.address;
-        }
-      })
-    );
-
-    return tx;
-  }
-
-  fixTokenSymbols(tx) {
-    const index = tx.tokenSymbols.findIndex((x) => x.address === this.tokenItx.address);
-    if (index === -1) {
-      tx.tokenSymbols.push(extractTokenMeta(this.tokenItx.address, [this.tokenItx]));
-    }
-
-    return tx;
-  }
-
-  enrichIndexContext(ctx) {
-    if (Array.isArray(ctx.tokenStates)) {
-      return { ...ctx, tokenStates: [...ctx.tokenStates, this.tokenItx] };
-    }
-    if (ctx.tokenState) {
-      return { ...ctx, tokenStates: [ctx.tokenState] };
-    }
-
-    return ctx;
-  }
-
-  async formatDelegateState(state) {
-    if (Array.isArray(state.ops) && state.ops.length > 0) {
-      await Promise.all(
-        state.ops.map(async (op) => {
-          if (op.value.limit && Array.isArray(op.value.limit.tokens)) {
-            op.value.limit.tokens = await this.formatTokenArray(op.value.limit.tokens || []);
-          }
-        })
-      );
-    }
-
-    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;
-  }
-
-  async getMigrationChain() {
-    if (!this.migrationChain) {
-      await this.buildMigrationChain();
-    }
-
-    return this.migrationChain;
-  }
-
-  /** fix accounts field of legacy approve_withdraw transactions in indexdb */
-  async fixApproveWithdrawAccounts() {
-    const approveWithdrawTxs = await this._getAllResults('transactions', (paging) =>
-      this.listTransactions({
-        paging,
-        typeFilter: { types: ['approve_withdraw'] },
-        validityFilter: { validity: ['VALID'] },
-      })
-    );
-
-    const updatedTxs = await Promise.all(
-      approveWithdrawTxs.map(async (tx) => {
-        const withdrawHash = tx.tx?.itxJson?.withdraw_tx_hash;
-
-        if (!withdrawHash) return;
-
-        const indexdbTx = await this.indexdb.tx.get(tx.hash);
-        const withdrawTx = await this.getTx({ hash: withdrawHash });
-        const from = withdrawTx?.tx?.from;
-
-        if (!from || !indexdbTx) return;
-
-        const accounts = uniq((indexdbTx.accounts || []).concat([from]).filter(Boolean));
-        debug('fixApproveWithdrawAccounts', { tx, from, accounts });
-
-        // update indexdb
-        const updatedTx = await this.indexdb.tx.update(tx.hash, { accounts });
-        return updatedTx;
-      })
-    );
-
-    return updatedTxs.filter(Boolean);
-  }
-
-  async updateTokenDistribution({ tokenAddress = this.config.token.address, force = false } = {}) {
-    const paramsSchema = Joi.object({
-      tokenAddress: Joi.DID().prefix().role('ROLE_TOKEN').required(),
-      force: Joi.boolean().required(),
-    });
-    const validation = paramsSchema.validate({ tokenAddress, force });
-    if (validation.error) {
-      throw new CustomError('INVALID_PARAMS', validation.error.message);
-    }
-
-    const data = await this.tokenDistribution.updateByToken(tokenAddress, force);
-    return data;
-  }
-
-  async getTokenDistribution({ tokenAddress = this.config.token.address }) {
-    const data = await this.tokenDistribution.getDistribution(tokenAddress);
-    return data;
-  }
-
-  /**
-   * Fetch data in chunks to handle large datasets
-   * @param {Function} fn Function to fetch data
-   * @param {Object} param
-   * @param {number} [param.concurrency=3] Number of concurrent requests
-   * @param {number} [param.chunkSize=2000] Maximum number of items to return in each next() call
-   * @param {number} [param.pageSize=100] Number of items per page
-   * @param {string} param.timeKey Key to access time in response
-   * @param {string} param.dataKey Key to access data in response
-   * @returns {Promise<Array>} Array of fetched items
-   */
-  listChunks(fn, { total, concurrency = 3, chunkSize = 2100, pageSize = 100, timeKey, dataKey }) {
-    let done = false;
-    let time;
-    const totalPage = Math.ceil(total / pageSize);
-    let curPage = 0;
-
-    const next = async () => {
-      if (done) {
-        return [];
-      }
-
-      let results = [];
-
-      // next pages
-      for (; curPage < totalPage; curPage += concurrency) {
-        const batchResults = await Promise.all(
-          new Array(Math.min(concurrency, totalPage - curPage)).fill(true).map(async (_, i) => {
-            const { [dataKey]: list } = await fn({
-              size: pageSize,
-              cursor: i * pageSize,
-              time,
-            });
-            return list;
-          })
-        );
-        const flatResults = batchResults.flat();
-
-        // finish
-        if (!flatResults.length) {
-          done = true;
-          return results;
-        }
-
-        results = results.concat(flatResults);
-        time = results.length ? results[results.length - 1][timeKey] : null;
-
-        // limit
-        if (results.length >= chunkSize) {
-          return results;
-        }
-      }
-
-      done = true;
-      return results;
-    };
-
-    return {
-      next,
-      done,
-    };
-  }
-
-  async listTransactionsChunks(args = {}, { chunkSize = 2100, pageSize = 100 } = {}) {
-    return this.listChunks(
-      ({ size, time, cursor }) =>
-        this.listTransactions({
-          ...args,
-          paging: {
-            order: { field: 'time', type: 'asc' },
-            ...(args.paging || {}),
-            size,
-            cursor,
-          },
-          timeFilter: Object.assign(args.timeFilter || {}, time ? { startDateTime: time } : {}),
-        }),
-      {
-        dataKey: 'transactions',
-        timeKey: 'time',
-        total: await this.indexdb.tx.count(),
-        chunkSize,
-        pageSize,
-      }
-    );
-  }
-
-  async listStakeChunks(args = {}, { chunkSize = 2100, pageSize = 100 } = {}) {
-    return this.listChunks(
-      ({ size, time, cursor }) =>
-        this.listStakes({
-          ...args,
-          paging: {
-            order: { field: 'time', type: 'asc' },
-            ...(args.paging || {}),
-            size,
-            cursor,
-          },
-          timeFilter: Object.assign(args.timeFilter || {}, time ? { startDateTime: time } : {}),
-        }),
-      {
-        dataKey: 'stakes',
-        timeKey: 'renaissanceTime',
-        total: await this.indexdb.stake.count(),
-        chunkSize,
-        pageSize,
-      }
-    );
-  }
-};
-
-module.exports.formatData = formatData;
-module.exports.formatDelegationOps = formatDelegationOps;