@ocap/indexdb 1.6.3 → 1.6.10

package/lib/db.js

@@ -1,15 +1,57 @@
+/* eslint-disable no-unused-vars */
 const Ready = require('@ocap/util/lib/ready');
+const { indexes } = require('@ocap/state');
 
 class BaseIndexDB extends Ready {
   constructor() {
     super();
 
-    this.readyMarks = {
-      account: false,
-      asset: false,
-      delegation: false,
-      tx: false,
-    };
+    this.readyMarks = indexes.reduce((acc, x) => ({ ...acc, [x]: false }), {});
+    this.readyListenersAttached = false;
+  }
+
+  attachReadyListeners() {
+    if (this.readyListenersAttached) {
+      return;
+    }
+
+    for (const index of indexes) {
+      if (typeof this[index] === 'undefined') {
+        throw new Error(`Missing index ${index} in indexdb adapter: ${this.name}`);
+      }
+
+      this[index].onReady(() => this.markReady(index));
+    }
+
+    this.readyListenersAttached = true;
+  }
+
+  listTransactions({ addressFilter = {}, paging = {}, timeFilter = {}, typeFilter = {} } = {}) {
+    throw new Error('listTransactions should be implemented in adapter');
+  }
+
+  listAssets({ ownerAddress, paging } = {}) {
+    throw new Error('listAssets should be implemented in adapter');
+  }
+
+  listFactories({ ownerAddress, paging } = {}) {
+    throw new Error('listFactories should be implemented in adapter');
+  }
+
+  listTopAccounts({ paging, tokenAddress } = {}) {
+    throw new Error('listTopAccounts should be implemented in adapter');
+  }
+
+  listTokens({ paging }) {
+    throw new Error('listTokens should be implemented in adapter');
+  }
+
+  listStakes({ paging = {}, addressFilter = {}, timeFilter = {}, assetFilter = {} } = {}) {
+    throw new Error('listStakes should be implemented in adapter');
+  }
+
+  listBlocks() {
+    return [];
   }
 }
 

package/lib/index.js

@@ -1,5 +1,6 @@
 /* eslint-disable no-underscore-dangle */
 const Kareem = require('kareem');
+const omit = require('lodash/omit');
 const Ready = require('@ocap/util/lib/ready');
 
 class BaseIndex extends Ready {
@@ -21,6 +22,11 @@ class BaseIndex extends Ready {
           hooks.execPreSync(x, args);
           const result = await this[`_${x}`](...args);
           hooks.execPostSync(x, result);
+
+          if (['insert', 'update'].includes(x)) {
+            this.emit(x, omit(result, '$loki'));
+          }
+
           return result;
         },
       });

package/lib/util.js

@@ -0,0 +1,514 @@
+/* eslint-disable no-restricted-globals */
+const get = require('lodash/get');
+const uniq = require('lodash/uniq');
+const pick = require('lodash/pick');
+const createSortedList = require('@ocap/util/lib/create-sorted-list');
+const { BN } = require('@ocap/util');
+
+const formatTokenMeta = (token, tokenStates) => {
+  if (!tokenStates) {
+    return token;
+  }
+
+  const tokenState = tokenStates.find((x) => x.address === token.address);
+  token.decimal = tokenState.decimal;
+  token.unit = tokenState.unit;
+  token.symbol = tokenState.symbol;
+
+  return token;
+};
+
+const createIndexedAccount = async (x, getTokenFn) => {
+  const tasks = Object.keys(x.tokens || {}).map((address) => getTokenFn(address));
+  const tokenStates = await Promise.all(tasks);
+
+  return {
+    address: x.address,
+    balance: x.balance || '0',
+    moniker: x.moniker,
+    nonce: x.nonce,
+    numAssets: x.numAssets || 0,
+    numTxs: x.numTxs || 0,
+    recentNumTxs: [],
+    renaissanceTime: x.context.renaissanceTime,
+    tokens: Object.keys(x.tokens || {}).map((address) =>
+      formatTokenMeta({ address, balance: x.tokens[address] }, tokenStates)
+    ), // eslint-disable-line function-paren-newline
+    genesisTime: x.context.genesisTime,
+    migratedTo: x.migratedTo[0] || '',
+    migratedFrom: x.migratedFrom[0] || '',
+  };
+};
+
+const createIndexedAsset = (x) => ({
+  address: x.address,
+  issuer: x.issuer,
+  moniker: x.moniker,
+  owner: x.owner,
+  parent: x.parent,
+  readonly: x.readonly,
+  transferrable: x.transferrable,
+  ttl: x.ttl,
+  consumedTime: x.consumedTime,
+  genesisTime: x.context.genesisTime,
+  renaissanceTime: x.context.renaissanceTime,
+  data: x.data,
+  display: x.display,
+  endpoint: x.endpoint,
+  tags: x.tags,
+});
+
+const createIndexedDelegation = (x, ctx) => ({
+  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', ''),
+});
+
+const createIndexedToken = (x) => ({
+  address: x.address,
+  issuer: x.issuer,
+  name: x.name,
+  description: x.description,
+  symbol: x.symbol,
+  unit: x.unit,
+  decimal: x.decimal,
+  icon: x.icon,
+  totalSupply: x.totalSupply,
+  initialSupply: x.initialSupply,
+  foreignToken: x.foreignToken,
+  data: x.data,
+  genesisTime: x.context.genesisTime,
+  renaissanceTime: x.context.renaissanceTime,
+});
+
+const createIndexedFactory = async (factory, context) => {
+  if (context.factoryTokens && context.factoryTokens.length > 0) {
+    factory.input.tokens = factory.input.tokens.map((token) => formatTokenMeta(token, context.tokenStates));
+  }
+  return {
+    ...pick(factory, [
+      'address',
+      'owner',
+      'name',
+      'description',
+      'settlement',
+      'limit',
+      'trustedIssuers',
+      'input',
+      'output',
+      'hooks',
+      'data',
+      'numMinted',
+      'lastSettlement',
+      'balance',
+      'display',
+    ]),
+    tokens: Object.keys(factory.tokens || {}).map((address) =>
+      formatTokenMeta({ address, balance: factory.tokens[address] }, context.tokenStates)
+    ), // eslint-disable-line function-paren-newline
+    genesisTime: factory.context.genesisTime,
+    renaissanceTime: factory.context.renaissanceTime,
+  };
+};
+
+// These fields are used internally to filter transactions by some entity
+const createIndexedTransaction = (tx, ctx) => {
+  tx.accounts = [tx.tx.from, tx.sender, tx.receiver];
+  tx.assets = [];
+  tx.tokens = [];
+  tx.factories = [];
+  tx.stakes = [];
+  tx.rollups = [];
+
+  tx.valid = tx.code === 'OK';
+
+  // accounts
+  if (ctx.senderState) {
+    tx.accounts.push(ctx.senderState.address);
+  }
+  if (ctx.receiverState) {
+    tx.accounts.push(ctx.receiverState.address);
+  }
+  if (ctx.vaultState) {
+    tx.accounts.push(ctx.vaultState.address);
+  }
+  if (ctx.updatedAccounts && Array.isArray(ctx.updatedAccounts)) {
+    tx.accounts.push(...ctx.updatedAccounts.map((x) => x.address));
+  }
+  if (ctx.delegatorState) {
+    tx.accounts.push(ctx.delegatorState.address);
+  }
+  if (Array.isArray(ctx.delegatorStates)) {
+    tx.accounts.push(...ctx.delegatorStates.map((x) => x.address));
+  }
+  if (Array.isArray(ctx.signerStates)) {
+    tx.accounts.push(...ctx.signerStates.map((x) => x.address));
+  }
+  if (Array.isArray(ctx.receiverStates)) {
+    tx.accounts.push(...ctx.receiverStates.map((x) => x.address));
+  }
+
+  // assets
+  if (ctx.assetState) {
+    tx.assets.push(ctx.assetState.address);
+  }
+  if (ctx.assetStates && Array.isArray(ctx.assetStates)) {
+    tx.assets.push(...ctx.assetStates.map((x) => x.address));
+  }
+
+  // tokens
+  if (ctx.tokenState) {
+    tx.tokens.push(ctx.tokenState.address);
+  }
+  if (ctx.tokenStates && Array.isArray(ctx.tokenStates)) {
+    tx.tokens.push(...ctx.tokenStates.map((x) => x.address));
+  }
+
+  // factories
+  if (ctx.factoryState) {
+    tx.factories.push(ctx.factoryState.address);
+  }
+
+  // stakes
+  if (ctx.stakeState) {
+    tx.stakes.push(ctx.stakeState.address);
+  }
+  if (Array.isArray(ctx.stakeStates)) {
+    tx.stakes.push(...ctx.stakeStates.map((x) => x.address));
+  }
+
+  // rollups
+  if (ctx.rollupState) {
+    tx.rollups.push(ctx.rollupState.address);
+  }
+
+  const pickedFields = ['address', 'symbol', 'decimal', 'unit'];
+  if (Array.isArray(ctx.tokenStates)) {
+    tx.tokenSymbols = ctx.tokenStates.map((t) => pick(t, pickedFields));
+  } else if (ctx.tokenState) {
+    tx.tokenSymbols = [pick(ctx.tokenState, pickedFields)];
+  } else {
+    tx.tokenSymbols = [];
+  }
+
+  tx.accounts = [...tx.accounts, ...tx.stakes];
+
+  return tx;
+};
+
+const createIndexedStake = async (x, ctx) => {
+  return {
+    ...pick(x, [
+      'address',
+      'sender',
+      'receiver',
+      'assets',
+      'revocable',
+      'data',
+      'message',
+      'revokeWaitingPeriod',
+      'revokedAssets',
+    ]),
+    tokens: Object.keys(x.tokens || {}).map((address) =>
+      formatTokenMeta({ address, balance: x.tokens[address] }, ctx.tokenStates)
+    ),
+    revokedTokens: Object.keys(x.revokedTokens || {}).map((address) =>
+      formatTokenMeta({ address, balance: x.revokedTokens[address] }, ctx.tokenStates)
+    ),
+    genesisTime: x.context.genesisTime,
+    renaissanceTime: x.context.renaissanceTime,
+  };
+};
+
+const createIndexedRollup = async (x, ctx) => {
+  const rollup = {
+    ...pick(x, [
+      'address',
+      'paused',
+      'tokenAddress',
+      'contractAddress',
+      'seedValidators',
+      'validators',
+      'minStakeAmount',
+      'maxStakeAmount',
+      'minSignerCount',
+      'maxSignerCount',
+      'minBlockSize',
+      'maxBlockSize',
+      'minBlockInterval',
+      'minBlockConfirmation',
+      'minDepositAmount',
+      'maxDepositAmount',
+      'minWithdrawAmount',
+      'maxWithdrawAmount',
+      'depositFeeRate',
+      'withdrawFeeRate',
+      'proposerFeeShare',
+      'publisherFeeShare',
+      'minDepositFee',
+      'maxDepositFee',
+      'minWithdrawFee',
+      'maxWithdrawFee',
+      'issuer',
+      'blockHeight',
+      'blockHash',
+      'leaveWaitingPeriod',
+      'publishWaitingPeriod',
+      'publishSlashRate',
+      'migrateHistory',
+      'data',
+    ]),
+    genesisTime: x.context.genesisTime,
+    renaissanceTime: x.context.renaissanceTime,
+  };
+
+  if (ctx.tokenStates) {
+    const tokenState = ctx.tokenStates.find((t) => t.address === x.tokenAddress);
+    rollup.tokenInfo = formatTokenMeta({ address: x.tokenAddress, value: '0' }, ctx.tokenStates);
+    rollup.foreignToken = tokenState.foreignToken;
+  }
+
+  return rollup;
+};
+
+const createIndexedRollupBlock = async (x, ctx) => {
+  return {
+    ...pick(x, [
+      'hash',
+      'height',
+      'merkleRoot',
+      'previousHash',
+      'txsHash',
+      'txs',
+      'proposer',
+      'signatures',
+      'rollup',
+      'mintedAmount',
+      'burnedAmount',
+      'rewardAmount',
+      'minReward',
+      'data',
+    ]),
+    genesisTime: x.context.genesisTime,
+    renaissanceTime: x.context.renaissanceTime,
+    tokenInfo: formatTokenMeta({ address: ctx.rollupState.tokenAddress, value: '0' }, ctx.tokenStates),
+    validators: (x.signaturesList || x.signatures || []).map((v) => v.signer),
+  };
+};
+
+const formatTxBeforeInsert = (row) => {
+  const tx = { ...row };
+  tx.sender = tx.sender || '';
+  tx.receiver = tx.receiver || '';
+
+  // index assets
+  tx.assets = tx.assets || [];
+  if (['transfer', 'transfer_v2'].includes(tx.type) && tx.tx.itxJson.assets) {
+    tx.assets.push(...tx.tx.itxJson.assets);
+  } else if (['transfer_v3', 'stake'].includes(tx.type)) {
+    tx.assets.push(...createSortedList(tx.tx.itxJson.inputs.map((x) => x.assets)));
+  } else if (['revoke_stake'].includes(tx.type)) {
+    tx.assets.push(...createSortedList(tx.tx.itxJson.outputs.map((x) => x.assets)));
+  } else if (['exchange', 'exchange_v2'].includes(tx.type)) {
+    tx.assets.push(...(tx.tx.itxJson.sender.assets || []), ...(tx.tx.itxJson.receiver.assets || []));
+  } else if (['create_asset', 'update_asset', 'acquire_asset_v2', 'mint_asset'].includes(tx.type)) {
+    tx.assets.push(tx.tx.itxJson.address);
+  }
+
+  // index factories
+  tx.factories = tx.factories || [];
+  if (['acquire_asset_v2', 'acquire_asset_v3', 'mint_asset', 'create_factory'].includes(tx.type)) {
+    tx.factories.push(tx.tx.itxJson.factory);
+  }
+
+  // index tokens
+  tx.tokens = tx.tokens || [];
+  if (tx.type === 'transfer_v2' && tx.tx.itxJson.tokens) {
+    tx.tokens.push(...tx.tx.itxJson.tokens.map((x) => x.address));
+  } else if (['transfer_v3', 'stake'].includes(tx.type)) {
+    tx.tokens.push(...createSortedList(tx.tx.itxJson.inputs.map((x) => x.tokens.map((t) => t.address))));
+  } else if (['revoke_stake'].includes(tx.type)) {
+    tx.tokens.push(...createSortedList(tx.tx.itxJson.outputs.map((x) => x.tokens.map((t) => t.address))));
+  } else if (tx.type === 'exchange_v2') {
+    tx.tokens.push(
+      ...(tx.tx.itxJson.sender.tokens || []).map((x) => x.address),
+      ...(tx.tx.itxJson.receiver.tokens || []).map((x) => x.address)
+    );
+  }
+
+  tx.accounts = tx.accounts || [];
+  tx.stakes = tx.stakes || [];
+
+  tx.assets = uniq(tx.assets).filter(Boolean);
+  tx.factories = uniq(tx.factories).filter(Boolean);
+  tx.tokens = uniq(tx.tokens).filter(Boolean);
+  tx.accounts = uniq(tx.accounts).filter(Boolean);
+  tx.stakes = uniq(tx.stakes).filter(Boolean);
+  tx.rollups = uniq(tx.rollups).filter(Boolean);
+
+  return tx;
+};
+
+const formatTxAfterRead = (tx) => {
+  delete tx.assets;
+  delete tx.factories;
+  delete tx.tokens;
+  delete tx.accounts;
+  delete tx.stakes;
+  delete tx.rollups;
+
+  return tx;
+};
+
+const parseDateTime = (str) => {
+  if (!str) {
+    return '';
+  }
+
+  const parsed = Date.parse(str);
+  if (isNaN(parsed)) {
+    return '';
+  }
+
+  return new Date(parsed).toISOString();
+};
+
+const PAGE_SIZE_DEFAULT = 20;
+const PAGE_SIZE_MAX = 100;
+
+const formatPagination = ({ paging, defaultSortField, supportedSortFields = [] }) => {
+  if (!defaultSortField) {
+    throw new Error('argument defaultSortField is required');
+  }
+
+  const pagination = paging || { size: PAGE_SIZE_DEFAULT };
+  if (Array.isArray(pagination.order)) {
+    [pagination.order] = pagination.order;
+  }
+
+  if (!pagination.order) {
+    pagination.order = { field: defaultSortField, type: 'desc' };
+  }
+
+  if (!pagination.order.field) {
+    pagination.order.field = defaultSortField;
+  }
+
+  if (supportedSortFields.length > 0 && !supportedSortFields.includes(pagination.order.field)) {
+    pagination.order.field = defaultSortField;
+  }
+
+  if (!pagination.order.type) {
+    pagination.order.type = 'desc';
+  }
+
+  if (pagination.size === null || typeof pagination.size === 'undefined') {
+    pagination.size = PAGE_SIZE_DEFAULT;
+  }
+
+  // Since Elasticsearch does not support cursor based pagination, we just use offset as cursor
+  if (pagination.cursor) {
+    pagination.cursor = Number(pagination.cursor);
+  } else {
+    pagination.cursor = 0;
+  }
+
+  pagination.size = Math.min(pagination.size, PAGE_SIZE_MAX);
+
+  return pagination;
+};
+
+const formatNextPagination = (total, pagination) => {
+  const nextCursor = pagination.cursor + pagination.size;
+  if (total > nextCursor) {
+    return { cursor: nextCursor, next: true, total };
+  }
+
+  return { cursor: '0', next: false, total };
+};
+
+const isDefaultTokenChanged = (tx, token) => {
+  const itx = tx.tx.itxJson;
+  if (
+    [
+      'fg:t:transfer',
+      'fg:t:transfer_v2',
+      'fg:t:transfer_v3',
+      'fg:t:acquire_asset_v2',
+      'fg:t:acquire_asset_v3',
+      'fg:t:exchange',
+      'fg:t:exchange_v2',
+      'fg:t:deposit_token',
+      'fg:t:withdraw_token',
+      'fg:t:faucet',
+      'fg:t:poke',
+      'fg:t:setup_swap',
+      'fg:t:retrieve_swap',
+      'fg:t:stake',
+      'fg:t:revoke_stake',
+    ].includes(itx.type_url) === false
+  ) {
+    return false;
+  }
+
+  const ZERO = new BN(0);
+  const isDefaultToken = (id) => [token.address, ''].includes(id);
+  const isPositive = (v) => new BN(v || 0).gt(ZERO);
+  const isChangedByInput = (input) =>
+    isPositive(input.value) || input.tokens.some((x) => isDefaultToken(x.address) && isPositive(x.value));
+
+  switch (itx.type_url) {
+    case 'fg:t:transfer':
+      return isPositive(itx.value);
+    case 'fg:t:transfer_v2':
+      return isChangedByInput(itx);
+    case 'fg:t:transfer_v3':
+    case 'fg:t:acquire_asset_v3':
+      return itx.inputs.some(isChangedByInput);
+    case 'fg:t:acquire_asset_v2':
+      return tx.receipts.some((r) => r.changes.some((c) => isDefaultToken(c.target) && isPositive(c.value)));
+    case 'fg:t:exchange':
+      return isPositive(itx.sender.value) || isPositive(itx.receiver.value);
+    case 'fg:t:exchange_v2':
+      return isChangedByInput(itx.sender) || isChangedByInput(itx.receiver);
+    case 'fg:t:deposit_token':
+    case 'fg:t:withdraw_token':
+      return isPositive(itx.value);
+    case 'fg:t:setup_swap':
+    case 'fg:t:retrieve_swap':
+      return isPositive(itx.value);
+    case 'fg:t:poke':
+      return true;
+    case 'fg:t:faucet':
+      return !itx.token;
+    case 'fg:t:stake':
+      return itx.inputs.some(isChangedByInput);
+    case 'fg:t:revoke_stake':
+      return itx.outputs.some(isChangedByInput);
+    default:
+      return false;
+  }
+};
+
+module.exports = {
+  createIndexedAccount,
+  createIndexedAsset,
+  createIndexedFactory,
+  createIndexedDelegation,
+  createIndexedToken,
+  createIndexedTransaction,
+  createIndexedStake,
+  createIndexedRollup,
+  createIndexedRollupBlock,
+  formatPagination,
+  formatNextPagination,
+  formatTxAfterRead,
+  formatTxBeforeInsert,
+  parseDateTime,
+  formatTokenMeta,
+  isDefaultTokenChanged,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.3",
+  "version": "1.6.10",
   "description": "Defines the basic interface for OCAP IndexDB",
   "main": "lib/main.js",
   "files": [
@@ -12,18 +12,23 @@
   "scripts": {
     "lint": "eslint tests lib",
     "lint:fix": "eslint --fix tests lib",
-    "test": "node tools/jest.js",
+    "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
+  "contributors": [
+    "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
+  ],
   "license": "MIT",
   "devDependencies": {
-    "jest": "^26.6.3"
+    "jest": "^27.3.1"
   },
   "dependencies": {
-    "@ocap/util": "^1.6.3",
-    "kareem": "^2.3.2"
+    "@ocap/state": "1.6.10",
+    "@ocap/util": "1.6.10",
+    "kareem": "^2.3.2",
+    "lodash": "^4.17.21"
   },
-  "gitHead": "5246168dbbc268a3e6f95c3992d9d343647ca25b"
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
 }