unused nonce

Author: arcoraven

src/server/routes/backend-wallet/transfer.ts

@@ -29,20 +29,21 @@ import {
 } from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-// INPUTS
 const requestSchema = Type.Omit(walletWithAddressParamSchema, [
   "walletAddress",
 ]);
 const requestBodySchema = Type.Object({
   to: Type.String({
-    description: "Address of the wallet to transfer to",
+    description: "The recipient wallet address.",
   }),
   currencyAddress: Type.String({
-    description: "Address of the token to transfer",
+    description:
+      "The token address to transfer. Set to for the chain's native currency.",
     default: constants.AddressZero,
   }),
   amount: Type.String({
-    description: "The amount of tokens to transfer",
+    description:
+      'The amount in ether to transfer. Example: "0.1" to send 0.1 ETH.',
   }),
   ...txOverridesWithValueSchema.properties,
 });
@@ -59,7 +60,7 @@ export async function transfer(fastify: FastifyInstance) {
     schema: {
       summary: "Transfer tokens",
       description:
-        "Transfer native or ERC20 tokens from this wallet to another wallet",
+        "Transfer native currency or ERC20 tokens to another wallet.",
       tags: ["Backend Wallet"],
       operationId: "transfer",
       params: requestSchema,

src/worker/index.ts

@@ -9,7 +9,6 @@ import {
 } from "./listeners/webhookListener";
 
 // Init workers.
-import "./tasks/cancelTransactionWorker";
 import "./tasks/cancelUnusedNoncesWorker";
 import "./tasks/mineTransactionWorker";
 import "./tasks/processEventLogsWorker";

src/worker/queues/cancelTransactionQueue.ts

@@ -17,6 +17,7 @@ export class MineTransactionQueue {
       // Delay confirming the tx by 500ms.
       delay: 500,
       // Check in 5s, 10s, 20s, 40s, 80s, 160s, 320s, 640s, 1280s, 2560s (~45 minutes)
+      // This needs to be long enough to handle transactions stuck in mempool for a while.
       attempts: 10,
       backoff: { type: "exponential", delay: 5_000 },
     },

src/worker/queues/mineTransactionQueue.ts

@@ -30,7 +30,14 @@ const handler: Processor<any, void, string> = async (_: Job<string>) => {
             nonce,
           });
           success.push(nonce);
-        } catch (e) {
+        } catch (e: unknown) {
+          // If the error suggests the nonce is already used, do not release the nonce.
+          if (isNonceUsedOnchain(e)) {
+            success.push(nonce);
+            continue;
+          }
+
+          // Otherwise release the nonce so it can be re-used or cancelled again later.
           await releaseNonce(chainId, walletAddress, nonce);
           fail.push(nonce);
         }
@@ -65,6 +72,20 @@ const getAndDeleteUnusedNonces = async (key: string) => {
   return results.map(parseInt);
 };
 
+/**
+ * Returns true if the error suggests the nonce is used onchain.
+ * @param error
+ * @returns
+ */
+const isNonceUsedOnchain = (error: unknown) => {
+  if (error instanceof Error) {
+    if (error.message.toLowerCase().includes("nonce too low")) {
+      return true;
+    }
+  }
+  return false;
+};
+
 // Worker
 const _worker = new Worker(CANCEL_UNUSED_NONCES_QUEUE_NAME, handler, {
   concurrency: 1,

src/worker/tasks/cancelTransactionWorker.ts

@@ -9,6 +9,7 @@ import {
 import { stringify } from "thirdweb/utils";
 import { getUserOpReceiptRaw } from "thirdweb/wallets/smart";
 import { TransactionDB } from "../../db/transactions/db";
+import { releaseNonce } from "../../db/wallets/walletNonce";
 import { getBlockNumberish } from "../../utils/block";
 import { getConfig } from "../../utils/cache/getConfig";
 import { getChain } from "../../utils/chain";
@@ -24,7 +25,6 @@ import {
 } from "../../utils/transaction/types";
 import { enqueueTransactionWebhook } from "../../utils/transaction/webhook";
 import { reportUsage } from "../../utils/usage";
-import { CancelTransactionQueue } from "../queues/cancelTransactionQueue";
 import {
   MineTransactionData,
   MineTransactionQueue,
@@ -227,23 +227,24 @@ _worker.on("failed", async (job: Job<string> | undefined) => {
       return;
     }
 
-    if (sentTransaction.isUserOp) {
-      // If userOp, set as errored.
-      job.log("Transaction is unmined after timeout. Erroring transaction...");
-      const erroredTransaction: ErroredTransaction = {
-        ...sentTransaction,
-        status: "errored",
-        errorMessage: "Transaction Timed out.",
-      };
-      await TransactionDB.set(erroredTransaction);
-      await enqueueTransactionWebhook(erroredTransaction);
-      _reportUsageError(erroredTransaction);
-    } else {
-      // If EOA transaction, enqueue a cancel job.
-      job.log(
-        "Transaction is unmined after timeout. Cancelling transaction...",
+    job.log("Transaction is unmined after timeout. Erroring transaction...");
+    const erroredTransaction: ErroredTransaction = {
+      ...sentTransaction,
+      status: "errored",
+      errorMessage: "Transaction timed out.",
+    };
+    await TransactionDB.set(erroredTransaction);
+    await enqueueTransactionWebhook(erroredTransaction);
+    _reportUsageError(erroredTransaction);
+
+    if (!sentTransaction.isUserOp) {
+      // Release the nonce to allow another transaction to acquire it.
+      job.log(`Releasing nonce ${sentTransaction.nonce}.`);
+      await releaseNonce(
+        sentTransaction.chainId,
+        sentTransaction.from,
+        sentTransaction.nonce,
       );
-      await CancelTransactionQueue.add({ queueId });
     }
   }
 });