@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/util.js

@@ -1,442 +0,0 @@
-const groupBy = require('lodash/groupBy');
-const flattenDeep = require('lodash/flattenDeep');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { BN, fromTokenToUnit } = 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) {
-    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;
-  }
-};
-
-// If we are adding tokens to multiple states, same updates applied to all
-// If we are removing tokens from multiple states, applied sequentially
-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 states = cloneDeep((Array.isArray(state) ? state : [state]).map((x) => ({ tokens: x.tokens || {} })));
-  for (let i = 0; i < tokens.length; i++) {
-    const { address, value } = tokens[i];
-    const expectedDelta = new BN(value);
-
-    let fulfilled = new BN(0);
-    for (let j = 0; j < states.length; j++) {
-      const origin = states[j].tokens;
-      const updated = cloneDeep(origin);
-      const balance = new BN(origin[address] || 0);
-
-      let newBalance;
-      if (operator === 'add') {
-        fulfilled = fulfilled.add(expectedDelta);
-        newBalance = balance.add(expectedDelta);
-      } else {
-        const unfulfilledDelta = expectedDelta.sub(fulfilled);
-        const actualDelta = balance.lt(unfulfilledDelta) ? balance : unfulfilledDelta;
-        fulfilled = fulfilled.add(actualDelta);
-        newBalance = balance.sub(actualDelta);
-      }
-
-      updated[address] = newBalance.toString(10);
-      states[j].tokens = updated;
-    }
-
-    if (fulfilled.lt(expectedDelta)) {
-      throw new Error(
-        'INSUFFICIENT_FUND',
-        `Negative token balance when applyTokenUpdates for ${address}, expected: ${expectedDelta.toString()} fulfilled: ${fulfilled.toString()}`
-      );
-    }
-  }
-
-  return Array.isArray(state) ? states : states[0];
-};
-
-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.isNeg()) {
-    throw new Error('NEGATIVE_AMOUNT', 'Unexpected negative amount when getTxFee, abort!');
-  }
-  if (maxFeeAmount.isNeg()) {
-    throw new Error('NEGATIVE_MAX_FEE', 'Unexpected negative maxFee when getTxFee, abort!');
-  }
-  if (minFeeAmount.isNeg()) {
-    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 getDelegationRequirements = (context) => {
-  const { txType, config } = context;
-  const txFee = config.transaction.txFee[txType];
-  if (!txFee) {
-    return [];
-  }
-
-  return [
-    {
-      type: 'token',
-      address: config.token.address,
-      value: fromTokenToUnit(txFee, config.token.decimal).toString(),
-    },
-  ];
-};
-
-const splitTxFee = ({ total, shares = {}, stringify = true, rateBase = RATE_BASE }) => {
-  const totalAmount = new BN(total);
-  if (totalAmount.isNeg()) {
-    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!`);
-    }
-  });
-  if (
-    Object.values(shares)
-      .reduce((sum, x) => sum.add(new BN(x)), new BN(0))
-      .eq(rateBase) === false
-  ) {
-    throw new Error('INVALID_FEE_SHARE', 'Invalid share config when splitTxFee, abort!');
-  }
-
-  const rewardShares = Object.keys(shares).reduce((acc, x) => {
-    acc[x] = totalAmount.mul(new BN(shares[x])).div(rateBase);
-    return acc;
-  }, {});
-
-  // ensure sum of shares equals to total, to avoid floating point precision issue
-  // Adjust the first share to compensate for rounding errors
-  if (
-    Object.values(rewardShares)
-      .reduce((sum, x) => sum.add(x), new BN(0))
-      .eq(totalAmount) === false
-  ) {
-    const firstKey = Object.keys(rewardShares)[0];
-    const currentSum = Object.values(rewardShares).reduce((sum, x) => sum.add(x), new BN(0));
-    rewardShares[firstKey] = rewardShares[firstKey].add(totalAmount.sub(currentSum));
-  }
-
-  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);
-const isGovernanceTx = (x) => ['pause_rollup', 'resume_rollup', 'migrate_rollup'].includes(x.type);
-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) => isGovernanceTx(x) === false && 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) => isGovernanceTx(x) === false && 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.isNeg()) {
-      actualFee = defaults.reward;
-    } else {
-      // Else the tx is charged for a portion of totalMissingFee
-      actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
-    }
-
-    if (actualFee.isNeg()) {
-      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
-    .filter((x) => isGovernanceTx(x) === false)
-    .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;
-};
-
-const isGasStakeAddress = (sender, stakeId) => toStakeAddress(sender, sender) === stakeId;
-const isGasStakeInput = (inputs, token) => {
-  if (inputs.length !== 1) {
-    return false;
-  }
-
-  const [{ assetsList, tokensList }] = inputs;
-  if (assetsList.length > 0) {
-    return false;
-  }
-  if (tokensList.length !== 1) {
-    return false;
-  }
-
-  const [tokenInput] = tokensList;
-  if (tokenInput.address !== token) {
-    return false;
-  }
-
-  return true;
-};
-const isGasStakeValid = (state, config) => {
-  if (!state) {
-    return false;
-  }
-
-  const { token, transaction } = config;
-  const { minStake } = transaction.txGas;
-  const expectedMin = fromTokenToUnit(minStake, token.decimal);
-
-  if (state.tokens) {
-    const actualStaked = new BN(state.tokens[token.address] || 0);
-    if (actualStaked.gte(expectedMin)) {
-      return true;
-    }
-  }
-
-  if (state.revokedTokens) {
-    const actualRevoked = new BN(state.revokedTokens[token.address] || 0);
-    if (actualRevoked.gte(expectedMin)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-module.exports = {
-  decodeAnySafe,
-  applyTokenUpdates,
-  applyTokenChange,
-  fixTokenInput,
-  getTxFee,
-  splitTxFee,
-  getRewardLocker,
-  ensureBlockReward,
-  getBNSum,
-  isFixedFee,
-  isGasStakeAddress,
-  isGasStakeInput,
-  isGasStakeValid,
-  RATE_BASE,
-  getDelegationRequirements,
-};