@ocap/state 1.28.8 → 1.29.0

package/lib/states/tx.js

@@ -1,896 +0,0 @@
-const get = require('lodash/get');
-const pick = require('lodash/pick');
-const merge = require('lodash/merge');
-const groupBy = require('lodash/groupBy');
-const upperFirst = require('lodash/upperFirst');
-const camelCase = require('lodash/camelCase');
-const { fromTypeUrl, formatMessage, decodeAny } = require('@ocap/message');
-const { toBase64, BN, isBN, fromTokenToUnit } = require('@ocap/util');
-const { getListField } = require('@ocap/util/lib/get-list-field');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { getRelatedAddresses } = require('@ocap/util/lib/get-related-addr');
-const { toTypeInfo, types } = require('@arcblock/did');
-
-const ZERO = new BN(0);
-const { RoleType } = types;
-
-const FORGE_TOKEN_HOLDER = 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz';
-const FORGE_FEE_RECEIVER = 'z1EJUBdbPYqMiWHfRZvSAvbYeWcEHB19Xyfc';
-const QLDB_MIGRATION_TIME = new Date('2021-05-03T12:46:56.245Z');
-
-function eachReceipts(receipts, callback) {
-  const result = (receipts || []).map((receipt) => {
-    return (receipt.changes || []).map((change) => callback(receipt.address, change));
-  });
-
-  return result.flat();
-}
-
-function groupReceiptTokenChanges(receipts) {
-  /**
-   * Map of address to token changes
-   * @type {Record<string, {[tokenAddress: string]: string}>}
-   */
-  const tokenChanges = {};
-  // get token changes for each account by receipts
-  eachReceipts(receipts || [], (address, change) => {
-    if (toTypeInfo(change.target).role !== RoleType.ROLE_TOKEN) return;
-    if (change.value === '0') return;
-    if (!tokenChanges[address]) {
-      tokenChanges[address] = {};
-    }
-    const tokenChange = tokenChanges[address];
-    tokenChange[change.target] = new BN(tokenChange[change.target] || 0).add(new BN(change.value)).toString();
-  });
-
-  return tokenChanges;
-}
-
-// Receiver = Whose asset have net gain
-const getTxReceiver = ({ tx, itx, typeUrl }) => {
-  switch (typeUrl) {
-    case 'TransferTx':
-    case 'ExchangeTx':
-    case 'TransferV2Tx':
-    case 'ExchangeV2Tx':
-      return itx.to;
-    case 'MintAssetTx':
-      return itx.owner;
-    case 'CreateTokenTx':
-    case 'CreateAssetTx':
-    case 'AcquireAssetV2Tx':
-      return tx.delegator || tx.from;
-    case 'AcquireAssetV3Tx':
-      return itx.owner;
-    case 'SetupSwapTx':
-      return itx.receiver;
-    case 'StakeTx':
-      return itx.address;
-    default:
-      return '';
-  }
-};
-
-// Sender = Whose asset have net lose
-const getTxSender = ({ tx, typeUrl }) => {
-  switch (typeUrl) {
-    case 'TransferTx':
-    case 'TransferV2Tx':
-    case 'ExchangeTx':
-    case 'ExchangeV2Tx':
-    case 'AcquireAssetV2Tx':
-    case 'SetupSwapTx':
-    case 'WithdrawTokenTx':
-    case 'StakeTx':
-    case 'ReturnStakeTx':
-    case 'SlashStakeTx':
-      return tx.from;
-    default:
-      return '';
-  }
-};
-
-const getReceiptChange = (receipts, { address, action }) => {
-  const receipt = receipts.filter((x) => !address || x.address === address);
-  const changes = receipt.flatMap((x) => x.changes.filter((c) => !action || c.action === action));
-  return changes;
-};
-
-const getTransferReceipts = (tx) => {
-  const senderReceipt = { address: tx.from, changes: [] };
-  const receiverReceipt = { address: tx.itxJson.to, changes: [] };
-
-  if (new BN(tx.itxJson.value).gt(ZERO)) {
-    senderReceipt.changes.push({ target: '', action: 'transfer', value: `-${tx.itxJson.value}` });
-    receiverReceipt.changes.push({ target: '', action: 'transfer', value: tx.itxJson.value });
-  }
-  if (Array.isArray(tx.itxJson.tokens)) {
-    tx.itxJson.tokens.forEach((x) => {
-      senderReceipt.changes.push({ target: x.address, action: 'transfer', value: `-${x.value}` });
-      receiverReceipt.changes.push({ target: x.address, action: 'transfer', value: x.value });
-    });
-  }
-  if (Array.isArray(tx.itxJson.assets)) {
-    tx.itxJson.assets.forEach((x) => {
-      senderReceipt.changes.push({ target: x, action: 'transfer', value: '-1' });
-      receiverReceipt.changes.push({ target: x, action: 'transfer', value: '1' });
-    });
-  }
-
-  return [senderReceipt, receiverReceipt];
-};
-
-const getReceiptsFromTxInput = (inputs, symbol, action = 'transfer') => {
-  const receipts = [];
-  inputs.forEach((x) => {
-    const receipt = { address: x.owner, changes: [] };
-    getListField(x, 'tokens').forEach(({ address, value }) => {
-      receipt.changes.push({ target: address, action, value: `${symbol}${value}` });
-    });
-    getListField(x, 'assets').forEach((address) =>
-      receipt.changes.push({ target: address, action, value: `${symbol}1` })
-    );
-    receipts.push(receipt);
-  });
-
-  return receipts;
-};
-
-// TODO: this logic does not support assets yet
-const getReceiptsFromContext = (ctx) => {
-  if (Array.isArray(ctx.updatedAccounts)) {
-    const grouped = groupBy(
-      ctx.updatedAccounts.filter((x) => x.address && x.delta),
-      'address'
-    );
-    return Object.keys(grouped).map((k) => ({
-      address: k,
-      changes: grouped[k].map((x) => ({ target: x.token, action: x.action || 'transfer', value: x.delta })),
-    }));
-  }
-
-  return [];
-};
-
-/**
- * Add receipts for tx that have gasPaid but no receipts
- * This is used to handle legacy data that gas receipts were not properly recorded
- */
-const getReceiptsFromGasPaid = (tx, { config, typeUrl }) => {
-  const gasReceipt = getReceiptChange(tx.receipts || [], { action: 'gas' });
-  const gasPaid = new BN(tx.gasPaid || 0);
-
-  // For new transactions being created, gas receipts are usually attached by getReceiptsFromContext before,
-  // so we don't add duplicate gas receipts here
-  if (gasReceipt.length) return [];
-  if (gasPaid.lte(ZERO)) return [];
-
-  const gasPayerMap = {
-    AccountMigrateTx: tx.itxJson?.address,
-  };
-  const gasPayer = gasPayerMap[typeUrl] || tx.from;
-  // Cannot determine who received the gas fee in legacy data
-  const gasReceiver = config?.vaults?.txGas?.[0] || FORGE_FEE_RECEIVER;
-
-  if (!gasPayer) return [];
-
-  return [
-    { address: gasPayer, changes: [{ target: '', action: 'gas', value: gasPaid.neg().toString() }] },
-    { address: gasReceiver, changes: [{ target: '', action: 'gas', value: gasPaid.toString() }] },
-  ];
-};
-
-const getTransferV3Receipts = (tx) => [
-  ...getReceiptsFromTxInput(tx.itxJson.inputs, '-', 'transfer'),
-  ...getReceiptsFromTxInput(tx.itxJson.outputs, '', 'transfer'),
-];
-
-const getExchangeReceipts = (tx, ctx) => {
-  const { senderState, receiverState } = ctx;
-  const { sender, receiver } = tx.itxJson;
-  const senderReceipt = { address: senderState ? senderState.address : tx.from, changes: [] };
-  const receiverReceipt = { address: receiverState ? receiverState.address : tx.itxJson.to, changes: [] };
-
-  if (new BN(sender.value).gt(ZERO)) {
-    senderReceipt.changes.push({ target: '', action: 'transfer', value: `-${sender.value}` });
-    receiverReceipt.changes.push({ target: '', action: 'transfer', value: sender.value });
-  }
-  if (new BN(receiver.value).gt(ZERO)) {
-    receiverReceipt.changes.push({ target: '', action: 'transfer', value: `-${receiver.value}` });
-    senderReceipt.changes.push({ target: '', action: 'transfer', value: receiver.value });
-  }
-
-  if (Array.isArray(sender.tokens)) {
-    sender.tokens.forEach((x) => {
-      senderReceipt.changes.push({ target: x.address, action: 'transfer', value: `-${x.value}` });
-      receiverReceipt.changes.push({ target: x.address, action: 'transfer', value: x.value });
-    });
-  }
-  if (Array.isArray(receiver.tokens)) {
-    receiver.tokens.forEach((x) => {
-      receiverReceipt.changes.push({ target: x.address, action: 'transfer', value: `-${x.value}` });
-      senderReceipt.changes.push({ target: x.address, action: 'transfer', value: x.value });
-    });
-  }
-
-  if (Array.isArray(sender.assets)) {
-    sender.assets.forEach((x) => {
-      senderReceipt.changes.push({ target: x, action: 'transfer', value: '-1' });
-      receiverReceipt.changes.push({ target: x, action: 'transfer', value: '1' });
-    });
-  }
-  if (Array.isArray(receiver.assets)) {
-    receiver.assets.forEach((x) => {
-      receiverReceipt.changes.push({ target: x, action: 'transfer', value: '-1' });
-      senderReceipt.changes.push({ target: x, action: 'transfer', value: '1' });
-    });
-  }
-
-  return [senderReceipt, receiverReceipt];
-};
-
-const getCreateAssetReceipts = (tx) => {
-  const owner = tx.delegator || tx.from;
-  const ownerReceipt = { address: owner, changes: [{ target: tx.itxJson.address, action: 'create', value: '1' }] };
-  return [ownerReceipt];
-};
-
-const getMintAssetReceipts = (tx, ctx) => {
-  const { assets = [], address, owner } = tx.itxJson;
-  const ownerReceipt = {
-    address: ctx.ownerAddress || owner,
-    changes: [{ target: address, action: 'mint', value: '1' }],
-  };
-  assets.map((x) => ownerReceipt.changes.push({ target: x, action: 'consume', value: '-1' }));
-  return [ownerReceipt];
-};
-
-const getAcquireAssetReceipts = (tx, ctx) => {
-  const { assets = [], address } = tx.itxJson;
-  const delegator = tx.delegator || tx.from;
-
-  const ownerReceipt = { address: delegator, changes: [{ target: address, action: 'mint', value: '1' }] }; // who owns the minted asset
-  const senderReceipt = { address: tx.from, changes: [] }; // who paid for this tx
-
-  assets.map((x) => senderReceipt.changes.push({ target: x, action: 'consume', value: '-1' }));
-
-  if (ctx.factoryState) {
-    const { value, tokens } = ctx.factoryState.input;
-    if (new BN(value).gt(ZERO)) {
-      senderReceipt.changes.push({ target: '', action: 'consume', value: `-${value}` });
-    }
-    tokens.map((x) => senderReceipt.changes.push({ target: x.address, action: 'consume', value: `-${x.value}` }));
-  }
-
-  let mergedReceipts = [ownerReceipt, senderReceipt];
-  if (ownerReceipt.address === senderReceipt.address) {
-    senderReceipt.changes = [...ownerReceipt.changes, ...senderReceipt.changes];
-    mergedReceipts = [senderReceipt];
-  }
-
-  return [...mergedReceipts];
-};
-
-const getAcquireAssetV3Receipts = (tx) => {
-  const { inputs, owner, address } = tx.itxJson;
-  const ownerReceipt = { address: owner, changes: [{ target: address, action: 'mint', value: '1' }] };
-  return [ownerReceipt, ...getReceiptsFromTxInput(inputs, '-', 'consume')];
-};
-
-const getStakeReceipts = (tx) => {
-  const { inputs, address } = tx.itxJson;
-
-  // aggregated stake changes
-  const tokens = {};
-  const assets = [];
-  inputs.forEach((input) => {
-    input.tokens.forEach((x) => {
-      if (typeof tokens[x.address] === 'undefined') {
-        tokens[x.address] = new BN(0);
-      }
-      tokens[x.address] = tokens[x.address].add(new BN(x.value));
-    });
-    assets.push(...input.assets);
-  });
-
-  const stakeReceipt = { address, changes: [] };
-  assets.forEach((x) => stakeReceipt.changes.push({ target: x, action: 'stake', value: '1' }));
-  Object.keys(tokens).forEach((x) =>
-    stakeReceipt.changes.push({ target: x, action: 'stake', value: tokens[x].toString(10) })
-  );
-
-  return [stakeReceipt, ...getReceiptsFromTxInput(inputs, '-', 'stake')];
-};
-
-const getClaimStakeReceipts = (tx, ctx, action) => {
-  const { address } = tx.itxJson;
-  const { outputs } = ctx;
-
-  // aggregated stake changes
-  const tokens = {};
-  const assets = [];
-  outputs.forEach((output) => {
-    getListField(output, 'tokens').forEach((x) => {
-      if (typeof tokens[x.address] === 'undefined') {
-        tokens[x.address] = new BN(0);
-      }
-      tokens[x.address] = tokens[x.address].add(new BN(x.value));
-    });
-    assets.push(...getListField(output, 'assets'));
-  });
-
-  const stakeReceipt = { address, changes: [] };
-  assets.forEach((x) => stakeReceipt.changes.push({ target: x, action, value: '-1' }));
-  Object.keys(tokens).forEach((x) =>
-    stakeReceipt.changes.push({ target: x, action, value: `-${tokens[x].toString(10)}` })
-  );
-
-  return [stakeReceipt, ...getReceiptsFromTxInput(outputs, '', action)];
-};
-
-const getCreateTokenReceipts = (tx) => {
-  const { initialSupply, address } = tx.itxJson;
-  const balance = new BN(initialSupply).toString();
-
-  const issuerReceipt = {
-    address: tx.delegator || tx.from,
-    changes: [{ target: address, action: 'mint', value: balance }],
-  };
-
-  return [issuerReceipt];
-};
-
-const getMintTokenReceipts = (tx, ctx) => {
-  const { inputChanges, tokenFactoryState } = ctx;
-  const { reserveAddress, tokenAddress, owner } = tokenFactoryState;
-  const hasFee = new BN(ctx.reserveFee || '0').gt(ZERO);
-
-  const inputReceipts = inputChanges.map((input) => {
-    return {
-      address: input.address,
-      changes: [
-        {
-          target: reserveAddress,
-          action: 'swap',
-          value: input.delta,
-        },
-      ],
-    };
-  });
-
-  return inputReceipts
-    .concat([
-      {
-        address: tx.itxJson.receiver,
-        changes: [
-          {
-            target: tokenAddress,
-            action: 'mint',
-            value: `${tx.itxJson.amount}`,
-          },
-        ],
-      },
-    ])
-    .concat(
-      hasFee
-        ? [
-            {
-              address: owner,
-              changes: [{ target: reserveAddress, action: 'fee', value: `${ctx.reserveFee}` }],
-            },
-          ]
-        : []
-    );
-};
-
-const getBurnTokenReceipts = (tx, ctx) => {
-  const { inputChanges, tokenFactoryState } = ctx;
-  const { reserveAddress, tokenAddress, owner } = tokenFactoryState;
-
-  const fee = new BN(ctx.reserveFee || '0');
-  const receiveAmount = new BN(ctx.reserveAmount || '0').sub(fee);
-
-  const inputReceipts = inputChanges.map((input) => {
-    return {
-      address: input.address,
-      changes: [
-        {
-          target: tokenAddress,
-          action: 'burn',
-          value: input.delta,
-        },
-      ],
-    };
-  });
-
-  return inputReceipts
-    .concat(
-      receiveAmount.gt(ZERO)
-        ? [
-            {
-              address: tx.itxJson.receiver,
-              changes: [{ target: reserveAddress, action: 'swap', value: receiveAmount.toString() }],
-            },
-          ]
-        : []
-    )
-    .concat(
-      fee.gt(ZERO)
-        ? [
-            {
-              address: owner,
-              changes: [{ target: reserveAddress, action: 'fee', value: fee.toString() }],
-            },
-          ]
-        : []
-    );
-};
-
-// Following only exist for legacy support purpose
-const getDepositTokenReceipts = (tx) => [
-  {
-    address: tx.itxJson.address,
-    changes: [{ target: '', action: 'mint', value: tx.itxJson.value }],
-  },
-];
-
-const getWithdrawFee = (value) => {
-  let fee = new BN(value).abs().mul(new BN('1')).div(new BN('1000')); // 0.1% fee
-  fee = BN.min(fee, new BN('100000000000000000000')); // max 100 ABT
-  fee = BN.max(fee, new BN('1000000000000000000')); // min 1 ABT
-  return fee;
-};
-
-const getWithdrawTokenReceipts = (tx) => {
-  const fee = getWithdrawFee(tx.itxJson.value);
-
-  return [
-    {
-      address: tx.from,
-      changes: [
-        { target: '', action: 'lock', value: `-${tx.itxJson.value}` },
-        { target: '', action: 'fee', value: `-${fee.toString()}` },
-      ],
-    },
-    {
-      address: FORGE_TOKEN_HOLDER,
-      changes: [
-        { target: '', action: 'lock', value: tx.itxJson.value },
-        { target: '', action: 'fee', value: fee.toString() },
-      ],
-    },
-  ];
-};
-
-const getRevokeWithdrawReceipts = (tx, { withdrawTx }) => {
-  if (!withdrawTx?.tx?.from) return [];
-  if (withdrawTx.hash !== tx.itxJson.withdraw_tx_hash) return [];
-
-  const account = withdrawTx.tx.from;
-  const withdrawReceipt = withdrawTx.receipts?.find((x) => x.address === account);
-  const lockChange = withdrawReceipt?.changes?.find((x) => x.action === 'lock');
-
-  if (!lockChange) return [];
-
-  const value = new BN(lockChange.value).abs();
-  const fee = getWithdrawFee(value.toString());
-  const revokeFee = fee.mul(new BN('5')).div(new BN('100')); // 5% fee
-
-  return [
-    {
-      address: account,
-      changes: [
-        { target: '', action: 'unlock', value: value.toString() },
-        { target: '', action: 'fee', value: fee.sub(revokeFee).toString() },
-      ],
-    },
-    {
-      address: FORGE_TOKEN_HOLDER,
-      changes: [
-        { target: '', action: 'unlock', value: `-${value.toString()}` },
-        { target: '', action: 'fee', value: `-${fee.toString()}` },
-      ],
-    },
-    {
-      address: FORGE_FEE_RECEIVER,
-      changes: [{ target: '', action: 'fee', value: revokeFee.toString() }],
-    },
-  ];
-};
-
-const getApproveWithdrawReceipts = (tx, { withdrawTx }) => {
-  if (!withdrawTx?.tx?.itxJson?.value) return [];
-  if (withdrawTx.hash !== tx.itxJson.withdraw_tx_hash) return [];
-
-  const { value } = withdrawTx.tx.itxJson;
-  const fee = getWithdrawFee(value);
-
-  return [
-    {
-      address: FORGE_TOKEN_HOLDER,
-      changes: [
-        { target: '', action: 'burn', value: `-${value}` },
-        { target: '', action: 'fee', value: `-${fee.toString()}` },
-      ],
-    },
-    {
-      address: FORGE_FEE_RECEIVER,
-      changes: [{ target: '', action: 'fee', value: fee.toString() }],
-    },
-  ];
-};
-
-const getSetupSwapReceipts = (tx) => [
-  {
-    address: tx.from,
-    changes: [
-      new BN(tx.itxJson.value).gt(ZERO) ? { target: '', action: 'swap', value: `-${tx.itxJson.value}` } : null,
-      ...tx.itxJson.assets.map((x) => ({
-        target: x,
-        action: 'swap',
-        value: '-1',
-      })),
-    ].filter(Boolean),
-  },
-];
-const getRetrieveSwapReceipts = (tx) => [
-  {
-    address: tx.from,
-    changes: [
-      new BN(tx.itxJson.value).gt(ZERO) ? { target: '', action: 'swap', value: tx.itxJson.value } : null,
-      ...tx.itxJson.assets.map((x) => ({
-        target: x,
-        action: 'swap',
-        value: '1',
-      })),
-    ].filter(Boolean),
-  },
-];
-
-const getMigrateReceipts = (tx, context) => {
-  const fromState = context.fromState || context.senderState;
-
-  if (!fromState?.tokens) return [];
-  if (!tx.itxJson?.address) return [];
-
-  const changes = Object.entries(fromState.tokens)
-    .filter(([, value]) => value && value !== '0')
-    .map(([address, value]) => ({ target: address, action: 'migrate', value }));
-
-  return changes.length
-    ? [
-        {
-          address: tx.itxJson.address,
-          changes,
-        },
-      ]
-    : [];
-};
-
-const getDeclareReceipts = (tx, { config, time }) => {
-  const txTime = new Date(time);
-
-  if (!tx.itxJson?.issuer) return [];
-  if (!config?.token) return [];
-  if (!time) return [];
-  if (txTime >= QLDB_MIGRATION_TIME) return [];
-
-  const gas = fromTokenToUnit('0.5', config.token.decimal);
-
-  return [
-    {
-      address: tx.itxJson?.issuer,
-      changes: [{ target: config.token.address, action: 'gas', value: `-${gas.toString()}` }],
-    },
-    {
-      address: FORGE_FEE_RECEIVER,
-      changes: [{ target: config.token.address, action: 'gas', value: gas.toString() }],
-    },
-  ];
-};
-
-const mergeTxReceipts = (receipts) => {
-  const merged = [];
-  receipts.forEach((x) => {
-    if (merged[x.address] === undefined) {
-      merged[x.address] = x;
-    } else {
-      merged[x.address].changes = [...merged[x.address].changes, ...x.changes];
-    }
-  });
-
-  return Object.values(merged);
-};
-
-/**
- * Get list of accounts with migration history
- * @param {Object} ctx - transaction execution context
- * @returns {Promise<string[][]>} adress[][]
- */
-const getAccountMigrationsFromContext = (ctx) => {
-  const migrationAddresses = [];
-  for (const [key, state] of Object.entries(ctx)) {
-    if (key.endsWith('State') && state?.address) {
-      migrationAddresses.push(getRelatedAddresses(state));
-    }
-    if (key.endsWith('States') && Array.isArray(state)) {
-      state.forEach((x) => {
-        if (x?.address) {
-          migrationAddresses.push(getRelatedAddresses(x));
-        }
-      });
-    }
-  }
-  return migrationAddresses;
-};
-
-/**
- * Group receipts by target
- * @param {Object[]} receipts - transaction receipts
- * @returns {Record<string, { address: string, value: BN, action: string }[]>}
- */
-const groupReceiptsByTarget = (receipts) => {
-  const targets = {};
-
-  for (const { address, changes } of receipts) {
-    for (const { target, value, action } of changes) {
-      if (!targets[target]) {
-        targets[target] = [];
-      }
-      targets[target].push({ address, value: new BN(value), action });
-    }
-  }
-  return targets;
-};
-
-/**
- * Verify transaction receipts
- * @param {Object[]} receipts - transaction receipts
- * @param {String} typeUrl - transaction type
- * @param {Object} ctx - transaction execution context
- * @returns {Promise<boolean>}
- */
-const verifyTxReceipts = (receipts, typeUrl, ctx = {}) => {
-  const targets = groupReceiptsByTarget(receipts);
-  const accountsWithMigration = getAccountMigrationsFromContext(ctx);
-  const skipActions =
-    {
-      MintAssetTx: ['mint', 'consume'],
-      AcquireAssetV2Tx: ['mint', 'consume'],
-      AcquireAssetV3Tx: ['mint', 'consume'],
-      CreateAssetTx: ['create'],
-      CreateTokenTx: ['mint'],
-      CreateRollupBlockTx: ['burn', 'mint'],
-      AccountMigrateTx: ['migrate'],
-      ApproveWithdrawTx: ['burn'],
-      SetupSwapTx: ['swap'],
-      RevokeSwapTx: ['swap'],
-      RetrieveSwapTx: ['swap'],
-      MintTokenTx: ['swap', 'mint', 'fee'],
-      BurnTokenTx: ['burn', 'swap', 'fee'],
-    }[typeUrl] || [];
-
-  for (const [target, changes] of Object.entries(targets)) {
-    // These actions will skip zero-sum calculation
-    const filteredChanges = changes.filter(({ action }) => {
-      if (!skipActions.includes(action)) return true;
-      if (action === 'consume' && toTypeInfo(target).role !== RoleType.ROLE_ASSET) return true;
-      return false;
-    });
-
-    // Ensure token/asset amounts are zero-sum
-    const sum = filteredChanges.reduce((prev, current) => prev.add(current.value), new BN(0));
-    if (!sum.eq(ZERO)) {
-      throw new Error('INVALID_RECEIPTS_VALUE', `Receipts are not zero-sum, target: ${target}, sum: ${sum}`);
-    }
-
-    // Ensure address is unique
-    const accountValue = {};
-    for (const { address, value, action } of filteredChanges) {
-      const accounts = accountsWithMigration.find((x) => x.includes(address)) || [address];
-      for (const account of accounts) {
-        const key = `${action}-${account}`;
-        const existingValue = accountValue[key];
-        if (
-          existingValue &&
-          ((existingValue.gt(ZERO) && value.lt(ZERO)) || (existingValue.lt(ZERO) && value.gt(ZERO)))
-        ) {
-          throw new Error(
-            'INVALID_RECEIPTS_ADDRESS',
-            `Duplicate accounts in receipts, target: ${target}, address: ${address}, action: ${action}`
-          );
-        }
-
-        accountValue[key] = value;
-      }
-    }
-  }
-
-  return true;
-};
-
-/**
- * Create transaction receipts, each receipt has following properties:
- *
- * - address: the entity did that changed
- * - changes:
- *   - target: the target address that was changed, can be token address, asset address
- *   - action: why the target has changed, such as consume, burn and transfer
- *   - value: the amount that has changed
- *
- * @param {Object} tx - decoded transaction
- * @param {Object} ctx - transaction execution context
- * @return {Array} list of receipts
- */
-const getTxReceipts = ({ tx, code }, ctx = {}) => {
-  const typeUrl = upperFirst(camelCase(tx?.itxJson?._type || ''));
-
-  if (code !== 'OK') {
-    const receiptsFromContext = ctx.gasPaid ? getReceiptsFromContext(ctx) : [];
-    const receiptsFromGas = getReceiptsFromGasPaid(tx, { ...ctx, typeUrl });
-    return receiptsFromContext.concat(receiptsFromGas);
-  }
-
-  let receipts = Array.isArray(ctx.receipts) ? ctx.receipts : [];
-
-  if (['TransferTx', 'TransferV2Tx'].includes(typeUrl)) {
-    receipts = receipts.concat(getTransferReceipts(tx, ctx));
-  } else if (['TransferV3Tx'].includes(typeUrl)) {
-    receipts = receipts.concat(getTransferV3Receipts(tx, ctx));
-  } else if (['ExchangeTx', 'ExchangeV2Tx'].includes(typeUrl)) {
-    receipts = receipts.concat(getExchangeReceipts(tx, ctx));
-  } else if (['CreateAssetTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getCreateAssetReceipts(tx, ctx));
-  } else if (['MintAssetTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getMintAssetReceipts(tx, ctx));
-  } else if (['AcquireAssetV2Tx'].includes(typeUrl)) {
-    receipts = receipts.concat(getAcquireAssetReceipts(tx, ctx));
-  } else if (['AcquireAssetV3Tx'].includes(typeUrl)) {
-    receipts = receipts.concat(getAcquireAssetV3Receipts(tx, ctx));
-  } else if (['CreateTokenTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getCreateTokenReceipts(tx, ctx));
-  } else if (['MintTokenTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getMintTokenReceipts(tx, ctx));
-  } else if (['BurnTokenTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getBurnTokenReceipts(tx, ctx));
-  } else if (['DepositTokenTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getDepositTokenReceipts(tx, ctx));
-  } else if (['WithdrawTokenTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getWithdrawTokenReceipts(tx, ctx));
-  } else if (['SetupSwapTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getSetupSwapReceipts(tx, ctx));
-  } else if (['RetrieveSwapTx', 'RevokeSwapTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getRetrieveSwapReceipts(tx, ctx));
-  } else if (['StakeTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getStakeReceipts(tx, ctx));
-  } else if (['ClaimStakeTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, 'claim'));
-  } else if (['SlashStakeTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, 'slash'));
-  } else if (['ReturnStakeTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, 'stake'));
-  } else if (['RevokeWithdrawTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getRevokeWithdrawReceipts(tx, ctx));
-  } else if (['ApproveWithdrawTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getApproveWithdrawReceipts(tx, ctx));
-  } else if (['AccountMigrateTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getMigrateReceipts(tx, ctx));
-  } else if (['DeclareTx'].includes(typeUrl)) {
-    receipts = receipts.concat(getDeclareReceipts(tx, ctx));
-  }
-
-  receipts = receipts.concat(getReceiptsFromContext(ctx));
-  receipts = receipts.concat(getReceiptsFromGasPaid(tx, { ...ctx, typeUrl }));
-
-  const merged = mergeTxReceipts(receipts).filter((x) => x.address && Array.isArray(x.changes) && x.changes.length);
-
-  // Attach default token address
-  const tokenAddr = get(ctx, 'config.token.address', '');
-  if (tokenAddr) {
-    merged.forEach((x) =>
-      x.changes.forEach((c) => {
-        if (c.target === '') {
-          c.target = tokenAddr;
-        }
-      })
-    );
-  }
-
-  return merged;
-};
-
-const create = (context, code = 'OK', verifyReceipts = true) => {
-  const { txHash, txTime, tx, totalGas, itxExtras = {}, extra = {} } = context;
-  const itx = decodeAny(tx.itx).value; // we should decode here because `context.itx` maybe changed
-  const typeUrl = fromTypeUrl(tx.itx.typeUrl);
-  const typeName = tx.itx.typeUrl.split(':').pop();
-  const itxJson = formatMessage(typeUrl, itx);
-
-  const result = {
-    code,
-    hash: txHash,
-    height: 0,
-    index: 0,
-    time: txTime,
-    sender: getTxSender({ tx, itx, typeUrl }),
-    receiver: getTxReceiver({ tx, itx, typeUrl }),
-    type: typeName,
-    tx: {
-      chainId: tx.chainId,
-      delegator: tx.delegator,
-      from: tx.from,
-      nonce: tx.nonce,
-      serviceFee: tx.serviceFee || '0',
-      gasFee: isBN(totalGas) ? totalGas.toString(10) : '0',
-      pk: toBase64(tx.pk),
-      signature: toBase64(tx.signature),
-      signatures: getListField(tx, 'signatures').map((x) => formatMessage('Multisig', x)),
-      itx: {
-        // Hack: this is required because of required by interface type inference on graphql
-        __typename: typeUrl,
-      },
-      itxJson: {
-        _type: typeUrl,
-        encoded_value: tx.itx.value,
-        type_url: tx.itx.typeUrl,
-        ...itxJson,
-        ...itxExtras,
-        data: itx.data || null,
-      },
-      extra: extra.txExtra || null,
-    },
-  };
-
-  result.receipts = getTxReceipts(result, context);
-
-  if (code === 'OK' && verifyReceipts) {
-    try {
-      verifyTxReceipts(result.receipts, typeUrl, context);
-      result.receiptsVerified = true;
-    } catch (err) {
-      console.warn(JSON.stringify(result, null));
-      console.error('verifyTxReceipts error', err);
-      result.receiptsVerified = false;
-    }
-  }
-
-  // determine gasPaid
-  attachPaidTxGas(result);
-
-  return result;
-};
-
-const attachPaidTxGas = (tx) => {
-  if (tx.tx.gasPaid) {
-    return tx;
-  }
-
-  // determine gasPaid
-  let gasChange = null;
-  tx.receipts.forEach((r) => {
-    const tmp = r.changes.find((c) => c.action === 'gas' && c.value === tx.tx.gasFee);
-    if (tmp) {
-      gasChange = tmp;
-    }
-  });
-  tx.tx.gasPaid = gasChange ? tx.tx.gasFee : '0';
-
-  return tx;
-};
-
-// Only a few props are allowed to be changed in tx state
-const update = (state, updates) => merge(state, pick(updates, ['finalized', 'tx.itxJson.actualFee']));
-
-module.exports = {
-  create,
-  update,
-  getTxReceiver,
-  getTxSender,
-  getTxReceipts,
-  mergeTxReceipts,
-  attachPaidTxGas,
-  verifyTxReceipts,
-  eachReceipts,
-  groupReceiptTokenChanges,
-  FORGE_TOKEN_HOLDER,
-};