@ocap/indexdb 1.28.8 → 1.29.0

package/lib/util.js

@@ -1,634 +0,0 @@
-const get = require('lodash/get');
-const uniq = require('lodash/uniq');
-const pick = require('lodash/pick');
-const uniqBy = require('lodash/uniqBy');
-const { createSortedList } = require('@ocap/util/lib/create-sorted-list');
-const { BN } = require('@ocap/util');
-
-const formatTokenMeta = (token, tokenStates, ...rest) => {
-  if (!tokenStates) {
-    return token;
-  }
-
-  const tokenState = tokenStates.filter(Boolean).find((x) => x.address === token.address);
-  if (tokenState) {
-    token.decimal = tokenState.decimal;
-    token.unit = tokenState.unit;
-    token.symbol = tokenState.symbol;
-    token.icon = tokenState.icon;
-  } else {
-    console.warn('Invalid token state on formatting', token, tokenStates, ...rest);
-  }
-
-  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)
-    ),
-    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) => {
-  const result = {
-    address: x.address,
-    data: x.data,
-    genesisTime: x.context.genesisTime,
-    renaissanceTime: x.context.renaissanceTime,
-    // https://discuss.elastic.co/t/updating-an-object-field/110735
-    ops: [x.ops],
-  };
-  if (x.from) {
-    result.from = x.from;
-  } else if (ctx.senderState) {
-    result.from = get(ctx, 'senderState.address', '');
-  } else {
-    result.from = get(ctx, 'tx.from', '');
-  }
-  if (x.to) {
-    result.to = x.to;
-  } else if (ctx.receiverState) {
-    result.to = get(ctx, 'receiverState.address', '');
-  } else {
-    result.to = get(ctx, 'itx.to', '');
-  }
-  return result;
-};
-
-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,
-  website: x.website,
-  totalSupply: x.totalSupply,
-  initialSupply: x.initialSupply,
-  maxTotalSupply: x.maxTotalSupply,
-  foreignToken: x.foreignToken,
-  tokenFactoryAddress: x.tokenFactoryAddress,
-  metadata: x.metadata,
-  spenders: x.spenders,
-  minters: x.minters,
-  type: x.type,
-  data: x.data,
-  genesisTime: x.context.genesisTime,
-  renaissanceTime: x.context.renaissanceTime,
-});
-
-const createIndexedTokenFactory = (tokenFactory, context) => {
-  return {
-    ...pick(tokenFactory, [
-      'address',
-      'owner',
-      'tokenAddress',
-      'reserveAddress',
-      'curve',
-      'feeRate',
-      'currentSupply',
-      'reserveBalance',
-      'status',
-      'data',
-    ]),
-    token: formatTokenMeta({ address: tokenFactory.tokenAddress }, [context.itx.token]),
-    reserveToken: formatTokenMeta({ address: tokenFactory.reserveAddress }, [context.config.token]),
-    genesisTime: tokenFactory.context.genesisTime,
-    renaissanceTime: tokenFactory.context.renaissanceTime,
-  };
-};
-
-const createIndexedFactory = (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)
-    ),
-    genesisTime: factory.context.genesisTime,
-    renaissanceTime: factory.context.renaissanceTime,
-  };
-};
-
-// These fields are used internally to filter transactions by some entity
-const createIndexedTransaction = async (tx, ctx, indexdb) => {
-  tx.accounts = [tx.tx.from, tx.sender, tx.receiver];
-  tx.assets = [];
-  tx.tokens = [];
-  tx.factories = [];
-  tx.stakes = [];
-  tx.rollups = [];
-  tx.delegations = [];
-  tx.tokenFactories = [];
-
-  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.feeVaultState && ctx.feeVaultChange) {
-    tx.accounts.push(ctx.feeVaultState.address);
-  }
-  if (ctx.gasVaultState && ctx.gasVaultChange) {
-    tx.accounts.push(ctx.gasVaultState.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 (ctx.delegationState) {
-    tx.delegations.push(ctx.delegationState.address);
-  }
-  if (ctx.delegationState && ctx.txType === 'fg:t:revoke_delegate') {
-    const indexed = await indexdb.delegation.get(ctx.delegationState.address);
-    if (indexed) {
-      tx.accounts.push(indexed.to);
-    }
-  }
-  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);
-    // index update asset for owners, so that wallet can sync this tx
-    if (ctx.txType === 'fg:t:update_asset') {
-      tx.accounts.push(ctx.assetState.owner);
-    }
-    if (ctx.txType === 'fg:t:mint_asset') {
-      tx.accounts.push(ctx.ownerAddress);
-    }
-  }
-  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 (ctx.txType === 'fg:t:slash_stake') {
-      tx.accounts.push(ctx.stakeState.sender);
-    }
-    if (ctx.txType === 'fg:t:return_stake') {
-      tx.accounts.push(ctx.stakeState.sender);
-    }
-  }
-  if (Array.isArray(ctx.stakeStates)) {
-    tx.stakes.push(...ctx.stakeStates.map((x) => x.address));
-  }
-
-  // rollups
-  if (ctx.rollupState) {
-    tx.rollups.push(ctx.rollupState.address);
-  }
-
-  // token factories
-  if (ctx.tokenFactoryState) {
-    tx.tokenFactories.push(ctx.tokenFactoryState.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, indexdb) => {
-  const tokens = uniq(Object.keys(x.tokens || {}).concat(Object.keys(x.revokedTokens || {})));
-  const existTokenStates = ctx.tokenStates || [];
-  const missingTokenStates = await Promise.all(
-    tokens.filter((a) => !existTokenStates.find((t) => t.address === a)).map((t) => indexdb.token.get(t))
-  );
-  const tokenStates = [...existTokenStates, ...missingTokenStates];
-  return {
-    ...pick(x, [
-      'address',
-      'sender',
-      'receiver',
-      'assets',
-      'slashers',
-      'revocable',
-      'data',
-      'nonce',
-      'message',
-      'revokeWaitingPeriod',
-      'revokedAssets',
-    ]),
-    tokens: Object.keys(x.tokens || {}).map((address) =>
-      formatTokenMeta({ address, balance: x.tokens[address] }, tokenStates, x)
-    ),
-    revokedTokens: Object.keys(x.revokedTokens || {}).map((address) =>
-      formatTokenMeta({ address, balance: x.revokedTokens[address] }, tokenStates)
-    ),
-    genesisTime: x.context.genesisTime,
-    renaissanceTime: x.context.renaissanceTime,
-  };
-};
-
-const createIndexedRollup = (x, ctx) => {
-  const rollup = {
-    ...pick(x, [
-      'address',
-      'paused',
-      'closed',
-      'tokenAddress',
-      'vaultAddress',
-      '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',
-      'vaultHistory',
-      '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 = (x, ctx) => {
-  return {
-    ...pick(x, [
-      'hash',
-      'height',
-      'merkleRoot',
-      'previousHash',
-      'txsHash',
-      'txs',
-      'proposer',
-      'signatures',
-      'rollup',
-      'mintedAmount',
-      'burnedAmount',
-      'rewardAmount',
-      'minReward',
-      'governance',
-      '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 createIndexedTokenDistribution = (x) => {
-  return {
-    ...pick(x, 'tokenAddress', 'txTime'),
-    account: x.account.toString(),
-    gas: x.gas.toString(),
-    fee: x.fee.toString(),
-    slashedVault: x.slashedVault.toString(),
-    stake: x.stake.toString(),
-    revokedStake: x.revokedStake.toString(),
-    gasStake: x.gasStake.toString(),
-  };
-};
-
-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', 'slash_stake', 'return_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', 'slash_stake', 'return_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);
-  tx.tokenSymbols = uniqBy(tx.tokenSymbols, 'address');
-
-  return tx;
-};
-
-const formatTxAfterRead = (tx) => {
-  delete tx.assets;
-  delete tx.factories;
-  delete tx.tokens;
-  delete tx.accounts;
-  delete tx.stakes;
-  delete tx.rollups;
-  delete tx.delegations;
-
-  return tx;
-};
-
-const formatDelegationAfterRead = (delegation) => {
-  // https://discuss.elastic.co/t/updating-an-object-field/110735
-  const ops = Array.isArray(delegation.ops) ? delegation.ops[0] : delegation.ops;
-  delegation.ops = Object.keys(ops).map((x) => ({ key: x, value: ops[x] }));
-  return delegation;
-};
-
-const parseDateTime = (str) => {
-  if (!str) {
-    return '';
-  }
-
-  const parsed = Date.parse(str);
-  if (Number.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':
-    case 'fg:t:slash_stake':
-    case 'fg:t:return_stake':
-      return itx.outputs.some(isChangedByInput);
-    default:
-      return false;
-  }
-};
-
-module.exports = {
-  createIndexedAccount,
-  createIndexedAsset,
-  createIndexedFactory,
-  createIndexedTokenFactory,
-  createIndexedDelegation,
-  createIndexedToken,
-  createIndexedTransaction,
-  createIndexedStake,
-  createIndexedRollup,
-  createIndexedRollupBlock,
-  createIndexedTokenDistribution,
-  formatPagination,
-  formatNextPagination,
-  formatTxAfterRead,
-  formatTxBeforeInsert,
-  parseDateTime,
-  formatTokenMeta,
-  isDefaultTokenChanged,
-  formatDelegationAfterRead,
-};