@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/governance/stake.js

@@ -0,0 +1,176 @@
+const pick = require('lodash/pick');
+const { promisify } = require('util');
+const isEmpty = require('empty-value');
+const Joi = require('@arcblock/validator');
+const Error = require('@ocap/util/lib/error');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { toStakeAddress } = require('@arcblock/did-util');
+const { account, asset, stake } = require('@ocap/state');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:acquire-asset-v2`);
+
+const { applyTokenUpdates } = require('../../util');
+
+const verifyAssetOwner = promisify(pipes.VerifyUpdater({ assetKey: 'assets', ownerKey: 'owner' }));
+
+const runner = new Runner();
+
+// 0. verify itx
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_STAKE').required(),
+  receiver: Joi.DID().required(),
+  locked: Joi.boolean().default(false),
+  message: Joi.string().trim().min(1).max(256).required(),
+  revokeWaitingPeriod: Joi.number().integer().min(0).default(0),
+}).options({ stripUnknown: true, noDefaults: false });
+runner.use(({ itx }, next) => {
+  const { error } = schema.validate(itx);
+  return next(error ? new Error('INVALID_TX', `Invalid itx: ${error.message}`) : null);
+});
+runner.use(
+  pipes.VerifyTxInput({
+    fieldKey: 'itx.inputs',
+    inputsKey: 'inputs',
+    sendersKey: 'senders',
+    tokensKey: 'tokens',
+    assetsKey: 'assets',
+  })
+);
+
+// 1. verify itx address
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TX',
+      message: 'Invalid staking address',
+      fn: ({ tx, itx }) => toStakeAddress(tx.from, itx.receiver) === itx.address,
+    },
+    {
+      error: 'INSUFFICIENT_DATA',
+      message: 'Can not stake without any token or asset',
+      fn: ({ assets, tokens }) => !(isEmpty(tokens) && isEmpty(assets)),
+    },
+  ])
+);
+
+// 2. verify itx size: set hard limit here because more inputs leads to longer tx execute time
+runner.use(pipes.VerifyListSize({ listKey: ['inputs', 'senders', 'tokens', 'assets'] }));
+
+// 3. verify multi sig
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'senders' }));
+
+// 4. verify against state
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'stakeState', status: 'OK', table: 'stake' }));
+
+// 5. verify sender & signer & receiver
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
+runner.use(pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'itx.receiver', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' })); // can by any type
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 6. verify token state and balance
+runner.use(pipes.ExtractState({ from: 'tokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'signerStates', conditionKey: 'inputs' }));
+
+// 7. verify asset state and ownership
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'OK', table: 'asset' }));
+runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
+runner.use(async (context, next) => {
+  const { inputs, assetStates = [], signerStates } = context;
+  for (const input of inputs) {
+    const { owner, assetsList } = input;
+    const states = assetStates.filter((x) => assetsList.includes(x.address));
+    const signer = signerStates.find((x) => x.address === owner);
+
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await verifyAssetOwner({ assets: states, owner: signer });
+    } catch (err) {
+      return next(err);
+    }
+  }
+
+  return next();
+});
+
+// update statedb
+runner.use(
+  async (context, next) => {
+    const { tx, itx, inputs, statedb, senderState, stakeState, signerStates, assetStates = [] } = context;
+
+    const signerUpdates = {};
+    const stakeUpdates = stakeState
+      ? { tokens: stakeState.tokens, assets: stakeState.assets }
+      : { tokens: {}, assets: [] };
+
+    inputs.forEach((x) => {
+      const { owner, tokensList, assetsList } = x;
+      signerUpdates[owner] = applyTokenUpdates(
+        tokensList,
+        signerStates.find((s) => s.address === owner),
+        'sub'
+      );
+      Object.assign(stakeUpdates, applyTokenUpdates(tokensList, stakeUpdates, 'add'));
+      stakeUpdates.assets.push(...assetsList);
+    });
+
+    const isAlsoSigner = !!signerUpdates[tx.from];
+
+    const [newSenderState, newSignerStates, newStakeState, newAssetStates] = await Promise.all([
+      // Update sender state
+      statedb.account.updateOrCreate(
+        senderState,
+        account.updateOrCreate(
+          senderState,
+          Object.assign({ address: tx.from, nonce: tx.nonce, pk: tx.pk }, signerUpdates[tx.from] || {}),
+          context
+        ),
+        context
+      ),
+
+      // Update signer state
+      Promise.all(
+        signerStates
+          .filter((x) => x.address !== tx.from)
+          .map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context))
+      ),
+
+      // Update/create stake state
+      stakeState
+        ? statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context)
+        : statedb.stake.create(
+            itx.address,
+            stake.create(
+              {
+                sender: tx.from,
+                revocable: !itx.locked,
+                ...pick(itx, ['address', 'receiver', 'message', 'data', 'revokeWaitingPeriod']),
+                ...stakeUpdates,
+              },
+              context
+            ),
+            context
+          ),
+
+      // Transfer assets to staking account
+      Promise.all(
+        assetStates.map((x) =>
+          statedb.asset.update(x.address, asset.update(x, { owner: itx.address }, context), context)
+        )
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+    context.stakeState = newStakeState;
+    context.assetStates = newAssetStates;
+
+    debug('stake', { address: itx.address, stakeUpdates, signerUpdates });
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/rollup/claim-reward.js

@@ -0,0 +1,283 @@
+const uniqBy = require('lodash/uniqBy');
+const groupBy = require('lodash/groupBy');
+const cloneDeep = require('lodash/cloneDeep');
+const Joi = require('@arcblock/validator');
+const Error = require('@ocap/util/lib/error');
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake, evidence, rollupBlock } = require('@ocap/state');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:claim-block-reward`);
+
+const { toStakeAddress } = require('@arcblock/did-util');
+const VerifySigners = require('./pipes/verify-signers');
+const { applyTokenChange, splitTxFee, getBNSum, getRewardLocker, RATE_BASE } = require('../../util');
+
+const runner = new Runner();
+
+// 1. verify itx
+const schema = Joi.object({
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  blockHeight: Joi.number().integer().greater(0).required(),
+  blockHash: Joi.string().regex(Joi.patterns.txHash).required(),
+  evidence: Joi.object({
+    hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  }).required(),
+  publisher: Joi.DID().wallet('ethereum').required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+runner.use((context, next) => {
+  const { tx, itx } = context;
+
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', error.message));
+  }
+
+  // ensure publisher same with tx.from
+  if (tx.from !== itx.publisher) {
+    return next(new Error('INVALID_TX', 'itx.publisher must be same with tx.from'));
+  }
+
+  context.lockerAddress = getRewardLocker(itx.rollup);
+
+  return next();
+});
+
+// 2. ensure evidence not exist
+runner.use(pipes.ExtractState({ from: 'itx.evidence.hash', to: 'evidenceSeen', status: 'OK', table: 'evidence' }));
+runner.use(pipes.ExtractState({ from: 'itx.blockHash', to: 'blockClaimed', status: 'OK', table: 'evidence' }));
+runner.use(({ evidenceSeen, blockClaimed }, next) => {
+  if (evidenceSeen) return next(new Error('INVALID_TX', 'Claim evidence already seen on this chain'));
+  if (blockClaimed) return next(new Error('INVALID_TX', 'Block reward already claimed before this tx'));
+  return next();
+});
+
+// 3. verify rollup and block state
+runner.use(pipes.ExtractState({ from: 'itx.rollup', to: 'rollupState', status: 'INVALID_ROLLUP', table: 'rollup' }));
+runner.use(pipes.ExtractState({ from: 'itx.blockHash', to: 'blockState', status: 'INVALID_ROLLUP_BLOCK', table: 'rollupBlock' })); // prettier-ignore
+runner.use((context, next) => {
+  const { blockState, rollupState, itx } = context;
+  if (blockState.rollup !== rollupState.address) {
+    return next(new Error('INVALID_TX', 'Rollup block belonging does not match'));
+  }
+  if (blockState.height !== itx.blockHeight) {
+    return next(new Error('INVALID_TX', 'Rollup block height does not match'));
+  }
+
+  // If the publisher is not the producer, he should wait at least rollupState.publishWaitingPeriod
+  if (blockState.proposer !== itx.publisher) {
+    const proposedAt = +new Date(blockState.context.genesisTime);
+    const publishedAt = +new Date(context.txTime);
+    if (proposedAt + rollupState.publishWaitingPeriod * 1000 > publishedAt) {
+      return next(new Error('INVALID_TX', 'Rollup block can only be published by producer during waiting period'));
+    }
+  }
+
+  context.producerStake = toStakeAddress(blockState.proposer, itx.rollup);
+
+  return next();
+});
+
+// 4. verify tx signers & signatures
+runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: true }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
+
+// 5. verify block reward locker
+runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'INVALID_LOCKER_STATE', table: 'stake' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'producerStake', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+
+// 6. verify sender and signer states
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 7. verify token state
+runner.use(pipes.ExtractState({ from: 'rollupState.tokenAddress', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })); // prettier-ignore
+
+// 8. split and aggregate block reward for each tx and the block
+runner.use(pipes.ExtractState({ from: 'blockState.txs', to: 'txs', status: 'INVALID_TX', table: 'tx' }));
+runner.use(async (context, next) => {
+  const { itx, txs, rollupState, blockState, lockerState, tokenState, stakeState } = context;
+  const { proposerFeeShare, publisherFeeShare } = rollupState;
+
+  const shares = {
+    publisher: publisherFeeShare,
+    proposer: proposerFeeShare,
+    validator: 10000 - publisherFeeShare - proposerFeeShare,
+  };
+
+  const changes = { account: [], stake: [] };
+
+  // 0. handle slash case
+  // TODO: the producer stake balance should be enough for slashing
+  const shouldSlash = blockState.proposer !== itx.publisher;
+  if (shouldSlash) {
+    const slashAmount = new BN(rollupState.minStakeAmount).mul(new BN(rollupState.publishSlashRate)).div(RATE_BASE);
+    const slashShare = slashAmount.div(new BN(2));
+    changes.stake.push({ address: stakeState.address, delta: `-${slashAmount.toString(10)}`, action: 'slash' });
+    changes.stake.push({ address: lockerState.address, delta: slashShare.toString(10), action: 'slash' });
+    changes.account.push({ address: itx.publisher, delta: slashShare.toString(10), action: 'reward' });
+  }
+
+  // 1. loop through the tx and split reward
+  txs.forEach((x) => {
+    const { actualFee } = x.tx.itxJson;
+    const { publisher, proposer, validator } = splitTxFee({ total: actualFee, shares, stringify: false });
+
+    changes.stake.push({ address: lockerState.address, delta: `-${actualFee}`, action: 'claim' });
+    changes.account.push({ address: itx.publisher, delta: publisher.toString(10), action: 'fee' });
+
+    if (x.type === 'deposit_token_v2') {
+      changes.account.push({ address: x.tx.itxJson.proposer, delta: proposer.toString(10), action: 'fee' });
+
+      // block and tx signers share the validator part
+      // FIXME: delegation is not supported here yet
+      const validators = x.tx.signatures.map((s) => s.signer).concat(blockState.signatures.map((s) => s.signer));
+      const validatorShare = validator.div(new BN(validators.length));
+      validators.forEach((v) =>
+        changes.account.push({ address: v, delta: validatorShare.toString(10), action: 'fee' })
+      );
+    } else if (x.type === 'withdraw_token_v2') {
+      changes.account.push({ address: blockState.proposer, delta: proposer.toString(10), action: 'fee' });
+
+      // block signers share the validator part
+      // FIXME: delegation is not supported here yet
+      const validators = blockState.signatures.map((s) => s.signer);
+      const validatorShare = validator.div(new BN(validators.length));
+      validators.forEach((v) =>
+        changes.account.push({ address: v, delta: validatorShare.toString(10), action: 'fee' })
+      );
+    }
+  });
+
+  // 2. aggregate changes to updates
+  const grouped = {
+    account: groupBy(changes.account, 'address'),
+    stake: groupBy(changes.stake, 'address'),
+  };
+
+  const updates = {
+    stake: Object.keys(grouped.stake).reduce((acc, x) => {
+      acc[x] = {
+        address: x,
+        token: tokenState.address,
+        delta: getBNSum(...grouped.stake[x].map((c) => c.delta)),
+        action: grouped.stake[x][grouped.stake[x].length - 1].action,
+      };
+      return acc;
+    }, {}),
+    account: Object.keys(grouped.account).reduce((acc, x) => {
+      acc[x] = {
+        address: x,
+        token: tokenState.address,
+        delta: getBNSum(...grouped.account[x].map((c) => c.delta)),
+        action: grouped.account[x][grouped.account[x].length - 1].action,
+      };
+      return acc;
+    }, {}),
+  };
+
+  context.changes = changes;
+  context.updates = updates;
+
+  return next();
+});
+
+// 9. extract all accounts that will be updated exist
+runner.use((context, next) => {
+  const { updates, senderState, signerStates } = context;
+  const requiredAccounts = Object.keys(updates.account);
+  const knownAccounts = { [senderState.address]: senderState };
+
+  // eslint-disable-next-line no-return-assign
+  signerStates.forEach((x) => (knownAccounts[x.address] = x));
+
+  context.missingAccounts = requiredAccounts.filter((x) => !knownAccounts[x]);
+  return next();
+});
+runner.use(
+  pipes.ExtractState({
+    from: 'missingAccounts',
+    to: 'missingAccountStates',
+    status: 'INVALID_SIGNER_STATE',
+    table: 'account',
+  })
+);
+runner.use((context, next) => {
+  const { senderState, signerStates, missingAccountStates } = context;
+  context.accountStates = uniqBy([senderState, ...signerStates, ...(missingAccountStates || [])], 'address');
+  return next();
+});
+
+// 10. update state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, updates, statedb, senderState, blockState, lockerState, stakeState, accountStates } = context;
+
+    const [newStakeStates, newAccountStates, newBlockState] = await Promise.all([
+      // update stake states
+      Promise.all(
+        [lockerState, stakeState].map((x) =>
+          updates.stake[x.address]
+            ? statedb.stake.update(
+                x.address,
+                stake.update(x, applyTokenChange(x, updates.stake[x.address]), context),
+                context
+              )
+            : x
+        )
+      ),
+
+      // update accounts(proposer, publisher, validator)
+      Promise.all(
+        accountStates.map((x) =>
+          statedb.account.update(
+            x.address,
+            account.update(
+              x,
+              Object.assign(
+                x.address === senderState.address ? { nonce: tx.nonce } : {},
+                applyTokenChange(x, updates.account[x.address])
+              ),
+              context
+            ),
+            context
+          )
+        )
+      ),
+
+      // Update block state, just update the context
+      statedb.rollupBlock.update(blockState.hash, rollupBlock.update(blockState, context), context),
+
+      // Create evidence
+      statedb.evidence.create(
+        itx.evidence.hash,
+        evidence.create({ hash: itx.evidence.hash, data: 'rollup-claim-block-reward' }, context),
+        context
+      ),
+      statedb.evidence.create(
+        itx.blockHash,
+        evidence.create({ hash: itx.blockHash, data: 'rollup-claim-block-reward' }, context),
+        context
+      ),
+    ]);
+
+    // to avoid this to be incorrectly indexed
+    delete context.stakeState;
+
+    context.stakeStates = newStakeStates.filter((x) => updates.stake[x.address]);
+    context.accountStates = newAccountStates;
+    context.blockState = newBlockState;
+
+    context.updatedAccounts = cloneDeep([...Object.values(updates.account), ...Object.values(updates.stake)]);
+
+    debug('claim-block-reward', itx);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;