@ocap/resolver 1.6.3 → 1.6.10

package/lib/index.js

@@ -1,15 +1,47 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable newline-per-chained-call */
 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 Config = require('@ocap/config');
 const states = require('@ocap/state');
+const Joi = require('@arcblock/validator');
 const md5 = require('@ocap/util/lib/md5');
-const { fromPublicKey } = require('@arcblock/did');
+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 { toBN, fromTokenToUnit } = require('@ocap/util');
+const { DEFAULT_TOKEN_DECIMAL } = require('@ocap/util/lib/constant');
 const { createExecutor } = require('@ocap/tx-protocols');
-const { decodeItxData } = require('@ocap/tx-protocols/lib/util');
+const { decodeAnySafe } = require('@ocap/tx-protocols/lib/util');
+const {
+  createIndexedAccount,
+  createIndexedAsset,
+  createIndexedFactory,
+  createIndexedDelegation,
+  createIndexedToken,
+  createIndexedTransaction,
+  createIndexedStake,
+  createIndexedRollup,
+  createIndexedRollupBlock,
+  isDefaultTokenChanged,
+} = require('@ocap/indexdb/lib/util');
+const { formatTxType } = require('@ocap/util');
+
+const { getTxReceipts, mergeTxReceipts, getTxSender, getTxReceiver } = require('@ocap/state/lib/states/tx');
 
 const debug = require('debug')(require('../package.json').name);
+const hooks = require('./hooks');
+const { getInstance: getTokenCacheInstance } = require('./token-cache');
+
+const noop = (x) => x;
+const CHAIN_ADDR = md5('OCAP_CHAIN_ADDR');
 
 const formatData = (data) => {
   if (!data) {
@@ -27,18 +59,48 @@ const formatData = (data) => {
       data.type_url = data.typeUrl;
       return data;
     } catch (err) {
-      // do nothing
+      // 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 ? decodeItxData(data) : data;
-  if (['json', 'vc'].includes(decoded.type)) {
+  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 && 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.
@@ -59,41 +121,71 @@ module.exports = class OCAPResolver {
 
     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}`;
 
-    if (validateTokenConfig) {
-      this.validateTokenConfig();
+    if (indexdb) {
+      this.tokenCache = getTokenCacheInstance(indexdb.token);
+    }
+
+    if (this.tokenItx) {
+      this.config.token.address = this.tokenItx.address;
+      if (this.tokenCache) {
+        this.tokenCache.set(this.tokenItx.address, this.tokenItx);
+      }
     }
 
-    this.filter = filter;
     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.runAsLambda((txn) => this.initializeStateDB(txn));
+    this.runAsLambda((txn) => this.initializeStateDB(txn)).catch((err) => {
+      console.error('Failed to initialize statedb:', err.message);
+      process.exit(1);
+    });
   }
 
   async sendTx({ tx: txBase64 }) {
     debug('sendTx', txBase64);
 
+    if (process.env.CHAIN_MODE === 'readonly') {
+      throw new CustomError('FORBIDDEN', 'This chain node is running in readonly mode');
+    }
+
     // 0. create new context
     const context = { txBase64, statedb: this.statedb, config: this.config };
 
-    // 1. execute the transaction
+    // 1. execute and persist the transaction
     const result = await this.executor.execute(context);
 
     // 2. Return the hash
     return result.txHash;
   }
 
-  async getTx({ hash }) {
-    const result = await this.runAsLambda((txn) => this.statedb.tx.get(hash, { txn }));
-    if (result) {
-      result.tx.itxJson.data = formatData(result.tx.itxJson.data);
+  getTx({ hash }, ctx) {
+    if (Joi.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 result;
+
+    return null;
   }
 
   getBlock() {
@@ -110,15 +202,15 @@ module.exports = class OCAPResolver {
 
   async getChainInfo() {
     return Promise.resolve({
-      id: md5(this.config.chainId),
+      id: this.chainAddr,
       totalTxs: await this.indexdb.tx.count(),
       blockHash: md5(''),
       blockHeight: 0,
       blockTime: '',
       version: this.config.version,
-      address: md5(this.config.chainId),
+      address: this.chainAddr,
       appHash: md5(new Date().toISOString()),
-      consensusVersion: this.config.version,
+      consensusVersion: this.consensus,
       forgeAppsVersion: [],
       moniker: this.config.chainId,
       network: this.config.chainId,
@@ -130,9 +222,9 @@ module.exports = class OCAPResolver {
 
   getNodeInfo() {
     return Promise.resolve({
-      address: md5(this.config.chainId),
+      address: this.chainAddr,
       appHash: md5(new Date().toISOString()),
-      consensusVersion: `${this.statedb.name} v${this.statedb.version}`,
+      consensusVersion: this.consensus,
       forgeAppsVersion: [],
       geoInfo: {
         city: 'Unknown',
@@ -140,7 +232,7 @@ module.exports = class OCAPResolver {
         latitude: 0,
         longitude: 0,
       },
-      id: md5(this.config.chainId),
+      id: this.chainAddr,
       ip: '',
       moniker: this.config.chainId,
       network: this.config.chainId,
@@ -165,7 +257,7 @@ module.exports = class OCAPResolver {
       blockHeight: 0,
       validators: [
         {
-          address: fromPublicKey(md5(this.config.chainId)),
+          address: fromPublicKey(this.chainAddr),
           name: '',
           proposerPriority: '0',
           votingPower: '10',
@@ -178,25 +270,196 @@ module.exports = class OCAPResolver {
     return JSON.stringify(this.config);
   }
 
-  async getAccountState({ address }) {
-    const account = await this.runAsLambda((txn) => this.statedb.account.get(address, { txn }));
-    if (account) {
-      account.data = formatData(account.data);
+  getAccountState({ address }, ctx) {
+    return this._getState({
+      table: 'account',
+      id: address,
+      dataKey: 'data',
+      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 account;
+
+    return rollup;
   }
 
-  async getAssetState({ address }) {
-    const asset = await this.runAsLambda((txn) => this.statedb.asset.get(address, { txn }));
-    if (asset) {
-      asset.data = formatData(asset.data);
+  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;
     }
-    return asset;
+
+    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;
+      }
+    }
+
+    return state;
+  }
+
+  getDelegateState({ address }, ctx) {
+    return this._getState({ table: 'delegation', id: address, dataKey: 'data', onRead: formatDelegationOps, 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 } = this.config;
     return Promise.resolve({
-      accountConfig: [],
+      accountConfig: accounts,
       address: 'forge_state',
       consensus: {
         maxBytes: '150000',
@@ -207,52 +470,18 @@ module.exports = class OCAPResolver {
         validatorChanged: false,
       },
       data: null,
-      gas: [],
-      protocols: [],
-      stakeSummary: [],
       tasks: [],
-      token: this.config.token,
-      tokenSwapConfig: {
-        commissionHolderAddress: '',
-        commissionRate: 0,
-        maxCommission: null,
-        minCommission: null,
-        revokeCommissionRate: 0,
-      },
+      token,
       txConfig: {
-        minimumStake: '10000000000000000',
-        declare: {
-          cost: 0,
-          hierarchy: 5,
-          restricted: false,
-        },
-        stake: {
-          timeoutGeneral: 86400,
-          timeoutStakeForNode: 604800,
-        },
-        ...this.config.transaction,
+        ...transaction,
+        txFee: Object.keys(transaction.txFee)
+          .filter((x) => x !== 'default')
+          .map((x) => ({ typeUrl: x, fee: fromTokenToUnit(transaction.txFee[x], token.decimal).toString(10) })),
       },
       upgradeInfo: null,
     });
   }
 
-  getSwapState() {
-    return null;
-  }
-
-  async getDelegateState({ address }) {
-    const state = await this.runAsLambda((txn) => this.statedb.delegation.get(address, { txn }));
-    if (state && state.ops) {
-      state.data = formatData(state.data);
-      state.ops = Object.keys(state.ops).reduce((acc, key) => {
-        acc.push({ key, value: state.ops[key] });
-        return acc;
-      }, []);
-    }
-
-    return state;
-  }
-
   async getForgeStats() {
     const [accountCount, assetCount, txCount] = await Promise.all([
       this.indexdb.account.count(),
@@ -284,63 +513,119 @@ module.exports = class OCAPResolver {
     };
   }
 
-  async listTransactions(args) {
-    const txs = await this.indexdb.listTransactions(args);
-    txs.forEach((x) => {
-      x.tx.itxJson.data = formatData(x.tx.itxJson.data);
-    });
-    return txs;
+  listTransactions(args, ctx) {
+    return this._doPaginatedSearch('listTransactions', args, 'transactions', 'tx.itxJson.data', ctx);
   }
 
-  async listAssets(args) {
-    const res = await this.indexdb.listAssets(args);
-    const { assets = [], ...rest } = res;
-    assets.forEach((x) => {
-      x.data = formatData(x.data);
-    });
-
-    return { assets, ...rest };
+  listAssets(args, ctx) {
+    return this._doPaginatedSearch('listAssets', args, 'assets', 'data', ctx);
   }
 
-  listStakes() {
-    return [];
+  listAssetTransactions(args = {}, ctx) {
+    if (!args.address) {
+      return { transactions: [] };
+    }
+
+    return this._doPaginatedSearch(
+      'listTransactions',
+      { ...args, assetFilter: { assets: [args.address] } },
+      'transactions',
+      'tx.itxJson.data',
+      ctx
+    );
   }
 
-  async listAssetTransactions(args) {
-    const txs = await this.indexdb.listAssetTransactions(args);
-    txs.forEach((x) => {
-      x.tx.itxJson.data = formatData(x.tx.itxJson.data);
+  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 txs;
-  }
 
-  listBlocks() {
-    return [];
+    return result;
   }
 
   listTopAccounts(args) {
-    return this.indexdb.listTopAccounts(args);
+    if (!args.tokenAddress) {
+      args.tokenAddress = this.tokenItx.address;
+    }
+
+    return this._doPaginatedSearch('listTopAccounts', args, 'accounts');
   }
 
-  getHealthStatus() {
-    // TODO: implement this
-    return null;
+  listTokens(args, ctx) {
+    return this._doPaginatedSearch('listTokens', args, 'tokens', 'data', ctx);
   }
 
-  listSwap() {
-    return [];
+  listStakes(args, ctx) {
+    return this._doPaginatedSearch('listStakes', args, 'stakes', 'data', ctx);
   }
 
-  getSwapStatistics() {
-    return null;
+  listRollups(args, ctx) {
+    return this._doPaginatedSearch('listRollups', args, 'rollups', 'data', ctx);
   }
 
-  subscribe() {
-    throw new Error('subscribe must be implemented in sub adapter');
+  listRollupBlocks(args, ctx) {
+    return this._doPaginatedSearch('listRollupBlocks', args, 'blocks', 'data', ctx);
   }
 
-  unsubscribe() {
-    throw new Error('unsubscribe must be implemented in sub adapter');
+  async listRollupValidators(args, ctx) {
+    if (!args.rollupAddress) {
+      return { validators: [] };
+    }
+
+    const rollup = await this.runAsLambda((txn) => this.statedb.rollup.get(args.rollupAddress, { txn }));
+    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.runAsLambda((txn) => this.statedb.stake.get(stakeAddress, { txn }));
+        })
+      )
+    ).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;
+  }
+
+  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 (Joi.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'];
+    if (isValidDid(args.keyword)) {
+      const results = await Promise.all(entitiesByDid.map((type) => doSearch(type, args.keyword)));
+      return { results: results.filter(Boolean) };
+    }
+
+    return { results: [] };
+  }
+
+  listBlocks() {
+    return { blocks: [] };
   }
 
   validateTokenConfig() {
@@ -352,96 +637,353 @@ module.exports = class OCAPResolver {
     }
   }
 
+  runAsLambda(fn) {
+    if (typeof this.statedb.runAsLambda === 'function') {
+      return this.statedb.runAsLambda((txn) => fn(txn));
+    }
+
+    return fn();
+  }
+
+  getChain() {
+    return this.runAsLambda((txn) => this.statedb.chain.get(CHAIN_ADDR, { txn }));
+  }
+
+  getToken(id) {
+    return this.runAsLambda((txn) => this.statedb.token.get(id, { txn }));
+  }
+
   async initializeStateDB(txn) {
     const { accounts, token } = this.config;
-    const { account: accountStateDB } = this.statedb;
-    const { account: accountState } = states;
+    const { account: accountDB, chain: chainDB, token: tokenDB } = this.statedb;
+    const { account: accountState, chain: chainState, token: tokenState } = states;
+
+    const ctx = { txn };
+    const context = { txTime: new Date().toISOString(), txHash: '' };
+
+    // Auto persist config to chain state
+    // Will throw error if immutable chain config are updated
+    const info = await this.getChain();
+    if (!info) {
+      const state = chainState.create({ ...this.config, address: CHAIN_ADDR }, context);
+      const result = await chainDB.create(CHAIN_ADDR, state, ctx);
+      debug('create chain state', result);
+    } else if (isEqual(pick(info, Object.keys(this.config)), this.config) === false) {
+      const state = chainState.update(info, this.config, context);
+      const result = await chainDB.update(CHAIN_ADDR, state, ctx);
+      debug('update chain state', result);
+    }
+
+    // Auto persist token state, just once
+    // Since the token info should not be changed after restart
+    if (this.tokenItx) {
+      const existToken = await this.getToken(this.tokenItx.address);
+      if (!existToken) {
+        const state = tokenState.create(this.tokenItx, context);
+        const result = await tokenDB.create(this.tokenItx.address, state, ctx);
+        tokenDB.emit('create', result, ctx);
+        debug('create token state', result);
+      }
+
+      // Auto populate token holder accounts if not exist
+      for (let i = 0; i < accounts.length; i++) {
+        const { address, balance } = accounts[i];
+        try {
+          const existAccount = await accountDB.get(address, ctx);
+          if (!existAccount) {
+            const balanceStr = fromTokenToUnit(balance, token.decimal).toString(10);
+            const state = accountState.create(
+              { address, tokens: { [this.tokenItx.address]: balanceStr }, moniker: 'token-holder' },
+              context
+            );
+            const result = await accountDB.create(address, state, ctx);
+            accountDB.emit('create', result, ctx);
+          }
+        } catch (err) {
+          console.error('Failed to initialize initial token holders', err);
+        }
+      }
+    }
+  }
 
-    const emit = this.executor.emit.bind(this.executor);
+  connectIndexDB() {
+    const getToken = this.getToken.bind(this);
+
+    this.statedb.tx.on('create', async (x, ctx) => {
+      try {
+        const tx = await createIndexedTransaction(x, ctx);
+        await this.indexdb.tx.insert(tx);
+        if (typeof hooks.onCreateTx === 'function') {
+          await hooks.onCreateTx(tx, ctx, this.indexdb);
+        }
+      } catch (error) {
+        console.error('create tx index failed', { account: x, error });
+      }
+    });
 
-    // Auto populate token holder accounts if not exist
-    for (let i = 0; i < accounts.length; i++) {
-      const { address, balance } = accounts[i];
+    this.statedb.account.on('create', async (x) => {
       try {
-        const exist = await accountStateDB.get(address);
-        if (!exist) {
-          const balanceStr = fromTokenToUnit(balance, token.decimal).toString(10);
-          const context = { txTime: new Date().toISOString(), txHash: '', emit };
-          const state = accountState.create({ address, balance: balanceStr, moniker: 'token-holder' }, context);
-          await accountStateDB.create(address, state, { txn });
+        await this.indexdb.account.insert(await createIndexedAccount(x, getToken));
+      } catch (error) {
+        console.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) {
+        console.error('update account index failed', { account: x, error });
+      }
+    });
+
+    const mapping = {
+      asset: [createIndexedAsset, 'address'],
+      delegation: [createIndexedDelegation, 'address'],
+      token: [createIndexedToken, 'address'],
+      factory: [createIndexedFactory, 'address'],
+      stake: [createIndexedStake, 'address'],
+      rollup: [createIndexedRollup, 'address', hooks.onCreateRollup],
+      rollupBlock: [createIndexedRollupBlock, 'hash', hooks.onCreateRollupBlock],
+    };
+    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);
+          await this.indexdb[table].insert(doc);
+          if (typeof onCreate === 'function') {
+            await onCreate(doc, ctx, this.indexdb);
+          }
+        } catch (error) {
+          console.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);
+          await this.indexdb[table].update(doc[key], doc);
+          if (typeof onUpdate === 'function') {
+            await onUpdate(doc, ctx, this.indexdb);
+          }
+        } catch (error) {
+          console.error(`update ${table} index failed`, { [table]: x, error });
+        }
+      });
+    });
+  }
+
+  async _getState({ table, id, dataKey, onRead = noop, expandContext = true, ctx }) {
+    if (!id) {
+      throw new CustomError('INVALID_REQUEST', `Missing required parameter to read ${table} state`);
+    }
+
+    const state = await this.runAsLambda((txn) => this.statedb[table].get(id, { txn }));
+    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 };
         }
-      } catch (err) {
-        // Do nothing
       }
     }
+
+    return onRead(state);
   }
 
-  runAsLambda(fn) {
-    if (typeof this.statedb.runAsLambda === 'function') {
-      return new Promise((resolve, reject) => this.statedb.runAsLambda((txn) => fn(txn).then(resolve).catch(reject)));
+  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 = set(x, dataKey, formatData(get(x, dataKey)));
+          if (listKey === 'transactions') {
+            tx = await this.formatTx(tx, ctx);
+          }
+
+          return tx;
+        })
+      );
     }
 
-    return fn();
+    const final = { [listKey]: data, ...rest };
+    if (!final.paging) {
+      final.paging = { cursor: '0', next: false, total: 0 };
+    }
+
+    return final;
   }
 
-  connectIndexDB() {
-    const { account, asset, delegation, tx } = this.indexdb;
-    this.executor.on('tx.create', (x, ctx) => tx.insert(x, ctx));
-    this.executor.on('account.create', (x, ctx) => account.insert(this.createIndexedAccount(x), ctx));
-    this.executor.on('account.update', (x, ctx) => account.update(x.address, this.createIndexedAccount(x), ctx));
-    this.executor.on('asset.create', (x, ctx) => asset.insert(this.createIndexedAsset(x), ctx));
-    this.executor.on('asset.update', (x, ctx) => asset.update(x.address, this.createIndexedAsset(x), ctx));
-    this.executor.on('delegation.create', (x, ctx) => delegation.insert(this.createIndexedDelegation(x, ctx), ctx));
-    this.executor.on('delegation.update', (x, ctx) => delegation.update(x.address, x, ctx));
+  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 });
+    }
+
+    // https://github.com/blocklet/abt-wallet/issues/681
+    if (get(tx, 'tx.itxJson.type_url') === 'fg:t:deposit_token') {
+      tx.receipts = getTxReceipts(tx, { config: this.config });
+    }
+
+    tx.receipts = mergeTxReceipts(tx.receipts);
+    tx.tokenSymbols = await this.getTxTokenSymbols(tx);
+
+    this.fixReceiptTokens(tx, ctx);
+    this.fixTokenSymbols(tx, ctx);
+
+    return tx;
   }
 
-  createIndexedAccount(x) {
-    return {
-      address: x.address,
-      balance: x.balance,
-      genesisTime: x.context.genesisTime,
-      migratedFrom: x.migratedFrom[0] || '',
-      migratedTo: x.migratedTo[0] || '',
-      moniker: x.moniker,
-      nonce: x.nonce,
-      numAssets: x.numAssets,
-      numTxs: x.numTxs,
-      recentNumTxs: [],
-      renaissanceTime: x.context.renaissanceTime,
-      totalReceivedStakes: '0',
-      totalStakes: '0',
-      totalUnstakes: '0',
-    };
+  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) }));
   }
 
-  createIndexedAsset(x) {
-    return {
-      address: x.address,
-      consumedTime: x.consumedTime,
-      data: x.data,
-      genesisTime: x.context.genesisTime,
-      issuer: x.issuer,
-      moniker: x.moniker,
-      owner: x.owner,
-      parent: x.parent,
-      readonly: x.readonly,
-      renaissanceTime: x.context.renaissanceTime,
-      transferrable: x.transferrable,
-      ttl: x.ttl,
-    };
+  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),
+    }));
   }
 
-  createIndexedDelegation(x, ctx) {
-    return {
-      address: x.address,
-      data: x.data,
-      genesisTime: x.context.genesisTime,
-      renaissanceTime: x.context.renaissanceTime,
-      ops: x.ops,
-      from: get(ctx, 'senderState.address', ''),
-      to: get(ctx, 'receiverState.address', ''),
-    };
+  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 (typeUrl === 'RevokeStakeTx') {
+      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);
+      tokens.push(
+        ...uniqBy(
+          revokeTx.tx.itxJson.outputs.reduce((acc, x) => acc.concat(x.tokens), []),
+          'address'
+        ).filter((x) => x.address)
+      );
+    } 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])];
+    }
+
+    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)) {
+      ctx.tokenStates.push(this.tokenItx);
+    } else if (ctx.tokenState) {
+      ctx.tokenStates = [ctx.tokenState];
+    }
+
+    return ctx;
   }
 };
 
 module.exports.formatData = formatData;
+module.exports.formatDelegationOps = formatDelegationOps;