@ocap/resolver 1.6.5 → 1.6.10

package/lib/hooks.js

@@ -0,0 +1,308 @@
+/* eslint-disable consistent-return */
+// Purpose of these hooks: update indexdb to speed up subsequent queries
+// RULE: do not try to update statedb in these hooks
+
+const merge = require('lodash/merge');
+const pick = require('lodash/pick');
+const { BN } = require('@ocap/util');
+const { toStakeAddress } = require('@arcblock/did-util');
+
+const debug = require('debug')(require('../package.json').name);
+
+const onCreateRollup = async (rollup, ctx, indexdb) => {
+  rollup.seedValidators.forEach(async (x) => {
+    const { pk, address, endpoint } = x;
+    try {
+      const account = await indexdb.account.get(address);
+
+      await indexdb.rollupValidator.insert({
+        rollup: rollup.address,
+
+        pk,
+        address,
+        endpoint,
+        moniker: account.moniker,
+
+        joinTime: rollup.genesisTime,
+        leaveTime: '',
+        genesisTime: account.genesisTime,
+        renaissanceTime: account.renaissanceTime,
+
+        totalStake: '0',
+        revokedStake: '0',
+        availableStake: '0',
+
+        totalGain: '0',
+
+        proposedBlockCount: 0,
+        verifiedBlockCount: 0,
+
+        latestBlockHeight: 0,
+        latestBlockHash: '',
+      });
+
+      debug('create rollup validator', address);
+    } catch (err) {
+      console.error('create rollup validator error', err);
+    }
+  });
+};
+
+const ensureRollupValidator = async (address, rollupAddress, ctx, indexdb, upsert = true) => {
+  const doc = await indexdb.rollupValidator.get(address);
+  if (doc) {
+    if (!doc.pk || !doc.endpoint) {
+      const rollup = await indexdb.rollup.get(rollupAddress);
+      const validator = rollup.validators.find((v) => v.address === address);
+      doc.pk = validator.pk;
+      doc.endpoint = validator.endpoint;
+      doc.rollup = rollup.address;
+      return indexdb.rollupValidator.update(address, doc);
+    }
+
+    return doc;
+  }
+  if (upsert === false) {
+    throw new Error('Rollup validator not found and upsert is disabled');
+  }
+
+  const stakeAddress = toStakeAddress(address, rollupAddress);
+  const [rollup, stake, account] = await Promise.all([
+    indexdb.rollup.get(rollupAddress),
+    indexdb.stake.get(stakeAddress),
+    indexdb.account.get(address),
+  ]);
+
+  const token = stake.tokens.find((t) => t.address === rollup.tokenAddress);
+  const validator = rollup.validators.find((v) => v.address === address);
+
+  debug('ensure rollup validator', { txType: ctx.txType, address, rollupAddress, validator, token });
+
+  return indexdb.rollupValidator.insert({
+    rollup: rollup.address,
+
+    address,
+    pk: validator ? validator.pk : '',
+    endpoint: validator ? validator.endpoint : '',
+    moniker: account.moniker,
+
+    joinTime: '',
+    leaveTime: '',
+    genesisTime: ctx.txState.time,
+    renaissanceTime: ctx.txState.time,
+
+    totalStake: token.amount,
+    revokedStake: '0',
+    availableStake: '0',
+
+    totalGain: '0',
+
+    proposedBlockCount: 0,
+    verifiedBlockCount: 0,
+
+    latestBlockHeight: 0,
+    latestBlockHash: '',
+  });
+};
+
+const onCreateRollupBlock = async (block, ctx, indexdb) => {
+  const { validators, proposer } = block;
+  const { rollupState, txStates } = ctx;
+
+  validators.forEach(async (address) => {
+    try {
+      const doc = await ensureRollupValidator(address, rollupState.address, ctx, indexdb);
+
+      doc.rollup = rollupState.address;
+      doc.renaissanceTime = block.genesisTime;
+      doc.verifiedBlockCount += 1;
+      if (address === proposer) {
+        doc.latestBlockHeight = block.height;
+        doc.latestBlockHash = block.hash;
+        doc.proposedBlockCount += 1;
+      }
+
+      await indexdb.rollupValidator.update(address, doc);
+      debug('update rollup validator on new block', address);
+    } catch (err) {
+      console.error('update rollup validator error', err);
+    }
+  });
+
+  // Withdraw tx.actualFee needs to be reindexed
+  if (Array.isArray(txStates)) {
+    txStates
+      .filter((x) => x.type === 'withdraw_token_v2')
+      .forEach(async (x) => {
+        try {
+          const doc = await indexdb.tx.get(x.hash);
+          const updates = merge(doc, pick(x, ['tx.itxJson.actualFee']));
+          await indexdb.tx.update(x.hash, updates);
+          debug('update tx on new block', x.hash);
+        } catch (err) {
+          console.error('update tx on new block error', err);
+        }
+      });
+  }
+};
+
+const updateRollupStats = async (address, value, key, indexdb) => {
+  try {
+    const doc = await indexdb.rollup.get(address);
+    doc[key] = new BN(doc[key] || '0').add(new BN(value)).toString(10);
+    await indexdb.rollup.update(address, doc);
+    debug('update rollup', address);
+  } catch (err) {
+    console.error('update rollup error', err);
+  }
+};
+
+const onDepositTokenV2 = async (tx, ctx, indexdb) => {
+  const { signatures } = tx.tx;
+  const { rollupState } = ctx;
+  signatures.forEach(async ({ signer: address }) => {
+    try {
+      const doc = await ensureRollupValidator(address, rollupState.address, ctx, indexdb);
+      doc.renaissanceTime = tx.time;
+
+      await indexdb.rollupValidator.update(address, doc);
+      debug('update rollup validator on deposit', address);
+    } catch (err) {
+      console.error('update rollup validator error', err);
+    }
+  });
+
+  // totalDepositAmount should include txFee
+  const amount = new BN(tx.tx.itxJson.token.value).add(new BN(tx.tx.itxJson.actualFee));
+  await updateRollupStats(ctx.rollupState.address, amount.toString(), 'totalDepositAmount', indexdb);
+};
+
+const onClaimBlockReward = async (tx, ctx, indexdb) => {
+  const { rollupState, blockState } = ctx;
+  const { signatures } = blockState;
+  // TODO: delegation is not supported here
+  signatures.forEach(async ({ signer }) => {
+    try {
+      const doc = await ensureRollupValidator(signer, rollupState.address, ctx, indexdb);
+
+      const receipt = tx.receipts.find((x) => x.address === signer);
+      if (receipt) {
+        const change = receipt.changes.find((x) => x.target === rollupState.tokenAddress);
+        doc.totalGain = new BN(doc.totalGain).add(new BN(change.value).abs()).toString(10);
+        await indexdb.rollupValidator.update(signer, doc);
+        debug('update rollup validator on claim reward', signer);
+      }
+    } catch (err) {
+      console.error('update rollup validator on claim reward error', err);
+    }
+  });
+};
+
+const onJoinRollup = async (tx, ctx, indexdb) => {
+  try {
+    const address = tx.tx.from;
+    const doc = await ensureRollupValidator(address, tx.tx.itxJson.rollup, ctx, indexdb);
+
+    doc.endpoint = tx.tx.itxJson.endpoint;
+    doc.joinTime = tx.time;
+    doc.renaissanceTime = tx.time;
+    doc.leaveTime = '';
+
+    await indexdb.rollupValidator.update(address, doc);
+    debug('join rollup validator', address);
+  } catch (err) {
+    console.error('join rollup validator error', err);
+  }
+};
+
+const onLeaveRollup = async (tx, ctx, indexdb) => {
+  try {
+    const address = tx.tx.from;
+    const doc = await ensureRollupValidator(address, tx.tx.itxJson.rollup, ctx, indexdb);
+
+    doc.leaveTime = tx.time;
+    doc.renaissanceTime = tx.time;
+
+    await indexdb.rollupValidator.update(address, doc);
+    debug('leave rollup validator', address);
+  } catch (err) {
+    console.error('leave rollup validator error', err);
+  }
+};
+
+const onStake = async (tx, ctx, indexdb) => {
+  try {
+    const rollup = await indexdb.rollup.get(tx.tx.itxJson.receiver);
+    if (!rollup) {
+      return;
+    }
+
+    const address = tx.tx.from;
+    if (rollup.validators.find((x) => x.address === address) === undefined) {
+      return;
+    }
+
+    const stakeAddress = toStakeAddress(address, rollup.address);
+    const doc = await ensureRollupValidator(address, rollup.address, ctx, indexdb);
+
+    const receipt = ctx.txState.receipts.find((x) => x.address === stakeAddress);
+    const change = receipt.changes.find((x) => x.target === rollup.tokenAddress);
+    doc.totalStake = new BN(doc.totalStake).add(new BN(change.value).abs()).toString(10);
+    doc.renaissanceTime = tx.time;
+
+    await indexdb.rollupValidator.update(address, doc);
+    debug('stake rollup validator', address);
+  } catch (err) {
+    console.error('stake rollup validator error', err);
+  }
+};
+
+const onClaimStake = async (tx, ctx, indexdb) => {
+  try {
+    const stake = await indexdb.stake.get(tx.tx.itxJson.address);
+    const rollup = await indexdb.rollup.get(stake.receiver);
+    if (!rollup) {
+      return;
+    }
+
+    const address = tx.tx.from;
+    const doc = await ensureRollupValidator(address, rollup.address, ctx, indexdb, false);
+    const receipt = ctx.txState.receipts.find((x) => x.address === stake.address);
+    const change = receipt.changes.find((x) => x.target === rollup.tokenAddress);
+
+    doc.renaissanceTime = tx.time;
+    doc.revokedStake = new BN(doc.revokedStake).add(new BN(change.value).abs()).toString(10);
+
+    await indexdb.rollupValidator.update(address, doc);
+    debug('revoke-stake rollup validator', address);
+  } catch (err) {
+    console.error('revoke-stake rollup validator error', err);
+  }
+};
+
+const onCreateTx = async (tx, ctx, indexdb) => {
+  if (tx.code !== 'OK') {
+    return;
+  }
+
+  switch (tx.tx.itxJson.type_url) {
+    case 'fg:t:stake':
+      return onStake(tx, ctx, indexdb);
+    case 'fg:t:claim_stake':
+      return onClaimStake(tx, ctx, indexdb);
+    case 'fg:t:join_rollup':
+      return onJoinRollup(tx, ctx, indexdb);
+    case 'fg:t:leave_rollup':
+      return onLeaveRollup(tx, ctx, indexdb);
+    case 'fg:t:deposit_token_v2':
+      return onDepositTokenV2(tx, ctx, indexdb);
+    case 'fg:t:claim_block_reward':
+      return onClaimBlockReward(tx, ctx, indexdb);
+    case 'fg:t:withdraw_token_v2':
+      // totalWithdrawAmount does not include txFee
+      return updateRollupStats(ctx.rollupState.address, tx.tx.itxJson.token.value, 'totalWithdrawAmount', indexdb);
+    default:
+  }
+};
+
+module.exports = { onCreateRollup, onCreateTx, onCreateRollupBlock };