@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/util.js

@@ -1,5 +1,328 @@
+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 decodeItxData = (encoded) => (encoded ? decodeAny(encoded) : null);
+const ZERO = new BN(0);
+const RATE_BASE = new BN(10000);
 
-module.exports = { decodeItxData };
+const decodeAnyNested = (encoded) => {
+  if (!encoded) {
+    return encoded;
+  }
+
+  if (Array.isArray(encoded)) {
+    return encoded.map((k) => decodeAnyNested(k));
+  }
+
+  if (typeof encoded === 'object') {
+    if (encoded.typeUrl && encoded.value) {
+      const result = decodeAny(encoded);
+      result.value = decodeAnyNested(result.value);
+      return result;
+    }
+
+    return Object.keys(encoded).reduce((acc, x) => {
+      acc[x] = decodeAnyNested(encoded[x]);
+      return acc;
+    }, {});
+  }
+
+  return encoded;
+};
+
+const decodeAnySafe = (encoded) => {
+  if (!encoded) {
+    return null;
+  }
+
+  try {
+    const decoded = decodeAny(encoded);
+    if (decoded.value && typeof decoded.value === 'object') {
+      decoded.value = decodeAnyNested(decoded.value);
+    }
+
+    return decoded;
+  } catch (err) {
+    console.error('decodeAnySafe failed', err);
+    return null;
+  }
+};
+
+const applyTokenUpdates = (tokens, state, operator) => {
+  if (['add', 'sub'].includes(operator) === false) {
+    throw new Error('UNEXPECTED_OPERATOR', `Invalid operator when applyTokenUpdates: ${operator}`);
+  }
+
+  if (!state) {
+    return {};
+  }
+
+  const oldTokens = state.tokens || {};
+  const newTokens = cloneDeep(oldTokens);
+  for (let i = 0; i < tokens.length; i++) {
+    const { address, value } = tokens[i];
+    const requirement = new BN(value);
+    const balance = new BN(oldTokens[address] || 0);
+    const newBalance = balance[operator](requirement);
+    if (newBalance.lt(ZERO)) {
+      throw new Error('NEGATIVE_TOKEN_BALANCE', `Negative token balance when applyTokenUpdates for ${address}`);
+    }
+    newTokens[address] = newBalance.toString(10);
+  }
+
+  return {
+    tokens: newTokens,
+  };
+};
+const applyTokenChange = (state, change) => {
+  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: delta.abs().toString(10) }], state, 'sub');
+};
+
+const fixTokenInput = (input, config) => {
+  input.tokensList.forEach((t) => {
+    if (!t.address) {
+      t.address = config.token.address;
+    }
+  });
+
+  return input;
+};
+
+const getTxFee = ({ amount, feeRate, maxFee, minFee, stringify = true }) => {
+  const userAmount = new BN(amount);
+  const maxFeeAmount = new BN(maxFee);
+  const minFeeAmount = new BN(minFee);
+
+  if (feeRate < 0) {
+    throw new Error('NEGATIVE_FEE_RATE', 'Unexpected negative feeRate when getTxFee, abort!');
+  }
+  if (userAmount.lt(ZERO)) {
+    throw new Error('NEGATIVE_AMOUNT', 'Unexpected negative amount when getTxFee, abort!');
+  }
+  if (maxFeeAmount.lt(ZERO)) {
+    throw new Error('NEGATIVE_MAX_FEE', 'Unexpected negative maxFee when getTxFee, abort!');
+  }
+  if (minFeeAmount.lt(ZERO)) {
+    throw new Error('NEGATIVE_MIN_FEE', 'Unexpected negative minFee when getTxFee, abort!');
+  }
+
+  // total fee
+  let rewardAmount = userAmount.mul(new BN(feeRate)).div(RATE_BASE);
+  if (rewardAmount.lt(minFeeAmount)) {
+    rewardAmount = minFeeAmount;
+  }
+  if (rewardAmount.gt(maxFeeAmount)) {
+    rewardAmount = maxFeeAmount;
+  }
+
+  // total amount
+  const totalAmount = userAmount.add(rewardAmount);
+
+  if (stringify) {
+    return {
+      total: totalAmount.toString(10),
+      user: userAmount.toString(10),
+      reward: rewardAmount.toString(10),
+    };
+  }
+
+  return {
+    total: totalAmount,
+    user: userAmount,
+    reward: rewardAmount,
+  };
+};
+
+const splitTxFee = ({ total, shares = {}, stringify = true }) => {
+  const totalAmount = new BN(total);
+  if (totalAmount.lt(ZERO)) {
+    throw new Error('NEGATIVE_TOTAL_AMOUNT', 'Unexpected negative total when splitTxFee, abort!');
+  }
+  Object.keys(shares).forEach((key) => {
+    if (shares[key] < 0) {
+      throw new Error('NEGATIVE_FEE_SHARE', `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 minTxFee = minRequiredReward.div(new BN(txStates.length));
+  const changes = { stake: [], account: [] };
+  dynamicFeeTxs.forEach((x) => {
+    const maxFee = new BN(x.tx.itxJson.maxFee);
+    const defaults = getTxFee({
+      amount: x.tx.itxJson.token.value,
+      feeRate: withdrawFeeRate,
+      maxFee: maxWithdrawFee,
+      minFee: minWithdrawFee,
+      stringify: false,
+    });
+
+    let actualFee = new BN(0);
+    // If totalMissingFee is less than 0, then the tx will be charged for fixedFee
+    if (totalMissingFee.lt(ZERO)) {
+      actualFee = defaults.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('NEGATIVE_ACTUAL_FEE', 'Got negative actualFee for tx, abort!');
+    }
+
+    // If the actualFee is less than default fee, user will be charged the default fee
+    if (actualFee.lt(defaults.reward)) {
+      actualFee = defaults.reward;
+    }
+
+    // If the actualFee is less than minTxFee, user will be charged the minTxFee
+    if (actualFee.lt(minTxFee)) {
+      actualFee = minTxFee;
+    }
+
+    // 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,
+  getTxFee,
+  splitTxFee,
+  getRewardLocker,
+  ensureBlockReward,
+  getBNSum,
+  isFixedFee,
+  RATE_BASE,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.3",
+  "version": "1.6.10",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -12,32 +12,39 @@
   "scripts": {
     "lint": "eslint tests lib",
     "lint:fix": "eslint --fix tests lib",
-    "test": "node tools/jest.js",
-    "coverage": "npm run test -- --coverage"
+    "start": "node tools/start-chain.js",
+    "test": "jest --forceExit --detectOpenHandles",
+    "test:ci": "jest --forceExit --detectOpenHandles --coverage",
+    "coverage": "start-server-and-test start http://127.0.0.1:4001 test:ci"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "^1.6.3",
-    "@arcblock/did-util": "^1.6.3",
-    "@ocap/mcrypto": "^1.6.3",
-    "@ocap/message": "^1.6.3",
-    "@ocap/sdk": "^1.6.3",
-    "@ocap/state": "^1.6.3",
-    "@ocap/tx-pipeline": "^1.6.3",
-    "@ocap/util": "^1.6.3",
-    "@ocap/wallet": "^1.6.3",
-    "debug": "^4.3.1",
+    "@arcblock/did": "1.6.10",
+    "@arcblock/did-util": "1.6.10",
+    "@arcblock/validator": "1.6.10",
+    "@ocap/asset": "1.6.10",
+    "@ocap/mcrypto": "1.6.10",
+    "@ocap/merkle-tree": "1.6.10",
+    "@ocap/message": "1.6.10",
+    "@ocap/state": "1.6.10",
+    "@ocap/tx-pipeline": "1.6.10",
+    "@ocap/util": "1.6.10",
+    "@ocap/wallet": "1.6.10",
+    "debug": "^4.3.3",
+    "deep-diff": "^1.0.2",
     "empty-value": "^1.0.1",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "url-join": "^4.0.1"
   },
   "resolutions": {
     "bn.js": "5.1.3",
     "elliptic": "6.5.3"
   },
   "devDependencies": {
-    "jest": "^26.6.3"
+    "jest": "^27.3.1",
+    "start-server-and-test": "^1.14.0"
   },
-  "gitHead": "5246168dbbc268a3e6f95c3992d9d343647ca25b"
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
 }

package/lib/protocols/misc/poke.js

@@ -1,106 +0,0 @@
-const get = require('lodash/get');
-const padStart = require('lodash/padStart');
-const { account } = require('@ocap/state');
-const { Runner, Error, pipes } = require('@ocap/tx-pipeline');
-const { toBN, fromTokenToUnit } = require('@ocap/util');
-
-// eslint-disable-next-line global-require
-const debug = require('debug')(`${require('../../../package.json').name}:declare`);
-
-const runner = new Runner();
-
-runner.use(pipes.VerifyMultiSig(0));
-
-// Verify itx
-runner.use(
-  pipes.VerifyInfo([
-    {
-      error: 'FORBIDDEN',
-      message: 'Poke is not enabled for this ledger',
-      fn: ({ config }) => get(config, 'transaction.poke.enabled') === true,
-    },
-    {
-      error: 'INVALID_NONCE',
-      message: 'Poke transaction must set nonce to 0',
-      fn: ({ tx }) => tx.nonce === 0,
-    },
-    {
-      error: 'INSUFFICIENT_DATA',
-      message: 'itx.date and itx.address must be set',
-      fn: ({ itx }) => itx.date && itx.address,
-    },
-    {
-      error: 'INVALID_TX',
-      message: 'Poke config invalid or receiver address invalid',
-      fn: ({ itx, config }) => {
-        const pokeAccount = config.accounts.find((x) => !x.pk);
-        return pokeAccount && itx.address === pokeAccount.address;
-      },
-    },
-    {
-      error: 'INVALID_TX',
-      message: 'Poke date must be set to current date',
-      fn: ({ itx }) => {
-        const now = new Date();
-        const year = now.getUTCFullYear();
-        const month = now.getUTCMonth() + 1;
-        const day = now.getUTCDate();
-        const date = `${year}-${padStart(month, 2, '0')}-${padStart(day, 2, '0')}`;
-
-        return itx.date === date;
-      },
-    },
-  ])
-);
-
-// Ensure sender does not exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState' }));
-runner.use(pipes.VerifySender({ state: 'senderState' }));
-runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
-
-// The receiver must exist in the ledger
-runner.use(pipes.ExtractState({ from: 'itx.address', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
-
-// Create account state
-runner.use(async (context, next) => {
-  const { itx, statedb, config, senderState, receiverState } = context;
-
-  const decimal = get(config, 'token.decimal');
-  const amount = get(config, 'transaction.poke.amount');
-  const delta = fromTokenToUnit(amount, decimal);
-
-  if (senderState.poke && senderState.poke.date === itx.date) {
-    return next(new Error('INVALID_TX', `Sender already poked on ${itx.date}`));
-  }
-
-  const senderBalance = toBN(senderState.balance);
-  const receiverBalance = toBN(receiverState.balance);
-  if (delta.gt(receiverBalance)) {
-    return next(new Error('INSUFFICIENT_FUND', 'Receiver does not have enough balance for poke'));
-  }
-
-  const newSenderState = account.update(
-    senderState,
-    {
-      balance: senderBalance.add(delta).toString(),
-      poke: { date: itx.date },
-    },
-    context
-  );
-  const newReceiverState = account.update(receiverState, { balance: receiverBalance.sub(delta).toString() }, context);
-
-  context.senderState = newSenderState;
-  context.receiverState = newReceiverState;
-
-  debug('sender', newSenderState);
-  debug('receiver', newReceiverState);
-
-  await Promise.all([
-    statedb.account.update(senderState.address, newSenderState, context),
-    statedb.account.update(receiverState.address, newReceiverState, context),
-  ]);
-
-  return next();
-});
-
-module.exports = runner;

package/lib/protocols/trade/exchange.js

@@ -1,139 +0,0 @@
-const get = require('lodash/get');
-const isEmpty = require('empty-value');
-const getListField = require('@ocap/util/lib/get-list-field');
-const { decodeBigInt } = require('@ocap/message');
-const { fromUnitToToken, toBN } = require('@ocap/util');
-const { Runner, pipes } = require('@ocap/tx-pipeline');
-const { account } = require('@ocap/state');
-
-// eslint-disable-next-line global-require
-const debug = require('debug')(`${require('../../../package.json').name}:exchange`);
-
-const runner = new Runner();
-
-runner.use(pipes.VerifyMultiSig(1));
-runner.use(pipes.ExtractReceiver({ from: ['itx.to', 'tx.signaturesList', 'tx.signatures'] }));
-
-runner.use(
-  pipes.VerifyInfo([
-    {
-      error: 'INSUFFICIENT_DATA',
-      fn: ({ itx }) => itx.sender && itx.receiver,
-    },
-    {
-      error: 'INVALID_TX',
-      message: 'Can not exchange without any token or assets',
-      fn: (context) => {
-        const { itx, config } = context;
-        const decimal = get(config, 'token.decimal');
-
-        context.senderAssets = getListField(itx, 'sender.assets');
-        context.receiverAssets = getListField(itx, 'receiver.assets');
-        context.senderAmount = itx.sender.value ? decodeBigInt(itx.sender.value) : 0;
-        context.receiverAmount = itx.receiver.value ? decodeBigInt(itx.receiver.value) : 0;
-
-        if (Number(fromUnitToToken(context.senderAmount, decimal)) <= 0 && isEmpty(context.senderAssets)) {
-          return false;
-        }
-        if (Number(fromUnitToToken(context.receiverAmount, decimal)) <= 0 && isEmpty(context.receiverAssets)) {
-          return false;
-        }
-
-        return true;
-      },
-    },
-  ])
-);
-
-// TODO: verify-expiration
-
-runner.use(pipes.VerifySigner({ signer: 'itx.to' }));
-runner.use(pipes.VerifyItxSize({ value: ['senderAssets', 'receiverAssets'] }));
-
-// TODO: anti-replay-exchange-attack
-
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
-runner.use(pipes.VerifyBalance({ state: 'senderState', value: 'itx.sender.value' }));
-
-runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK' }));
-runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
-runner.use(pipes.ExtractSigner({ signerKey: 'signerStates', delegatorKey: 'delegatorStates' }));
-runner.use(
-  pipes.VerifyDelegation({
-    type: 'multisig',
-    signerKey: 'signerStates',
-    delegatorKey: 'delegatorStates',
-    delegationKey: 'delegationStates',
-  })
-);
-
-runner.use(pipes.ExtractState({ from: 'receiver', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
-runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState', signerKey: 'signerStates' }));
-runner.use(pipes.VerifyBalance({ state: 'receiverState', value: 'itx.receiver.value' }));
-
-runner.use(pipes.AntiLandAttack({ senderState: 'senderState', receiverState: 'receiverState' }));
-
-runner.use(pipes.ExtractState({ from: 'senderAssets', to: 'priv.senderAssets', status: 'INVALID_ASSET' }));
-runner.use(pipes.VerifyTransferrable({ assets: 'priv.senderAssets' }));
-runner.use(pipes.VerifyUpdater({ assetKey: 'priv.senderAssets', ownerKey: 'senderState' }));
-
-runner.use(pipes.ExtractState({ from: 'receiverAssets', to: 'priv.receiverAssets', status: 'INVALID_ASSET' }));
-runner.use(pipes.VerifyTransferrable({ assets: 'priv.receiverAssets' }));
-runner.use(pipes.VerifyUpdater({ assetKey: 'priv.receiverAssets', ownerKey: 'receiverState' }));
-
-runner.use(pipes.UpdateOwner({ assets: 'priv.senderAssets', owner: 'receiverState' }));
-runner.use(pipes.UpdateOwner({ assets: 'priv.receiverAssets', owner: 'senderState' }));
-
-runner.use(async (context, next) => {
-  const {
-    tx,
-    itx,
-    senderAssets,
-    receiverAssets,
-    senderAmount,
-    receiverAmount,
-    senderState,
-    receiverState,
-    statedb,
-  } = context;
-
-  const senderDelta = toBN(senderAmount);
-  const receiverDelta = toBN(receiverAmount);
-
-  // Update sender state
-  const newSenderState = account.update(
-    senderState,
-    {
-      balance: toBN(senderState.balance).sub(senderDelta).add(receiverDelta).toString(),
-      nonce: tx.nonce,
-      numAssets: Math.max(0, senderState.numAssets - senderAssets.length + receiverAssets.length),
-    },
-    context
-  );
-  await statedb.account.update(senderState.address, newSenderState, context);
-
-  // Update receiver state
-  const newReceiverState = account.update(
-    receiverState,
-    {
-      balance: toBN(receiverState.balance).add(senderDelta).sub(receiverDelta).toString(),
-      numAssets: Math.max(0, receiverState.numAssets + senderAssets.length - receiverAssets.length),
-    },
-    context
-  );
-  await statedb.account.update(receiverState.address, newReceiverState, context);
-
-  context.senderState = newSenderState;
-  context.receiverState = newReceiverState;
-
-  debug('exchange', {
-    from: tx.from,
-    to: itx.to,
-    sender: { assets: senderAssets.length, token: senderAmount },
-    receiver: { assets: receiverAssets.length, token: receiverAmount },
-  });
-
-  next();
-});
-
-module.exports = runner;