@ocap/tx-protocols 1.20.0 → 1.20.2

package/lib/execute.js

@@ -1,5 +1,4 @@
 /* eslint-disable consistent-return */
-const { promisify } = require('util');
 const get = require('lodash/get');
 const pick = require('lodash/pick');
 const camelCase = require('lodash/camelCase');
@@ -9,9 +8,8 @@ const { Runner, pipes } = require('@ocap/tx-pipeline');
 const createEnsureGasFn = require('./pipes/ensure-gas');
 const createEnsureCostFn = require('./pipes/ensure-cost');
 
-// FIXME: DeprecationWarning: Calling promisify on a function that returns a Promise is likely a mistake.
-const ensureTxGas = promisify(createEnsureGasFn(() => ({ create: 0, update: 2 })));
-const ensureTxCost = promisify(createEnsureCostFn({ attachSenderChanges: true, gasOnly: true }));
+const ensureTxGas = createEnsureGasFn(() => ({ create: 0, update: 2 }));
+const ensureTxCost = createEnsureCostFn({ attachSenderChanges: true, gasOnly: true });
 
 const getTxName = (typeUrl) => camelCase(typeUrl.split(':').pop());
 
@@ -50,24 +48,45 @@ module.exports = ({ filter, runAsLambda }) => {
   pre.use(pipes.VerifySignature);
 
   // charge gas fee for errored tx
-  const ensureGasFeePaid = async (context) => {
-    try {
-      await ensureTxGas(context);
-      await ensureTxCost(context);
+  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();
+      }
 
-      const { tx, statedb, senderState, senderUpdates, updateVaults } = context;
+      return next();
+    });
 
-      await Promise.all([
-        statedb.account.update(
-          senderState.address,
-          context.states.account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
-          context
-        ),
-      ]);
-      await updateVaults();
-    } catch (err) {
-      context.logger?.error('Failed to charge gas fee for errored tx', { error: err, txHash: context.txHash });
-    }
+    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();
+      });
+    });
   };
 
   // eslint-disable-next-line require-await
@@ -86,123 +105,121 @@ module.exports = ({ filter, runAsLambda }) => {
         }
 
         // eslint-disable-next-line no-shadow
-        protocol.run(context, async (err) => {
-          // we should only flush events when retry is not supported
-          // otherwise the outer caller should handle these 2
-          if (shouldPersistTx(err) && isRetrySupported === false) {
-            if (err) {
-              await ensureGasFeePaid(context);
+        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);
 
-            let txState;
+          if (shouldPersistTx(error)) {
             try {
-              txState = context.states.tx.create(context, err ? err.code || 'INTERNAL' : 'OK');
+              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);
-              context.logger?.info('Tx finalized', {
-                txHash: context.txHash,
-                txStatus: err ? err.code || 'INTERNAL' : 'OK',
-                txState,
-                error: err,
-              });
+              flushEvents(context, { txState });
             } catch (e) {
-              context.logger?.error('Failed to save invalid transaction to statedb', {
+              context.logger?.error('Failed to save transaction to statedb', {
                 error: e,
+                txError: error,
                 txHash: context.txHash,
                 txState,
               });
-              return reject(e);
+              // If we get an internal error here, should return the original tx error to client
+              return reject(error);
             }
-
-            flushEvents(context, { txState });
           }
 
-          // after executing the transaction
-          if (err) {
-            context.logger?.error('Failed to execute transaction', { error: err, txHash: context.txHash });
-            return reject(err);
-          }
+          context.logger?.info('Tx finalized', {
+            txHash: context.txHash,
+            txStatus,
+            txState,
+            error,
+          });
 
-          resolve(context);
+          if (error) {
+            return reject(error);
+          }
+          return resolve(context);
         });
       });
     });
 
   if (typeof runAsLambda === 'function') {
     return async (context, protocols) => {
-      let ctx = null;
-      let error = null;
-      let runCount = 0;
-      const retryLimit = context.statedb?.config?.retryLimit || 0;
-      const shouldRetry = context.statedb?.config?.shouldRetry || (() => false);
+      let ctx = context;
       const startTime = Date.now();
 
-      await runAsLambda(async (txn) => {
-        runCount += 1;
-
-        // create a new context each time in case we are retrying
-        ctx = pick(context, ['txBase64', 'statedb', 'indexdb', 'config', 'states', 'filter', 'extra', 'logger']);
-        Object.defineProperty(ctx, 'txn', { value: txn });
+      try {
+        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;
 
-        try {
           await execute(ctx, protocols, true);
-        } catch (err) {
-          if (runCount <= retryLimit && shouldRetry(err)) {
-            // throw the error to retry
-            throw err;
-          }
-          error = err;
-        }
-
-        if (error && !shouldPersistTx(error)) {
-          ctx.logger?.error('Failed to execute transaction', { error, txHash: ctx.txHash });
-          // throw the error to the abort transaction
-          throw error;
-        }
-
-        // create tx
-        const txStatus = error ? error.code || 'INTERNAL' : 'OK';
-        try {
-          let txState = context.states.tx.create(ctx, txStatus);
-          flushEvents(ctx, { txState });
-
-          if (error) {
-            await ensureGasFeePaid(ctx);
-            // Recreate tx to pick up gas related fields
-            txState = context.states.tx.create(ctx, txStatus);
-          }
 
+          const txState = context.states.tx.create(ctx, 'OK');
           await context.statedb.tx.create(txState.hash, txState, ctx);
+
+          // update indexdb
           flushEvents(ctx, { txState });
 
           ctx.logger?.info('Tx finalized', {
             txHash: ctx.txHash,
-            txStatus,
             txState,
-            error,
-            runCount,
+            txStatus: 'OK',
             duration: Date.now() - startTime,
           });
-        } catch (err) {
-          if (runCount <= retryLimit && shouldRetry(err)) {
-            // throw error to retry
-            throw err;
-          }
+        });
+      } catch (error) {
+        const txStatus = error.code || 'INTERNAL';
+        let txState = context.states.tx.create(ctx, txStatus, false);
 
-          const txState = context.states.tx.create(ctx, txStatus, false);
-          ctx.logger?.error('Failed to save invalid transaction to statedb', {
-            error: err,
-            protocolError: error,
-            txHash: ctx.txHash,
-            txState,
-            duration: Date.now() - startTime,
-          });
+        ctx.logger?.error('Failed to execute transaction', { error, txHash: ctx.txHash, txState });
+
+        if (shouldPersistTx(error)) {
+          try {
+            await runAsLambda(async (txn) => {
+              ctx = Object.assign({}, ctx, { txn, cacheStates: null });
+
+              await ensureGasFeePaid(ctx);
+
+              // Recreate tx to pick up gas related fields
+              txState = context.states.tx.create(ctx, txStatus);
 
-          // throw error to abort transaction
-          throw err;
+              await ctx.statedb.tx.create(txState.hash, txState, ctx);
+
+              // update indexdb
+              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,
+            });
+            // If we get an error here, should return the original tx error to client
+            throw error;
+          }
         }
-      });
 
-      if (error) {
         throw error;
       }
 

package/lib/pipes/ensure-cost.js

@@ -24,7 +24,7 @@ module.exports = function CreateEnsureTxCostPipe({
 } = {}) {
   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, gasVault, totalGas } = context;
+    const { config, statedb, txType, senderState, gasEstimate, totalGas } = context;
 
     // verify gas staking headers
     const { tx, extra = {}, txHash } = context;
@@ -83,11 +83,11 @@ module.exports = function CreateEnsureTxCostPipe({
     }
 
     let isCostCharged = false;
-    if (senderState && txCost.gt(ZERO)) {
+    if (txCost.gt(ZERO)) {
       const expected = new BN(gasEstimate.payment || 0).add(txCost);
-      const actual = new BN(senderState.tokens[config.token.address] || 0);
+      const actual = new BN(senderState?.tokens?.[config.token.address] || 0);
       // If we have someone with enough balance to pay for this tx
-      if (actual.gte(expected)) {
+      if (senderState && actual.gte(expected)) {
         isCostCharged = true;
 
         // to be merged into later pipe
@@ -108,7 +108,7 @@ module.exports = function CreateEnsureTxCostPipe({
         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(gasVault, context) : null,
+            changes.gas ? statedb.account.get(context.gasVault, context) : null,
           ]);
 
           const [newFeeVaultState, newGasVaultState] = await Promise.all([
@@ -167,11 +167,13 @@ module.exports = function CreateEnsureTxCostPipe({
 
           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}, expected ${fromUnitToToken(
+            `Insufficient fund to pay for tx cost from ${senderState?.address || tx.from}, expected ${fromUnitToToken(
               expected,
               config.token.decimal
             )}, got ${fromUnitToToken(actual, config.token.decimal)}`

package/lib/protocols/account/migrate.js

@@ -69,7 +69,6 @@ runner.use(
   })
 );
 runner.use(EnsureTxCost({ attachSenderChanges: true, throwOnInsufficientFund: false }));
-runner.use(pipes.VerifyGasPayer());
 
 // Save context snapshot before updating states
 runner.use(pipes.TakeStateSnapshot());

package/lib/protocols/governance/stake.js

@@ -178,7 +178,6 @@ runner.use(
   })
 );
 runner.use(EnsureTxCost({ attachSenderChanges: true }));
-runner.use(pipes.VerifyGasPayer());
 
 // Save context snapshot before updating states
 runner.use(pipes.TakeStateSnapshot());

package/lib/util.js

@@ -90,7 +90,10 @@ const applyTokenUpdates = (tokens, state, operator) => {
     }
 
     if (fulfilled.lt(expectedDelta)) {
-      throw new Error('NEGATIVE_TOKEN_BALANCE', `Negative token balance when applyTokenUpdates for ${address}`);
+      throw new Error(
+        'INSUFFICIENT_FUND',
+        `Negative token balance when applyTokenUpdates for ${address}, expected: ${expectedDelta.toString()} fulfilled: ${fulfilled.toString()}`
+      );
     }
   }
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.20.0",
+  "version": "1.20.2",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -21,18 +21,18 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "1.20.0",
-    "@arcblock/did-util": "1.20.0",
-    "@arcblock/jwt": "1.20.0",
-    "@arcblock/validator": "1.20.0",
-    "@ocap/asset": "1.20.0",
-    "@ocap/mcrypto": "1.20.0",
-    "@ocap/merkle-tree": "1.20.0",
-    "@ocap/message": "1.20.0",
-    "@ocap/state": "1.20.0",
-    "@ocap/tx-pipeline": "1.20.0",
-    "@ocap/util": "1.20.0",
-    "@ocap/wallet": "1.20.0",
+    "@arcblock/did": "1.20.2",
+    "@arcblock/did-util": "1.20.2",
+    "@arcblock/jwt": "1.20.2",
+    "@arcblock/validator": "1.20.2",
+    "@ocap/asset": "1.20.2",
+    "@ocap/mcrypto": "1.20.2",
+    "@ocap/merkle-tree": "1.20.2",
+    "@ocap/message": "1.20.2",
+    "@ocap/state": "1.20.2",
+    "@ocap/tx-pipeline": "1.20.2",
+    "@ocap/util": "1.20.2",
+    "@ocap/wallet": "1.20.2",
     "debug": "^4.3.6",
     "deep-diff": "^1.0.2",
     "empty-value": "^1.0.1",
@@ -47,5 +47,5 @@
     "jest": "^29.7.0",
     "start-server-and-test": "^1.14.0"
   },
-  "gitHead": "1639c0e496a8a18bd95404d907e5ad58d9d28cc3"
+  "gitHead": "70ddd9b43070605879fed7dff50a9f19f5325ea8"
 }