@ocap/tx-protocols 1.13.60 → 1.13.64

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

@@ -9,10 +9,10 @@ const { account, stake, evidence, rollupBlock, Joi } = 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, splitBlockReward, getBlockRewardLocker } = require('../../util');
+const { applyTokenChange, splitTxFee, getBNSum, getRewardLocker, RATE_BASE } = require('../../util');
 
-const ZERO = new BN(0);
 const runner = new Runner();
 
 // 1. verify itx
@@ -39,12 +39,21 @@ runner.use((context, next) => {
     return next(new Error('INVALID_TX', 'itx.publisher must be same with tx.from'));
   }
 
-  context.lockerAddress = getBlockRewardLocker(itx.rollup);
+  context.lockerAddress = getRewardLocker(itx.rollup);
 
   return next();
 });
 
-// 2. verify rollup and block state
+// 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) => {
@@ -55,24 +64,28 @@ runner.use((context, next) => {
   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();
 });
 
-// 3. verify tx signers & signatures
+// 4. verify tx signers & signatures
 runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: true }));
 runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
 
-// 4. verify block reward locker
+// 5. verify block reward locker
 runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'INVALID_LOCKER_STATE', table: 'stake' })); // prettier-ignore
-
-// 5. 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();
-});
+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
@@ -85,8 +98,7 @@ runner.use(pipes.ExtractState({ from: 'rollupState.tokenAddress', to: 'tokenStat
 // 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 } = context;
-  const { depositFeeRate, withdrawFeeRate, minDepositFee, maxDepositFee, minWithdrawFee, maxWithdrawFee } = rollupState;
+  const { itx, txs, rollupState, blockState, lockerState, tokenState, stakeState } = context;
   const { proposerFeeShare, publisherFeeShare } = rollupState;
 
   const shares = {
@@ -95,23 +107,28 @@ runner.use(async (context, next) => {
     validator: 10000 - publisherFeeShare - proposerFeeShare,
   };
 
-  // 1. loop through the tx and split reward
   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 amount = x.tx.itxJson.token.value;
+    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') {
-      const { fee, feeShares } = splitBlockReward({
-        total: amount,
-        feeRate: depositFeeRate,
-        maxFee: maxDepositFee,
-        minFee: minDepositFee,
-        shares,
-        stringify: false,
-      });
-      changes.stake.push({ address: lockerState.address, delta: `-${fee}`, action: 'claim' });
-
-      const { publisher, proposer, validator } = feeShares;
-      changes.account.push({ address: itx.publisher, delta: publisher.toString(10), action: 'fee' });
       changes.account.push({ address: x.tx.itxJson.proposer, delta: proposer.toString(10), action: 'fee' });
 
       // block and tx signers share the validator part
@@ -122,18 +139,6 @@ runner.use(async (context, next) => {
         changes.account.push({ address: v, delta: validatorShare.toString(10), action: 'fee' })
       );
     } else if (x.type === 'withdraw_token_v2') {
-      const { fee, feeShares } = splitBlockReward({
-        total: amount,
-        feeRate: withdrawFeeRate,
-        maxFee: maxWithdrawFee,
-        minFee: minWithdrawFee,
-        shares,
-        stringify: false,
-      });
-      changes.stake.push({ address: lockerState.address, delta: `-${fee}`, action: 'claim' });
-
-      const { publisher, proposer, validator } = feeShares;
-      changes.account.push({ address: itx.publisher, delta: publisher.toString(10), action: 'fee' });
       changes.account.push({ address: blockState.proposer, delta: proposer.toString(10), action: 'fee' });
 
       // block signers share the validator part
@@ -157,7 +162,7 @@ runner.use(async (context, next) => {
       acc[x] = {
         address: x,
         token: tokenState.address,
-        delta: grouped.stake[x].reduce((a, u) => a.add(new BN(u.delta)), ZERO),
+        delta: getBNSum(...grouped.stake[x].map((c) => c.delta)),
         action: grouped.stake[x][grouped.stake[x].length - 1].action,
       };
       return acc;
@@ -166,7 +171,7 @@ runner.use(async (context, next) => {
       acc[x] = {
         address: x,
         token: tokenState.address,
-        delta: grouped.account[x].reduce((a, u) => a.add(new BN(u.delta)), ZERO),
+        delta: getBNSum(...grouped.account[x].map((c) => c.delta)),
         action: grouped.account[x][grouped.account[x].length - 1].action,
       };
       return acc;
@@ -179,8 +184,6 @@ runner.use(async (context, next) => {
   return next();
 });
 
-// TODO: verify locker balance
-
 // 9. extract all accounts that will be updated exist
 runner.use((context, next) => {
   const { updates, senderState, signerStates } = context;
@@ -208,17 +211,23 @@ runner.use((context, next) => {
 });
 
 // 10. update state
-// FIXME: (future) we have a low probability of encounter QLDB 40 documents in a single transaction limit
 runner.use(
   async (context, next) => {
-    const { tx, itx, updates, statedb, senderState, blockState, lockerState, accountStates } = context;
+    const { tx, itx, updates, statedb, senderState, blockState, lockerState, stakeState, accountStates } = context;
 
-    // This balance from the locker will be checked when apply updates
-    const lockerUpdates = applyTokenChange(lockerState, updates.stake[lockerState.address]);
-
-    const [newLockerState, newAccountStates, newBlockState] = await Promise.all([
-      // update locker state
-      statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), 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(
@@ -254,12 +263,11 @@ runner.use(
       ),
     ]);
 
-    context.stakeState = newLockerState;
+    context.stakeStates = newStakeStates;
     context.accountStates = newAccountStates;
     context.blockState = newBlockState;
 
     context.updatedAccounts = cloneDeep([...Object.values(updates.account), ...Object.values(updates.stake)]);
-    context.updatedAccounts.forEach((x) => (x.delta = x.delta.toString(10))); // eslint-disable-line
 
     debug('claim-block-reward', itx);
 

package/lib/protocols/rollup/create-block.js

@@ -1,13 +1,11 @@
 /* eslint-disable indent */
 const pick = require('lodash/pick');
-const groupBy = require('lodash/groupBy');
 const Error = require('@ocap/util/lib/error');
 const MerkleTree = require('@ocap/merkle-tree');
-const { BN } = require('@ocap/util');
 const { formatMessage } = require('@ocap/message');
 const { toStakeAddress } = require('@arcblock/did-util');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
-const { account, stake, rollup, rollupBlock, evidence, Joi } = require('@ocap/state');
+const { account, stake, rollup, rollupBlock, tx: Tx, Joi } = require('@ocap/state');
 
 // eslint-disable-next-line global-require
 const debug = require('debug')(`${require('../../../package.json').name}:create-rollup-block`);
@@ -15,7 +13,7 @@ const debug = require('debug')(`${require('../../../package.json').name}:create-
 const VerifySigners = require('./pipes/verify-signers');
 const VerifyEvidence = require('./pipes/verify-evidence');
 const VerifyPaused = require('./pipes/verify-paused');
-const { applyTokenUpdates, applyTokenChange, splitBlockReward, getBlockRewardLocker } = require('../../util');
+const { applyTokenChange, ensureBlockReward, getRewardLocker } = require('../../util');
 
 const runner = new Runner();
 
@@ -34,6 +32,7 @@ const schema = Joi.object({
   proposer: Joi.DID().wallet('ethereum').required(),
   signaturesList: Joi.multiSigSchema.min(1).required(),
   rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  minReward: Joi.BN().min(0).required(),
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 
@@ -143,7 +142,6 @@ runner.use((context, next) => {
     }
 
     // ensure minBlockInterval
-    // TODO: (future) 这里需要再讨论下
     const minBlockTime = +new Date(previousBlock.context.genesisTime) + rollupState.minBlockInterval * 1000;
     const newBlockTime = +new Date(txTime);
     if (newBlockTime < minBlockTime) {
@@ -171,57 +169,42 @@ runner.use(
   pipes.ExtractState({ from: 'rollupState.tokenAddress', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })
 );
 
-// 8. verify evidence
-runner.use(pipes.ExtractState({ from: 'itx.txsList', to: 'evidenceStates', status: 'OK', table: 'evidence' }));
-runner.use(({ evidenceStates }, next) => {
-  if (Array.isArray(evidenceStates) && evidenceStates.length > 0) {
+// 8. verify txs
+runner.use(pipes.ExtractState({ from: 'itx.txsList', to: 'txStates', status: 'INVALID_TX', table: 'tx' }));
+runner.use(({ itx, txStates }, next) => {
+  // ensure not finalized
+  const finalizedTx = txStates.some((x) => x.finalized);
+  if (finalizedTx) {
     return next(new Error('INVALID_TX', 'Should not include finalized tx in later block'));
   }
 
-  return next();
-});
-
-// 9. verify txs
-runner.use(pipes.ExtractState({ from: 'itx.txsList', to: 'txs', status: 'INVALID_TX', table: 'tx' }));
-runner.use(({ itx, txs, rollupState }, next) => {
   // ensure tx are successfully executed
-  const invalidStatusTx = txs.some((x) => x.code !== 'OK');
+  const invalidStatusTx = txStates.some((x) => x.code !== 'OK');
   if (invalidStatusTx) {
     return next(new Error('INVALID_TX', 'Rollup block can only include successful executed transactions'));
   }
 
   // ensure tx type
-  const invalidTypeTx = txs.some((x) => ['deposit_token_v2', 'withdraw_token_v2'].includes(x.type) === false);
+  const invalidTypeTx = txStates.some((x) => ['deposit_token_v2', 'withdraw_token_v2'].includes(x.type) === false);
   if (invalidTypeTx) {
     return next(new Error('INVALID_TX', "Rollup block can only include 'withdraw_token' and 'deposit_token' tx"));
   }
 
   // ensure rollup belonging
-  const invalidRollupTx = txs.some((x) => x.tx.itxJson.rollup !== itx.rollup);
+  const invalidRollupTx = txStates.some((x) => x.tx.itxJson.rollup !== itx.rollup);
   if (invalidRollupTx) {
     return next(new Error('INVALID_TX', `Rollup block can only include tx from rollup ${itx.rollup}`));
   }
 
   // ensure merkleRoot
-  const { withdrawFeeRate, minWithdrawFee, maxWithdrawFee } = rollupState;
   const merkleTree = MerkleTree.getBlockMerkleTree(
-    txs
+    txStates
       .filter((x) => x.type === 'withdraw_token_v2')
-      .map((x) => {
-        // User can only withdraw erc20 tokens without the withdraw fee
-        const { user: userAmount } = splitBlockReward({
-          total: x.tx.itxJson.token.value,
-          feeRate: withdrawFeeRate,
-          maxFee: maxWithdrawFee,
-          minFee: minWithdrawFee,
-        });
-
-        return {
-          hash: x.hash,
-          to: x.tx.itxJson.to,
-          amount: userAmount,
-        };
-      })
+      .map((x) => ({
+        hash: x.hash,
+        to: x.tx.itxJson.to,
+        amount: x.tx.itxJson.token.value,
+      }))
   );
   if (merkleTree.getHexRoot() !== itx.merkleRoot) {
     return next(new Error('INVALID_TX', 'Invalid rollup block merkle root'));
@@ -230,118 +213,45 @@ runner.use(({ itx, txs, rollupState }, next) => {
   return next();
 });
 
-// 10. verify staking: used for minting & burning
+// 9. verify staking: used for minting & burning
 runner.use((context, next) => {
-  const { itx, txs } = context;
+  const { itx, txStates } = context;
 
-  const depositProposerStakeAddr = txs
+  const depositProposerStakeAddr = txStates
     .filter((x) => x.type === 'deposit_token_v2')
     .map((x) => toStakeAddress(x.tx.itxJson.proposer, itx.rollup));
 
-  const withdrawLockerStakeAddr = txs
+  const withdrawLockerStakeAddr = txStates
     .filter((x) => x.type === 'withdraw_token_v2')
     .map((x) => toStakeAddress(x.tx.from, itx.rollup));
 
-  context.stakeAddress = [...depositProposerStakeAddr, ...withdrawLockerStakeAddr];
-  context.lockerAddress = getBlockRewardLocker(itx.rollup);
+  context.stakeAddress = [...depositProposerStakeAddr, ...withdrawLockerStakeAddr, getRewardLocker(itx.rollup)];
 
   return next();
 });
-runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'OK', table: 'stake' }));
-runner.use(
-  pipes.ExtractState({ from: 'stakeAddress', to: 'stakeStates', status: 'INVALID_STAKE_STATE', table: 'stake' })
-);
+runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeStates', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+
+// 10. ensure block reward and dynamic tx fees
+runner.use((context, next) => {
+  const { itx, txStates, rollupState } = context;
+  try {
+    const result = ensureBlockReward(rollupState, itx.minReward, txStates);
+    context.senders = Object.keys(result.accountUpdates);
+    Object.assign(context, result);
+    return next();
+  } catch (err) {
+    return next(err);
+  }
+});
+runner.use(pipes.ExtractState({ from: 'senders', to: 'senderStates', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 
 // 11. update state: mint tokens for deposits, burn tokens for withdraws
 runner.use(
   async (context, next) => {
-    const {
-      tx,
-      itx,
-      txs,
-      statedb,
-      rollupState,
-      senderState,
-      tokenState,
-      stakeStates,
-      lockerAddress,
-      lockerState,
-      formattedItx,
-    } = context;
-    const { depositFeeRate, withdrawFeeRate, minDepositFee, maxDepositFee, minWithdrawFee, maxWithdrawFee } =
-      rollupState;
-
-    const ZERO = new BN(0);
-
-    context.mintedAmount = new BN(0);
-    context.burnedAmount = new BN(0);
-    context.rewardAmount = new BN(0);
-    context.pendingReward = new BN(0);
-
-    const tokenAddress = tokenState.address;
-
-    // 1. loop through the tx and gen all updates, minted, burned
-    const updates = { stake: [] };
-    txs.forEach((x) => {
-      const amount = x.tx.itxJson.token.value;
-      if (x.type === 'deposit_token_v2') {
-        const { fee: feeAmount } = splitBlockReward({
-          total: amount,
-          feeRate: depositFeeRate,
-          maxFee: maxDepositFee,
-          minFee: minDepositFee,
-          stringify: false,
-        });
-        context.rewardAmount = context.rewardAmount.add(feeAmount);
-        context.mintedAmount = context.mintedAmount.add(new BN(amount));
-
-        // mint tokens for deposit proposer
-        updates.stake.push({
-          address: toStakeAddress(x.tx.itxJson.proposer, itx.rollup),
-          delta: amount,
-          action: 'mint',
-        });
-      } else if (x.type === 'withdraw_token_v2') {
-        const { total: totalAmount, fee: feeAmount } = splitBlockReward({
-          total: amount,
-          feeRate: withdrawFeeRate,
-          maxFee: maxWithdrawFee,
-          minFee: minWithdrawFee,
-          stringify: false,
-        });
-
-        // save reward to rollup locker stake
-        context.pendingReward = context.pendingReward.add(feeAmount);
-
-        context.rewardAmount = context.rewardAmount.add(feeAmount);
-        context.burnedAmount = context.burnedAmount.add(totalAmount);
-
-        // burn tokens from user locker stakes
-        updates.stake.push({ address: toStakeAddress(x.tx.from, itx.rollup), delta: `-${amount}`, action: 'burn' });
-      }
-    });
-
-    // 2. aggregate stake updates
-    const grouped = { stake: groupBy(updates.stake, 'address') };
-    const stakeUpdates = Object.keys(grouped.stake).reduce((acc, x) => {
-      acc[x] = {
-        address: x,
-        token: tokenAddress,
-        delta: grouped.stake[x].reduce((a, u) => a.add(new BN(u.delta)), ZERO),
-        action: grouped.stake[x][grouped.stake[x].length - 1].action,
-      };
-
-      return acc;
-    }, {});
-
-    const lockerUpdates = applyTokenUpdates(
-      [{ address: tokenAddress, value: context.pendingReward.toString(10) }],
-      lockerState || { tokens: {} },
-      'add'
-    );
+    const { tx, itx, statedb, rollupState, senderState, stakeStates, txStates, formattedItx } = context;
+    const senderStates = context.senderStates || [];
 
-    // 3. update account & stake states
-    const [newSenderState, newStakeStates, newRollupState, rollupBlockState, newLockerState] = await Promise.all([
+    const [newSenderState, newStakeStates, newSenderStates, newRollupState, rollupBlockState] = await Promise.all([
       // update sender(proposer) account
       statedb.account.update(
         senderState.address,
@@ -352,16 +262,27 @@ runner.use(
       // update stake states
       Promise.all(
         stakeStates.map((x) =>
-          stakeUpdates[x.address]
+          context.stakeUpdates[x.address]
             ? statedb.stake.update(
                 x.address,
-                stake.update(x, applyTokenChange(x, stakeUpdates[x.address]), context),
+                stake.update(x, applyTokenChange(x, context.stakeUpdates[x.address]), context),
                 context
               )
             : Promise.resolve(x)
         )
       ),
 
+      // update tx owner states: those may get refund
+      Promise.all(
+        senderStates.map((x) =>
+          statedb.account.update(
+            x.address,
+            account.update(x, applyTokenChange(x, context.accountUpdates[x.address]), context),
+            context
+          )
+        )
+      ),
+
       // Update rollup state
       statedb.rollup.update(
         rollupState.address,
@@ -385,40 +306,17 @@ runner.use(
         context
       ),
 
-      // Update pending fee locker state
-      lockerState
-        ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context)
-        : statedb.stake.create(
-            itx.address,
-            stake.create(
-              {
-                address: lockerAddress,
-                sender: itx.rollup,
-                receiver: itx.rollup,
-                revocable: false,
-                message: 'pending-block-reward',
-                revokeWaitingPeriod: 0,
-                ...lockerUpdates,
-              },
-              context
-            ),
-            context
-          ),
-
-      // Create evidence
-      Promise.all(
-        itx.txsList.map((x) =>
-          statedb.evidence.create(x, evidence.create({ hash: x, data: 'rollup-block' }, context), context)
-        )
-      ),
+      // Update tx states: mark as finalized
+      Promise.all(txStates.map((x) => statedb.tx.update(x.hash, Tx.update(x, { finalized: true, tx: x.tx }), context))),
     ]);
 
     context.senderState = newSenderState;
-    context.stakeStates = [...newStakeStates, newLockerState];
+    context.stakeStates = newStakeStates;
+    context.newSenderStates = newSenderStates;
     context.rollupState = newRollupState;
     context.rollupBlockState = rollupBlockState;
-    context.updatedAccounts = [...Object.values(stakeUpdates)];
-    context.updatedAccounts.forEach((x) => (x.delta = x.delta.toString(10))); // eslint-disable-line
+
+    context.updatedAccounts = [...Object.values(context.stakeUpdates), ...Object.values(context.accountUpdates)];
 
     debug('create-rollup-block', { itx, updatedAccounts: context.updatedAccounts });
 

package/lib/protocols/token/deposit-v2.js

@@ -11,7 +11,7 @@ const debug = require('debug')(`${require('../../../package.json').name}:deposit
 
 const VerifySigners = require('../rollup/pipes/verify-signers');
 const VerifyPaused = require('../rollup/pipes/verify-paused');
-const { applyTokenUpdates, splitBlockReward, getBlockRewardLocker } = require('../../util');
+const { applyTokenUpdates, getTxFee, getBNSum, getRewardLocker } = require('../../util');
 
 const schema = Joi.object({
   token: Joi.tokenInputSchema.required(),
@@ -21,6 +21,7 @@ const schema = Joi.object({
     hash: Joi.string().regex(Joi.hashRegexp).required(),
   }).required(),
   rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  actualFee: Joi.BN().min(0).required(),
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 
@@ -82,21 +83,17 @@ runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: true })
 runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
 
 // 5. verify token state
-runner.use(
-  pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })
-);
+runner.use(pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })); // prettier-ignore
 
 // 6. verify staking: get address, extract state, verify amount
 runner.use((context, next) => {
   const { itx } = context;
   context.stakeAddress = toStakeAddress(itx.proposer, itx.rollup);
-  context.lockerAddress = getBlockRewardLocker(itx.rollup);
+  context.lockerAddress = getRewardLocker(itx.rollup);
   return next();
 });
 runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'OK', table: 'stake' }));
-runner.use(
-  pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })
-);
+runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
 runner.use((context, next) => {
   const { itx, stakeState, tokenState, rollupState } = context;
   if (stakeState.revocable === true) {
@@ -136,51 +133,45 @@ runner.use((context, next) => {
   return next();
 });
 
+// 7. verify actualFee
+runner.use((context, next) => {
+  const { itx, rollupState, tokenState } = context;
+  const { depositFeeRate, maxDepositFee, minDepositFee } = rollupState;
+
+  const { reward } = getTxFee({
+    amount: itx.token.value,
+    feeRate: depositFeeRate,
+    maxFee: maxDepositFee,
+    minFee: minDepositFee,
+  });
+
+  if (new BN(itx.actualFee).lt(new BN(reward))) {
+    const expected = fromUnitToToken(reward, tokenState.decimal);
+    const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
+    return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
+  }
+
+  return next();
+});
+
 // 7. verify sender and signer states
-runner.use(
-  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
-);
-runner.use(
-  pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })
-);
+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' }));
 
 // 8. update state: the token minting is done when deposit finalized in rollup-block
 runner.use(
   async (context, next) => {
-    const { tx, itx, statedb, rollupState, senderState, stakeState, stakeAddress, lockerState, lockerAddress } =
-      context;
-    const { depositFeeRate, maxDepositFee, minDepositFee } = rollupState;
-
-    const tokenAddress = itx.token.address;
-    const { user: userAmount, fee: feeAmount } = splitBlockReward({
-      total: itx.token.value,
-      feeRate: depositFeeRate,
-      maxFee: maxDepositFee,
-      minFee: minDepositFee,
-    });
-
-    const updatedAccounts = []; // for generating receipts
-    updatedAccounts.push({ address: senderState.address, token: tokenAddress, delta: userAmount, action: 'unlock' });
-    // stake for tx proposer is decreased
-    updatedAccounts.push({
-      address: stakeAddress,
-      token: tokenAddress,
-      delta: `-${itx.token.value}`,
-      action: 'unlock',
-    });
-    // block reward is locked for later claiming
-    updatedAccounts.push({
-      address: lockerAddress,
-      token: tokenAddress,
-      delta: feeAmount,
-      action: 'pending',
-    });
-
-    const senderUpdates = applyTokenUpdates([{ address: tokenAddress, value: userAmount }], senderState, 'add');
-    const stakeUpdates = applyTokenUpdates([itx.token], stakeState, 'sub');
+    const { tx, itx, statedb, senderState, stakeState, stakeAddress, lockerState, lockerAddress } = context;
+
+    const user = itx.token.value;
+    const fee = itx.actualFee;
+    const total = getBNSum(user, fee);
+
+    const stakeUpdates = applyTokenUpdates([{ address: itx.token.address, value: total }], stakeState, 'sub');
+    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: user }], senderState, 'add');
     const lockerUpdates = applyTokenUpdates(
-      [{ address: tokenAddress, value: feeAmount }],
+      [{ address: itx.token.address, value: fee }],
       lockerState || { tokens: {} },
       'add'
     );
@@ -228,9 +219,17 @@ runner.use(
     context.stakeState = newStakeState;
     context.evidenceState = evidenceState;
     context.stakeStates = [newStakeState, newLockerState];
-    context.updatedAccounts = updatedAccounts;
 
-    debug('deposit-token-v2', { itx, updatedAccounts });
+    context.updatedAccounts = [
+      // stake for tx proposer is decreased
+      { address: stakeAddress, token: itx.token.address, delta: `-${total}`, action: 'unlock' },
+      // mint to depositor from stake
+      { address: senderState.address, token: itx.token.address, delta: user, action: 'unlock' },
+      // tx fee is locked for later claiming
+      { address: lockerAddress, token: itx.token.address, delta: fee, action: 'pending' },
+    ];
+
+    debug('deposit-token-v2', itx);
 
     next();
   },

package/lib/protocols/token/withdraw-v2.js

@@ -1,5 +1,6 @@
 /* eslint-disable indent */
 const Error = require('@ocap/util/lib/error');
+const getListField = require('@ocap/util/lib/get-list-field');
 const { BN, fromUnitToToken } = require('@ocap/util');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
 const { account, stake, Joi } = require('@ocap/state');
@@ -9,19 +10,22 @@ const { toStakeAddress } = require('@arcblock/did-util');
 const debug = require('debug')(`${require('../../../package.json').name}:withdraw-token`);
 
 const VerifyPaused = require('../rollup/pipes/verify-paused');
-const { applyTokenUpdates } = require('../../util');
+const { applyTokenUpdates, getTxFee, getBNSum, getRewardLocker } = require('../../util');
+
+const verifyMultiSigV2 = pipes.VerifyMultiSigV2({ signersKey: 'signers' });
 
 const schema = Joi.object({
   token: Joi.tokenInputSchema.required(),
   to: Joi.DID().wallet('ethereum').required(),
   rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  proposer: Joi.DID().wallet('ethereum').optional().allow('').default(''),
+  actualFee: Joi.BN().min(0).required(),
+  maxFee: Joi.BN().min(0).required(),
   data: Joi.any().optional(),
 }).options({ stripUnknown: true, noDefaults: false });
 
 const runner = new Runner();
 
-runner.use(pipes.VerifyMultiSig(0));
-
 // 1. verify itx
 runner.use(({ tx, itx }, next) => {
   const { error } = schema.validate(itx);
@@ -48,18 +52,14 @@ runner.use((context, next) => {
   return next();
 });
 
-// 5. verify token state
-runner.use(
-  pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })
-);
+// 3. verify token state
+runner.use(pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })); // prettier-ignore
 
-// 6. verify sender and signer states
-runner.use(
-  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
-);
+// 4. 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.VerifyAccountMigration({ senderKey: 'senderState' }));
 
-// 7. verify amount
+// 5. verify amount
 runner.use((context, next) => {
   const { tx, itx, tokenState, rollupState } = context;
 
@@ -85,18 +85,71 @@ runner.use((context, next) => {
   }
 
   // user balance
-  context.tokenConditions = { owner: tx.from, tokens: [itx.token] };
+  const maxAmount = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+  context.tokenConditions = { owner: tx.from, tokens: [{ address: itx.token.address, value: maxAmount }] };
 
   return next();
 });
 runner.use(pipes.VerifyTokenBalance({ ownerKey: 'senderState', conditionKey: 'tokenConditions' }));
 
+// 6. verify actualFee
+runner.use((context, next) => {
+  const { itx, rollupState, tokenState } = context;
+  const { withdrawFeeRate, maxWithdrawFee, minWithdrawFee } = rollupState;
+
+  const isFixedFee = new BN(itx.maxFee).isZero();
+  if (isFixedFee) {
+    const { reward } = getTxFee({
+      amount: itx.token.value,
+      feeRate: withdrawFeeRate,
+      maxFee: maxWithdrawFee,
+      minFee: minWithdrawFee,
+    });
+
+    if (new BN(itx.actualFee).lt(new BN(reward))) {
+      const expected = fromUnitToToken(reward, tokenState.decimal);
+      const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
+      return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
+    }
+  }
+
+  return next();
+});
+
+// 7. verify maxFee and conditional multi-sig
+// eslint-disable-next-line consistent-return
+runner.use((context, next) => {
+  const { tx, itx } = context;
+  const isFixedFee = new BN(itx.maxFee).isZero();
+  if (isFixedFee) {
+    return next();
+  }
+
+  const signatures = getListField(tx, 'signatures');
+
+  // ensure signature count
+  if (signatures.length !== 1) {
+    return next(new Error('INVALID_TX', 'Withdraw with maxFee should have one multi-sig'));
+  }
+
+  // ensure proposer in signer list
+  if (signatures.some((x) => x.signer === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer must exist in tx.signatures'));
+  }
+
+  // ensure signature is valid
+  context.signers = signatures.map((x) => x.signer);
+  verifyMultiSigV2(context, next);
+});
+
 // 8. verify staking: user withdraw is locked in stake
 runner.use((context, next) => {
   const { itx, senderState } = context;
   context.stakeAddress = toStakeAddress(senderState.address, itx.rollup);
+  context.lockerAddress = getRewardLocker(itx.rollup);
   return next();
 });
+runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'OK', table: 'stake' }));
 runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'OK', table: 'stake' }));
 runner.use((context, next) => {
   const { stakeState } = context;
@@ -110,17 +163,28 @@ runner.use((context, next) => {
 // 8. update state: the fee splitting and token burning is done when withdraw finalized in rollup-block
 runner.use(
   async (context, next) => {
-    const { tx, itx, statedb, stakeState, senderState, stakeAddress } = context;
-    const updatedAccounts = []; // for generating receipts
-    const { address, value } = itx.token;
+    const { tx, itx, statedb, stakeState, senderState, lockerState, lockerAddress, stakeAddress } = context;
+
+    const total = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+    const fee = getBNSum(itx.actualFee, itx.maxFee);
+
+    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: total }], senderState, 'sub');
 
-    const senderUpdates = applyTokenUpdates([itx.token], senderState, 'sub');
-    const stakeUpdates = applyTokenUpdates([itx.token], stakeState || {}, 'add');
+    // Burned amount should equal to user received amount
+    const stakeUpdates = applyTokenUpdates(
+      [{ address: itx.token.address, value: itx.token.value }],
+      stakeState || {},
+      'add'
+    );
 
-    updatedAccounts.push({ address: senderState.address, token: address, delta: `-${value}`, action: 'lock' });
-    updatedAccounts.push({ address: stakeAddress, token: address, delta: value, action: 'lock' });
+    // Fees are locked to reward locker, and funded later
+    const lockerUpdates = applyTokenUpdates(
+      [{ address: itx.token.address, value: fee }],
+      lockerState || { tokens: {} },
+      'add'
+    );
 
-    const [newSenderState, newStakeState] = await Promise.all([
+    const [newSenderState, newStakeState, newLockerState] = await Promise.all([
       // update user account
       statedb.account.update(
         senderState.address,
@@ -147,13 +211,40 @@ runner.use(
             ),
             context
           ),
+
+      // Update pending fee locker state
+      lockerState
+        ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context)
+        : statedb.stake.create(
+            lockerAddress,
+            stake.create(
+              {
+                address: lockerAddress,
+                sender: itx.rollup,
+                receiver: itx.rollup,
+                revocable: false,
+                message: 'pending-block-reward',
+                revokeWaitingPeriod: 0,
+                ...lockerUpdates,
+              },
+              context
+            ),
+            context
+          ),
     ]);
 
     context.senderState = newSenderState;
     context.stakeState = newStakeState;
-    context.updatedAccounts = updatedAccounts;
+    context.lockerState = newLockerState;
+    context.stakeStates = [newStakeState, newLockerState];
+
+    context.updatedAccounts = [
+      { address: senderState.address, token: itx.token.address, delta: `-${total}`, action: 'lock' },
+      { address: stakeAddress, token: itx.token.address, delta: itx.token.value, action: 'lock' },
+      { address: lockerAddress, token: itx.token.address, delta: fee, action: 'pending' },
+    ];
 
-    debug('withdraw-token-v2', { itx, senderUpdates });
+    debug('withdraw-token-v2', itx);
 
     next();
   },

package/lib/util.js

@@ -1,9 +1,13 @@
+const groupBy = require('lodash/groupBy');
+const flattenDeep = require('lodash/flattenDeep');
+const Error = require('@ocap/util/lib/error');
 const { BN } = require('@ocap/util');
 const { decodeAny } = require('@ocap/message');
 const { toStakeAddress } = require('@arcblock/did-util');
 const cloneDeep = require('lodash/cloneDeep');
 
 const ZERO = new BN(0);
+const RATE_BASE = new BN(10000);
 
 const decodeAnyNested = (encoded) => {
   if (!encoded) {
@@ -50,7 +54,7 @@ const decodeAnySafe = (encoded) => {
 
 const applyTokenUpdates = (tokens, state, operator) => {
   if (['add', 'sub'].includes(operator) === false) {
-    throw new Error(`Invalid operator when applyTokenUpdates: ${operator}`);
+    throw new Error('FORBIDDEN', `Invalid operator when applyTokenUpdates: ${operator}`);
   }
 
   if (!state) {
@@ -65,7 +69,7 @@ const applyTokenUpdates = (tokens, state, operator) => {
     const balance = new BN(oldTokens[address] || 0);
     const newBalance = balance[operator](requirement);
     if (newBalance.lt(ZERO)) {
-      throw new Error(`Negative token balance when applyTokenUpdates for ${address}`);
+      throw new Error('FORBIDDEN', `Negative token balance when applyTokenUpdates for ${address}`);
     }
     newTokens[address] = newBalance.toString(10);
   }
@@ -75,10 +79,11 @@ const applyTokenUpdates = (tokens, state, operator) => {
   };
 };
 const applyTokenChange = (state, change) => {
-  if (change.delta.gt(ZERO)) {
-    return applyTokenUpdates([{ address: change.token, value: change.delta.toString(10) }], state, 'add');
+  const delta = typeof change.delta === 'string' ? new BN(change.delta) : change.delta;
+  if (delta.gt(ZERO)) {
+    return applyTokenUpdates([{ address: change.token, value: delta.toString(10) }], state, 'add');
   }
-  return applyTokenUpdates([{ address: change.token, value: change.delta.abs().toString(10) }], state, 'sub');
+  return applyTokenUpdates([{ address: change.token, value: delta.abs().toString(10) }], state, 'sub');
 };
 
 const fixTokenInput = (input, config) => {
@@ -91,54 +96,221 @@ const fixTokenInput = (input, config) => {
   return input;
 };
 
-const RATE_BASE = new BN(10000);
-const splitBlockReward = ({ total, feeRate, maxFee, minFee, shares = {}, stringify = true }) => {
+const getTxFee = ({ amount, feeRate, maxFee, minFee, stringify = true }) => {
+  const userAmount = new BN(amount);
   const maxFeeAmount = new BN(maxFee);
   const minFeeAmount = new BN(minFee);
-  const totalAmount = new BN(total);
+
+  if (feeRate < 0) {
+    throw new Error('FORBIDDEN', 'Unexpected negative feeRate when getTxFee, abort!');
+  }
+  if (userAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative amount when getTxFee, abort!');
+  }
+  if (maxFeeAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative maxFee when getTxFee, abort!');
+  }
+  if (minFeeAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative minFee when getTxFee, abort!');
+  }
 
   // total fee
-  let feeAmount = totalAmount.mul(new BN(feeRate)).div(RATE_BASE);
-  if (feeAmount.lt(minFeeAmount)) {
-    feeAmount = minFeeAmount;
+  let rewardAmount = userAmount.mul(new BN(feeRate)).div(RATE_BASE);
+  if (rewardAmount.lt(minFeeAmount)) {
+    rewardAmount = minFeeAmount;
   }
-  if (feeAmount.gt(maxFeeAmount)) {
-    feeAmount = maxFeeAmount;
+  if (rewardAmount.gt(maxFeeAmount)) {
+    rewardAmount = maxFeeAmount;
   }
 
-  // fee shares
-  const feeShares = Object.keys(shares).reduce((acc, x) => {
-    acc[x] = feeAmount.mul(new BN(shares[x])).div(RATE_BASE);
-    return acc;
-  }, {});
+  // total amount
+  const totalAmount = userAmount.add(rewardAmount);
 
   if (stringify) {
     return {
       total: totalAmount.toString(10),
-      fee: feeAmount.toString(10),
-      user: totalAmount.sub(feeAmount).toString(10),
-      feeShares: Object.keys(feeShares).reduce((acc, x) => {
-        acc[x] = feeShares[x].toString(10);
-        return acc;
-      }, {}),
+      user: userAmount.toString(10),
+      reward: rewardAmount.toString(10),
     };
   }
 
   return {
     total: totalAmount,
-    fee: feeAmount,
-    user: totalAmount.sub(feeAmount),
-    feeShares,
+    user: userAmount,
+    reward: rewardAmount,
   };
 };
 
-const getBlockRewardLocker = (rollupAddress) => toStakeAddress(rollupAddress, rollupAddress);
+const splitTxFee = ({ total, shares = {}, stringify = true }) => {
+  const totalAmount = new BN(total);
+  if (totalAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative total when splitTxFee, abort!');
+  }
+  Object.keys(shares).forEach((key) => {
+    if (shares[key] < 0) {
+      throw new Error('FORBIDDEN', `Unexpected negative shares[${key}] when splitTxFee, abort!`);
+    }
+  });
+
+  const rewardShares = Object.keys(shares).reduce((acc, x) => {
+    acc[x] = totalAmount.mul(new BN(shares[x])).div(RATE_BASE);
+    return acc;
+  }, {});
+
+  return Object.keys(rewardShares).reduce((acc, x) => {
+    acc[x] = stringify ? rewardShares[x].toString(10) : rewardShares[x];
+    return acc;
+  }, {});
+};
+
+const getRewardLocker = (rollupAddress) => toStakeAddress(rollupAddress, rollupAddress);
+const getBNSum = (...args) => flattenDeep(args).reduce((sum, x) => sum.add(new BN(x)), new BN(0)).toString(10); // prettier-ignore
+const isFixedFee = (x) => !x.tx.itxJson.maxFee || new BN(x.tx.itxJson.maxFee).isZero();
+
+const ensureBlockReward = (rollupState, minReward, txStates) => {
+  const { address, withdrawFeeRate, minWithdrawFee, maxWithdrawFee, tokenAddress } = rollupState;
+  const locker = getRewardLocker(address);
+
+  const result = {
+    mintedAmount: new BN(0),
+    burnedAmount: new BN(0),
+    rewardAmount: new BN(0),
+  };
+
+  // 0. ensure reward requirement
+  const maxPossibleReward = txStates.reduce(
+    (sum, x) => sum.add(new BN(isFixedFee(x) ? x.tx.itxJson.actualFee : x.tx.itxJson.maxFee)),
+    new BN(0)
+  );
+  const minRequiredReward = new BN(minReward);
+  if (maxPossibleReward.lt(minRequiredReward)) {
+    throw new Error('INVALID_BLOCK', 'Block reward does not match minReward requirement');
+  }
+
+  // 1. find dynamic reward tx
+  const dynamicFeeTxs = txStates.filter((x) => isFixedFee(x) === false);
+  const totalDynamicFee = dynamicFeeTxs.reduce((sum, x) => sum.add(new BN(x.tx.itxJson.maxFee)), new BN(0));
+
+  const fixedFeeTxs = txStates.filter((x) => isFixedFee(x));
+  const totalFixedFee = fixedFeeTxs.reduce((sum, x) => sum.add(new BN(x.tx.itxJson.actualFee)), new BN(0));
+
+  const totalMissingFee = minRequiredReward.sub(totalFixedFee);
+
+  // 2. calculate actual reward for each dynamic reward tx, mark tx to be updated
+  const changes = { stake: [], account: [] };
+  dynamicFeeTxs.forEach((x) => {
+    const maxFee = new BN(x.tx.itxJson.maxFee);
+    let actualFee = new BN(0);
+    // If totalMissingFee is less than 0, then the tx will be charged for fixedFee
+    if (totalMissingFee.lt(ZERO)) {
+      const fee = getTxFee({
+        amount: x.tx.itxJson.token.value,
+        feeRate: withdrawFeeRate,
+        maxFee: maxWithdrawFee,
+        minFee: minWithdrawFee,
+        stringify: false,
+      });
+      actualFee = fee.reward;
+    } else {
+      // Else the tx is charged for a portion of totalMissingFee
+      actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
+    }
+
+    if (actualFee.lt(ZERO)) {
+      throw new Error('FORBIDDEN', 'Got negative actualFee for tx, abort!');
+    }
+
+    // If the actualFee is less than the maxFee, user will have a refund
+    if (actualFee.lt(maxFee)) {
+      const refundFee = maxFee.sub(actualFee).toString(10);
+      changes.account.push({
+        address: x.tx.from,
+        delta: refundFee,
+        action: 'refund',
+      });
+      changes.stake.push({
+        address: locker,
+        delta: `-${refundFee}`,
+        action: 'refund',
+      });
+    }
+
+    x.tx.itxJson.actualFee = actualFee.toString(10);
+  });
+
+  // 3. bur/mint tokens, update stakes
+  txStates.forEach((x) => {
+    const user = x.tx.itxJson.token.value;
+    const fee = x.tx.itxJson.actualFee;
+    const total = getBNSum(user, fee);
+
+    if (x.type === 'deposit_token_v2') {
+      result.rewardAmount = result.rewardAmount.add(new BN(fee));
+      result.mintedAmount = result.mintedAmount.add(new BN(total));
+
+      // mint tokens for deposit proposer
+      changes.stake.push({
+        address: toStakeAddress(x.tx.itxJson.proposer, address),
+        delta: total,
+        action: 'mint',
+      });
+    } else if (x.type === 'withdraw_token_v2') {
+      result.rewardAmount = result.rewardAmount.add(new BN(fee));
+      result.burnedAmount = result.burnedAmount.add(new BN(user));
+
+      // burn tokens from locked withdraws: user amount
+      changes.stake.push({
+        address: toStakeAddress(x.tx.from, address),
+        delta: `-${user}`,
+        action: 'burn',
+      });
+    }
+  });
+
+  const grouped = {
+    stake: groupBy(changes.stake, 'address'),
+    account: groupBy(changes.account, 'address'),
+  };
+
+  result.stakeUpdates = Object.keys(grouped.stake).reduce((acc, x) => {
+    acc[x] = {
+      address: x,
+      token: tokenAddress,
+      delta: getBNSum(...grouped.stake[x].map((c) => c.delta)),
+      action: grouped.stake[x][grouped.stake[x].length - 1].action,
+    };
+
+    return acc;
+  }, {});
+
+  result.accountUpdates = Object.keys(grouped.account).reduce((acc, x) => {
+    acc[x] = {
+      address: x,
+      token: tokenAddress,
+      delta: getBNSum(...grouped.account[x].map((c) => c.delta)),
+      action: grouped.account[x][grouped.account[x].length - 1].action,
+    };
+
+    return acc;
+  }, {});
+
+  result.mintedAmount = result.mintedAmount.toString(10);
+  result.burnedAmount = result.burnedAmount.toString(10);
+  result.rewardAmount = result.rewardAmount.toString(10);
+
+  return result;
+};
 
 module.exports = {
   decodeAnySafe,
   applyTokenUpdates,
   applyTokenChange,
   fixTokenInput,
-  splitBlockReward,
-  getBlockRewardLocker,
+  getTxFee,
+  splitTxFee,
+  getRewardLocker,
+  ensureBlockReward,
+  getBNSum,
+  isFixedFee,
+  RATE_BASE,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.13.60",
+  "version": "1.13.64",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -19,16 +19,16 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "1.13.60",
-    "@arcblock/did-util": "1.13.60",
-    "@ocap/asset": "1.13.60",
-    "@ocap/mcrypto": "1.13.60",
-    "@ocap/merkle-tree": "1.13.60",
-    "@ocap/message": "1.13.60",
-    "@ocap/state": "1.13.60",
-    "@ocap/tx-pipeline": "1.13.60",
-    "@ocap/util": "1.13.60",
-    "@ocap/wallet": "1.13.60",
+    "@arcblock/did": "1.13.64",
+    "@arcblock/did-util": "1.13.64",
+    "@ocap/asset": "1.13.64",
+    "@ocap/mcrypto": "1.13.64",
+    "@ocap/merkle-tree": "1.13.64",
+    "@ocap/message": "1.13.64",
+    "@ocap/state": "1.13.64",
+    "@ocap/tx-pipeline": "1.13.64",
+    "@ocap/util": "1.13.64",
+    "@ocap/wallet": "1.13.64",
     "debug": "^4.3.2",
     "empty-value": "^1.0.1",
     "lodash": "^4.17.21",
@@ -41,5 +41,5 @@
   "devDependencies": {
     "jest": "^27.3.1"
   },
-  "gitHead": "2afb4dd279effb31bd28a2024789d50631819789"
+  "gitHead": "49c94d9fd5f12ec63c34ad609d041a92f68322a8"
 }