@ocap/tx-protocols 1.13.58 → 1.13.62

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) => 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.58",
+  "version": "1.13.62",
   "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.58",
-    "@arcblock/did-util": "1.13.58",
-    "@ocap/asset": "1.13.58",
-    "@ocap/mcrypto": "1.13.58",
-    "@ocap/merkle-tree": "1.13.58",
-    "@ocap/message": "1.13.58",
-    "@ocap/state": "1.13.58",
-    "@ocap/tx-pipeline": "1.13.58",
-    "@ocap/util": "1.13.58",
-    "@ocap/wallet": "1.13.58",
+    "@arcblock/did": "1.13.62",
+    "@arcblock/did-util": "1.13.62",
+    "@ocap/asset": "1.13.62",
+    "@ocap/mcrypto": "1.13.62",
+    "@ocap/merkle-tree": "1.13.62",
+    "@ocap/message": "1.13.62",
+    "@ocap/state": "1.13.62",
+    "@ocap/tx-pipeline": "1.13.62",
+    "@ocap/util": "1.13.62",
+    "@ocap/wallet": "1.13.62",
     "debug": "^4.3.2",
     "empty-value": "^1.0.1",
     "lodash": "^4.17.21",
@@ -41,5 +41,5 @@
   "devDependencies": {
     "jest": "^27.3.1"
   },
-  "gitHead": "5eabfe8405725ee0193f76a9f7cd895d8c763e52"
+  "gitHead": "a14f8d2ade8dc0c58fd9fbf331a4eb9b842de6ed"
 }