@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/execute.js

@@ -1,254 +0,0 @@
-const get = require('lodash/get');
-const pick = require('lodash/pick');
-const merge = require('lodash/merge');
-const camelCase = require('lodash/camelCase');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Runner, pipes } = require('@ocap/tx-pipeline');
-
-const createEnsureGasFn = require('./pipes/ensure-gas');
-const createEnsureCostFn = require('./pipes/ensure-cost');
-
-const ensureTxGas = createEnsureGasFn(() => ({ create: 0, update: 2 }));
-const ensureTxCost = createEnsureCostFn({ attachSenderChanges: true, gasOnly: true });
-
-const getTxName = (typeUrl) => camelCase(typeUrl.split(':').pop());
-
-const flushEvents = (context, extra = {}) => {
-  (context.events || []).forEach((e) => {
-    context.statedb[e.table].emit(e.name, e.data, { ...e.ctx, ...extra });
-  });
-  context.events = [];
-};
-
-const shouldPersistTx = (err) => !err || get(err, 'props.persist');
-
-module.exports = ({ filter, runAsLambda }) => {
-  // pipeline before executing the transaction
-  const pre = new Runner();
-  pre.use(pipes.DecodeTx);
-  pre.use(pipes.VerifyBlocked({ filter, stateKeys: ['tx.from'] }));
-  pre.use(pipes.DecodeItx);
-  pre.use(pipes.VerifyTx);
-  pre.use(pipes.VerifyServiceFee);
-
-  pre.use(async (context, next) => {
-    if (filter.has(context.txHash)) {
-      // Since bloom-filters may give false positive, we need to check for statedb if replay detected
-      const exist = await context.statedb.tx.get(context.txHash, context);
-      if (exist) {
-        return next(new Error('DUPLICATE_TX', 'Can not execute duplicate transaction'));
-      }
-    }
-
-    filter.add(context.txHash);
-    return next();
-  });
-
-  pre.use(pipes.VerifyTxSize);
-  pre.use(pipes.VerifySignature);
-
-  // charge gas fee for errored tx
-  const ensureGasFeePaid = (context) => {
-    const gasRunner = new Runner();
-
-    gasRunner.use(ensureTxGas);
-    gasRunner.use(ensureTxCost);
-    gasRunner.use(async (ctx, next) => {
-      const { tx, statedb, senderUpdates, updateVaults } = ctx;
-
-      // If senderState does not exist and there is no stakeId for gas, an error will be thrown in ensureTxCost before here.
-      // So if there is no senderState here, it means there has a stake for gas, so allowed to continue.
-      if (ctx.senderState) {
-        const senderState = ctx.stateSnapshot?.[ctx.senderState.address] || ctx.senderState;
-        await statedb.account.update(
-          senderState.address,
-          ctx.states.account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, ctx),
-          ctx
-        );
-        await updateVaults();
-      }
-
-      return next();
-    });
-
-    return new Promise((resolve, reject) => {
-      gasRunner.run(context, (err) => {
-        if (err) {
-          context.logger?.error('Failed to charge gas fee for errored tx', {
-            error: err,
-            tx: context.tx,
-            txBase64: context.txBase64,
-            txHash: context.txHash,
-          });
-          reject(err);
-          return;
-        }
-
-        resolve();
-      });
-    });
-  };
-
-  const execute = async (context, protocols, isRetrySupported = false) =>
-    new Promise((resolve, reject) => {
-      pre.run(context, (err) => {
-        if (err) {
-          context.logger?.error('Failed to prepare transaction', {
-            error: err,
-            txHash: context.txHash,
-            request: context.extra?.request,
-          });
-          return reject(err);
-        }
-
-        const name = getTxName(context.txType);
-        const protocol = protocols[name];
-        if (!protocol) {
-          return reject(new Error('UNSUPPORTED_TX', `Unsupported tx type ${context.txType}`));
-        }
-
-        protocol.run(context, async (error) => {
-          if (isRetrySupported) {
-            if (error) {
-              return reject(error);
-            }
-            return resolve(context);
-          }
-
-          const txStatus = error ? error.code || 'INTERNAL' : 'OK';
-          let txState = context.states.tx.create(context, txStatus);
-
-          if (shouldPersistTx(error)) {
-            try {
-              if (error) {
-                await ensureGasFeePaid(context);
-                // Recreate tx to pick up gas related fields
-                txState = context.states.tx.create(context, txStatus);
-              }
-
-              await context.statedb.tx.create(txState.hash, txState, context);
-              flushEvents(context, { txState });
-            } catch (e) {
-              context.logger?.error('Failed to save transaction to statedb', {
-                error: e,
-                txError: error,
-                txHash: context.txHash,
-                txState,
-              });
-              // If we get an internal error here, should return the original tx error to client
-              return reject(error);
-            }
-          }
-
-          context.logger?.info('Tx finalized', {
-            txHash: context.txHash,
-            txStatus,
-            txState,
-            error,
-          });
-
-          if (error) {
-            return reject(error);
-          }
-          return resolve(context);
-        });
-      });
-    });
-
-  if (typeof runAsLambda === 'function') {
-    return async (context, protocols) => {
-      let ctx = context;
-      const startTime = Date.now();
-
-      try {
-        const txState = await runAsLambda(
-          async (txn) => {
-            // create a new context each time in case we are retrying
-            ctx = pick(context, ['txBase64', 'statedb', 'indexdb', 'config', 'states', 'filter', 'extra', 'logger']);
-            ctx.txn = txn;
-
-            await execute(ctx, protocols, true);
-
-            const state = context.states.tx.create(ctx, 'OK');
-            await context.statedb.tx.create(state.hash, state, ctx);
-
-            return state;
-          },
-          { cleanWorkingSet: true, verifyHash: true, context: ctx }
-        );
-
-        // update indexdb after statedb commit
-        flushEvents(ctx, { txState });
-
-        ctx.logger?.info('Tx finalized', {
-          txHash: ctx.txHash,
-          txState,
-          txStatus: 'OK',
-          duration: Date.now() - startTime,
-        });
-      } catch (error) {
-        const txStatus = error.code || 'INTERNAL';
-        let txState = ctx.tx ? context.states.tx.create(ctx, txStatus, false) : null;
-
-        ctx.logger?.error('Failed to execute transaction', {
-          error,
-          txHash: ctx.txHash,
-          txState,
-          request: context.extra?.request,
-        });
-
-        if (txState && shouldPersistTx(error)) {
-          // Avoid sync data in failed transactions to indexdb
-          ctx.events = [];
-
-          try {
-            txState = await runAsLambda(
-              async (txn) => {
-                ctx = Object.assign({}, ctx, { txn, cacheStates: null });
-
-                await ensureGasFeePaid(ctx);
-
-                // Recreate tx to pick up gas related fields
-                const state = context.states.tx.create(ctx, txStatus);
-                await ctx.statedb.tx.create(state.hash, state, ctx);
-
-                return state;
-              },
-              { cleanWorkingSet: true, verifyHash: true, context: ctx }
-            );
-
-            // update indexdb after statedb commit
-            flushEvents(ctx, { txState });
-
-            ctx.logger?.info('Tx finalized', {
-              txHash: ctx.txHash,
-              txState,
-              txStatus,
-              error,
-              duration: Date.now() - startTime,
-            });
-          } catch (err) {
-            ctx.logger?.error('Failed to save invalid transaction to statedb', {
-              error: err,
-              txError: error,
-              txHash: ctx.txHash,
-              txState,
-              request: context.extra?.request,
-            });
-            // If we get an error here, should return the original tx error to client
-            throw error;
-          }
-        }
-
-        throw error;
-      } finally {
-        // Merge new ctx to original context
-        merge(context, ctx);
-      }
-
-      return ctx;
-    };
-  }
-
-  return execute;
-};

package/lib/index.js

@@ -1,117 +0,0 @@
-const states = require('@ocap/state');
-
-const transferV2 = require('./protocols/trade/transfer-v2');
-const transferV3 = require('./protocols/trade/transfer-v3');
-const exchangeV2 = require('./protocols/trade/exchange-v2');
-const migrate = require('./protocols/account/migrate');
-const delegate = require('./protocols/account/delegate');
-const revokeDelegate = require('./protocols/account/revoke-delegate');
-const createAsset = require('./protocols/asset/create');
-const updateAsset = require('./protocols/asset/update');
-const consumeAsset = require('./protocols/asset/consume');
-const createFactory = require('./protocols/factory/create');
-const acquireAssetV2 = require('./protocols/asset/acquire-v2');
-const acquireAssetV3 = require('./protocols/asset/acquire-v3');
-const mintAsset = require('./protocols/asset/mint');
-const createToken = require('./protocols/token/create');
-const stake = require('./protocols/governance/stake');
-const revokeStake = require('./protocols/governance/revoke-stake');
-const returnStake = require('./protocols/governance/return-stake');
-const claimStake = require('./protocols/governance/claim-stake');
-const slashStake = require('./protocols/governance/slash-stake');
-const depositTokenV2 = require('./protocols/token/deposit-v2');
-const withdrawTokenV2 = require('./protocols/token/withdraw-v2');
-const createRollup = require('./protocols/rollup/create');
-const updateRollup = require('./protocols/rollup/update');
-const joinRollup = require('./protocols/rollup/join');
-const leaveRollup = require('./protocols/rollup/leave');
-const pauseRollup = require('./protocols/rollup/pause');
-const closeRollup = require('./protocols/rollup/close');
-const resumeRollup = require('./protocols/rollup/resume');
-const createRollupBlock = require('./protocols/rollup/create-block');
-const claimBlockReward = require('./protocols/rollup/claim-reward');
-const migrateRollup = require('./protocols/rollup/migrate');
-const createTokenFactory = require('./protocols/token-factory/create');
-const updateTokenFactory = require('./protocols/token-factory/update');
-const mintToken = require('./protocols/token-factory/mint');
-const burnToken = require('./protocols/token-factory/burn');
-
-const executor = require('./execute');
-
-const createExecutor = ({ filter, runAsLambda }) => {
-  const protocols = {
-    // trade
-    transfer: transferV2,
-    transferV2,
-    transferV3,
-    exchangeV2,
-
-    // account
-    accountMigrate: migrate,
-    delegate,
-    revokeDelegate,
-
-    // asset
-    createAsset,
-    updateAsset,
-    consumeAsset,
-    acquireAssetV2,
-    acquireAssetV3,
-    mintAsset,
-
-    // factory
-    createFactory,
-
-    // token
-    createToken,
-    depositTokenV2,
-    withdrawTokenV2,
-    createTokenFactory,
-    updateTokenFactory,
-    mintToken,
-    burnToken,
-
-    // governance
-    stake,
-    revokeStake,
-    claimStake,
-    slashStake,
-    returnStake,
-
-    // rollup
-    createRollup,
-    updateRollup,
-    joinRollup,
-    leaveRollup,
-    pauseRollup,
-    closeRollup,
-    resumeRollup,
-    createRollupBlock,
-    claimBlockReward,
-    migrateRollup,
-  };
-
-  const execute = executor({ filter, runAsLambda });
-
-  return {
-    ...protocols,
-
-    execute: (context, done) => {
-      Object.defineProperty(context, 'states', { value: states });
-
-      if (typeof done === 'function') {
-        return execute(context, protocols)
-          .then((res) => done(null, res))
-          .catch((err) => done(err));
-      }
-
-      return execute(context, protocols);
-    },
-  };
-};
-
-// default in-memory tx-hash-filter
-const filter = new states.Blacklist();
-
-module.exports = createExecutor({ filter });
-module.exports.createExecutor = createExecutor;

package/lib/pipes/ensure-cost.js

@@ -1,193 +0,0 @@
-const noop = require('lodash/noop');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { fromTokenToUnit, BN, fromUnitToToken, hexToNumber } = require('@ocap/util');
-const JWT = require('@arcblock/jwt');
-const { account } = require('@ocap/state');
-const { toAddress } = require('@arcblock/did');
-const { toStakeAddress } = require('@arcblock/did-util');
-
-const debug = require('debug')(`${require('../../package.json').name}:pipes:ensure-cost`);
-
-const { applyTokenUpdates, isGasStakeValid } = require('../util');
-
-const ZERO = new BN(0);
-
-// We have a layered transaction cost design
-// - gas: charged for every tx for creating/updating states on the ledger
-// - service fee: charged for creating tokens/assets/factories/rollups
-// - protocol fee: charged for moving tokens across the bridge
-module.exports = function CreateEnsureTxCostPipe({
-  attachSenderChanges = true,
-  throwOnInsufficientFund = true, // In some cases, we can tolerance insufficient fund, such as account migration
-  gasOnly = false,
-} = {}) {
-  return async function EnsureTxCost(context, next) {
-    // TODO: we are using the sender as gas payer, this may change in future
-    const { config, statedb, txType, senderState, gasEstimate, totalGas } = context;
-
-    // verify gas staking headers
-    const { tx, extra = {}, txHash } = context;
-    const { token, pk } = extra.gasStakeHeaders || {};
-    const gasStake = {};
-    if (token && pk && (await JWT.verify(token, pk, { enforceTimestamp: true, tolerance: 5 }))) {
-      const decoded = JWT.decode(token);
-      const txHashes = (decoded.txHash || '')
-        .split(',')
-        .map((x) => x.trim())
-        .filter(Boolean);
-      if (txHashes.includes(txHash)) {
-        gasStake.owner = toAddress(decoded.iss);
-        gasStake.stakeId = toStakeAddress(gasStake.owner, gasStake.owner);
-      } else {
-        console.warn(`Invalid gas payer header for: ${txHash}`);
-      }
-    }
-    // fallback to tx sender
-    if (!gasStake.owner) {
-      gasStake.owner = tx.from;
-      gasStake.stakeId = toStakeAddress(gasStake.owner, gasStake.owner);
-    }
-    gasStake.state = await statedb.stake.get(gasStake.stakeId, context);
-    gasStake.valid = isGasStakeValid(gasStake.state, config);
-    context.gasStake = gasStake;
-    debug('gasStake', gasStake, context.extra);
-
-    // Get service fee and gas fee
-    const changes = {};
-    let txCost = new BN(0);
-    const txFee = config.transaction.txFee[txType];
-    // always charge tx fee
-    if (!gasOnly && txFee) {
-      const totalFee = fromTokenToUnit(txFee, config.token.decimal);
-      txCost = txCost.add(totalFee);
-      changes.fee = { address: config.token.address, value: totalFee.toString(10) };
-      context.feeVaultChange = changes.fee;
-    }
-    // only charge gas when gas stake is not valid
-    if (!gasStake.valid && totalGas.gt(ZERO)) {
-      txCost = txCost.add(totalGas);
-      changes.gas = { address: config.token.address, value: totalGas.toString(10) };
-      context.gasVaultChange = changes.gas;
-    }
-
-    // pick fee vault
-    if (changes.fee) {
-      if (config.vaults.txFees?.length) {
-        const feeIndex = hexToNumber(txHash.slice(-8)) % config.vaults.txFees.length;
-        const feeVault = config.vaults.txFees[feeIndex];
-        context.feeVault = feeVault;
-      } else {
-        context.feeVault = config.vaults.txFee;
-      }
-    }
-
-    let isCostCharged = false;
-    if (txCost.gt(ZERO)) {
-      const expected = new BN(gasEstimate.payment || 0).add(txCost);
-      const actual = new BN(senderState?.tokens?.[config.token.address] || 0);
-      // If we have someone with enough balance to pay for this tx
-      if (senderState && actual.gte(expected)) {
-        isCostCharged = true;
-
-        // to be merged into later pipe
-        context.senderUpdates = applyTokenUpdates(
-          [{ address: config.token.address, value: txCost.toString(10) }],
-          senderState,
-          'sub'
-        );
-        context.senderChange = {
-          address: senderState.address,
-          token: config.token.address,
-          delta: `-${txCost.toString(10)}`,
-        };
-
-        debug({ changes, senderUpdates: context.senderUpdates });
-
-        // to be called in later pipes
-        context.updateVaults = async function updateVaults() {
-          const [feeVaultState, gasVaultState] = await Promise.all([
-            changes.fee ? statedb.account.get(context.feeVault, context) : null,
-            changes.gas ? statedb.account.get(context.gasVault, context) : null,
-          ]);
-
-          const [newFeeVaultState, newGasVaultState] = await Promise.all([
-            changes.fee
-              ? statedb.account.update(
-                  feeVaultState.address,
-                  account.update(feeVaultState, applyTokenUpdates([changes.fee], feeVaultState, 'add'), context),
-                  context
-                )
-              : null,
-            changes.gas
-              ? statedb.account.update(
-                  gasVaultState.address,
-                  account.update(gasVaultState, applyTokenUpdates([changes.gas], gasVaultState, 'add'), context),
-                  context
-                )
-              : null,
-          ]);
-
-          if (newFeeVaultState) context.feeVaultState = newFeeVaultState;
-          if (newGasVaultState) context.gasVaultState = newGasVaultState;
-
-          context.updatedAccounts = context.updatedAccounts || [];
-          if (changes.fee) {
-            context.updatedAccounts.push({
-              address: feeVaultState.address,
-              token: config.token.address,
-              delta: changes.fee.value,
-              action: 'fee',
-            });
-            if (attachSenderChanges) {
-              context.updatedAccounts.push({
-                address: senderState.address,
-                token: config.token.address,
-                delta: `-${changes.fee.value}`,
-                action: 'fee',
-              });
-            }
-          }
-          if (changes.gas) {
-            context.updatedAccounts.push({
-              address: gasVaultState.address,
-              token: config.token.address,
-              delta: changes.gas.value,
-              action: 'gas',
-            });
-            if (attachSenderChanges) {
-              context.updatedAccounts.push({
-                address: senderState.address,
-                token: config.token.address,
-                delta: `-${changes.gas.value}`,
-                action: 'gas',
-              });
-            }
-          }
-
-          context.gasPaid = true;
-        };
-      } else if (!senderState) {
-        return next(new Error('INVALID_GAS_PAYER', `Gas payer ${tx.from} does not exist on chain`));
-      } else if (throwOnInsufficientFund) {
-        return next(
-          new Error(
-            'INSUFFICIENT_FUND',
-            `Insufficient fund to pay for tx cost from ${senderState?.address || tx.from}, expected ${fromUnitToToken(
-              expected,
-              config.token.decimal
-            )} ${config.token.symbol}, got ${fromUnitToToken(actual, config.token.decimal)} ${config.token.symbol}`
-          )
-        );
-      }
-    }
-
-    if (!isCostCharged) {
-      context.senderUpdates = {};
-      context.senderChange = null;
-      context.updateVaults = noop;
-      context.updatedAccounts = [];
-    }
-
-    return next();
-  };
-};

package/lib/pipes/ensure-gas.js

@@ -1,48 +0,0 @@
-const { BN, hexToNumber } = require('@ocap/util');
-
-const debug = require('debug')(`${require('../../package.json').name}:pipes:ensure-gas`);
-
-// Must be called after all state ready
-// Must be called before creating/updating any state
-// estimateTxGas should be a function that returns the following data:
-// - create: state creating ops
-// - update: state updating ops
-// - payment: sender payment amount of the gas token
-module.exports = function CreateGasEnsureFn(estimateTxGas) {
-  return function EnsureTxGas(context, next) {
-    const { txHash, config } = context;
-
-    // total gas in native token
-    const { txGas } = config.transaction;
-    const basePrice = new BN(txGas.price);
-
-    const estimate = estimateTxGas(context);
-    let totalGas = new BN(0);
-    if (context.txBaseGas) {
-      totalGas = basePrice.mul(new BN(txGas.dataStorage)).mul(new BN(context.txSize));
-      totalGas = totalGas.add(basePrice.mul(new BN(txGas.createState)).mul(new BN(estimate.create + 1))); // 1 = tx insert
-      totalGas = totalGas.add(basePrice.mul(new BN(txGas.updateState)).mul(new BN(estimate.update)));
-    }
-
-    // gas receiver address
-    const { txGas: gasVaults } = config.vaults;
-    const gasIndex = hexToNumber(txHash.slice(-8)) % gasVaults.length;
-    const gasVault = gasVaults[gasIndex];
-    context.gasVault = gasVault;
-
-    debug({
-      txType: context.txType,
-      txHash: context.txHash,
-      txSize: context.txSize,
-      txBaseGas: context.txBaseGas,
-      totalGas: totalGas.toString(10),
-      gasVault,
-      estimate,
-    });
-
-    context.totalGas = totalGas;
-    context.gasEstimate = estimate;
-
-    return next();
-  };
-};