log released nonces

Author: arcoraven

src/db/wallets/walletNonce.ts

@@ -12,39 +12,42 @@ const lastUsedNonceKey = (chainId: number, walletAddress: Address) =>
   `nonce:${chainId}:${normalizeAddress(walletAddress)}`;
 
 /**
- * The "unused nonces" list stores unsorted nonces to be reused or cancelled.
+ * The "recycled nonces" list stores unsorted nonces to be reused or cancelled.
  * Example: [ "25", "23", "24" ]
  */
-const unusedNoncesKey = (chainId: number, walletAddress: Address) =>
-  `nonce-unused:${chainId}:${normalizeAddress(walletAddress)}`;
+const recycledNoncesKey = (chainId: number, walletAddress: Address) =>
+  `nonce-recycled:${chainId}:${normalizeAddress(walletAddress)}`;
 
 /**
  * Acquire an unused nonce.
  * This should be used to send an EOA transaction with this nonce.
  * @param chainId
  * @param walletAddress
- * @returns number - The next unused nonce value for this wallet.
+ * @returns number
  */
-export const acquireNonce = async (chainId: number, walletAddress: Address) => {
-  // Acquire an unused nonce, if any.
-  let nonce = await _acquireUnusedNonce(chainId, walletAddress);
+export const acquireNonce = async (
+  chainId: number,
+  walletAddress: Address,
+): Promise<{ nonce: number; isRecycledNonce: boolean }> => {
+  // Acquire an recylced nonce, if any.
+  let nonce = await _acquireRecycledNonce(chainId, walletAddress);
   if (nonce !== null) {
-    return nonce;
+    return { nonce, isRecycledNonce: true };
   }
 
   // Else increment the last used nonce.
   const key = lastUsedNonceKey(chainId, walletAddress);
   nonce = await redis.incr(key);
   if (nonce === 1) {
     // If INCR returned 1, the nonce was not set.
-    // This may be a newly imported wallet. Sync and return the onchain nonce.
-    return await _syncNonce(chainId, walletAddress);
+    // This may be a newly imported wallet.
+    nonce = await _syncNonce(chainId, walletAddress);
   }
-  return nonce;
+  return { nonce, isRecycledNonce: false };
 };
 
 /**
- * Adds an unused nonce that can be reused by a future transaction.
+ * Recycles a nonce to be used by a future transaction.
  * This should be used if the current transaction that acquired this nonce is not valid.
  * @param chainId
  * @param walletAddress
@@ -55,18 +58,21 @@ export const releaseNonce = async (
   walletAddress: Address,
   nonce: number,
 ) => {
-  const key = unusedNoncesKey(chainId, walletAddress);
+  const key = recycledNoncesKey(chainId, walletAddress);
   await redis.rpush(key, nonce);
 };
 
 /**
- * Acquires an unused nonce.
+ * Acquires a recycled nonce that is unused.
  * @param chainId
  * @param walletAddress
  * @returns
  */
-const _acquireUnusedNonce = async (chainId: number, walletAddress: Address) => {
-  const key = unusedNoncesKey(chainId, walletAddress);
+const _acquireRecycledNonce = async (
+  chainId: number,
+  walletAddress: Address,
+) => {
+  const key = recycledNoncesKey(chainId, walletAddress);
   const res = await redis.lpop(key);
   return res ? parseInt(res) : null;
 };
@@ -87,7 +93,14 @@ const _syncNonce = async (
 
   const key = lastUsedNonceKey(chainId, walletAddress);
   await redis.set(key, transactionCount);
-  return transactionCount;
+
+  // Set last used nonce to transactionCount - 1.
+  // But don't lower the Redis nonce.
+
+  // @TODO:
+  // Set to max(value, transactionCount-1) -> 6
+
+  return await redis.incr(key);
 };
 
 /**
@@ -110,7 +123,7 @@ export const inspectNonce = async (chainId: number, walletAddress: Address) => {
 export const deleteAllNonces = async () => {
   const keys = [
     ...(await redis.keys("nonce:*")),
-    ...(await redis.keys("nonce-unused:*")),
+    ...(await redis.keys("nonce-recycled:*")),
   ];
   if (keys.length > 0) {
     await redis.del(keys);

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

@@ -3,7 +3,7 @@ import { randomUUID } from "crypto";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { Address, Hex } from "thirdweb";
-import { simulateQueuedTransaction } from "../../../utils/transaction/simulateQueuedTransaction";
+import { doSimulateTransaction } from "../../../utils/transaction/simulateQueuedTransaction";
 import { QueuedTransaction } from "../../../utils/transaction/types";
 import { createCustomError } from "../../middleware/error";
 import {
@@ -110,7 +110,7 @@ export async function simulateTransaction(fastify: FastifyInstance) {
             }),
       };
 
-      const simulateError = await simulateQueuedTransaction(queuedTransaction);
+      const simulateError = await doSimulateTransaction(queuedTransaction);
       if (simulateError) {
         throw createCustomError(
           simulateError,

src/utils/error.ts

@@ -2,7 +2,7 @@ import { ethers } from "ethers";
 import { getChainMetadata } from "thirdweb/chains";
 import { getChain } from "./chain";
 import { isEthersErrorCode } from "./ethers";
-import { simulateQueuedTransaction } from "./transaction/simulateQueuedTransaction";
+import { doSimulateTransaction } from "./transaction/simulateQueuedTransaction";
 import { AnyTransaction } from "./transaction/types";
 
 export const prettifyError = async (
@@ -17,7 +17,7 @@ export const prettifyError = async (
     }
 
     if (isEthersErrorCode(error, ethers.errors.UNPREDICTABLE_GAS_LIMIT)) {
-      const simulateError = await simulateQueuedTransaction(transaction);
+      const simulateError = await doSimulateTransaction(transaction);
       if (simulateError) {
         return simulateError;
       }

src/utils/transaction/insertTransaction.ts

@@ -4,7 +4,7 @@ import { createCustomError } from "../../server/middleware/error";
 import { SendTransactionQueue } from "../../worker/queues/sendTransactionQueue";
 import { normalizeAddress } from "../primitiveTypes";
 import { reportUsage } from "../usage";
-import { simulateQueuedTransaction } from "./simulateQueuedTransaction";
+import { doSimulateTransaction } from "./simulateQueuedTransaction";
 import { InsertedTransaction, QueuedTransaction } from "./types";
 
 interface InsertTransactionData {
@@ -54,7 +54,7 @@ export const insertTransaction = async (
 
   // Simulate the transaction.
   if (shouldSimulate) {
-    const error = await simulateQueuedTransaction(queuedTransaction);
+    const error = await doSimulateTransaction(queuedTransaction);
     if (error) {
       throw createCustomError(
         `Simulation failed: ${error.replace(/[\r\n]+/g, " --- ")}`,

src/utils/transaction/simulateQueuedTransaction.ts

@@ -20,7 +20,7 @@ import { AnyTransaction } from "./types";
  * @param transaction
  * @throws if there is a simulation error
  */
-export const simulateQueuedTransaction = async (
+export const doSimulateTransaction = async (
   transaction: AnyTransaction,
 ): Promise<string | null> => {
   const {

src/worker/queues/queues.ts

@@ -6,10 +6,10 @@ export const defaultJobOptions: JobsOptions = {
   attempts: 3,
   // Retries after 5s, 10s, 20s.
   backoff: { type: "exponential", delay: 5_000 },
-  // Purges completed jobs past 2000 or 5 days.
+  // Purges completed jobs.
   removeOnComplete: {
     age: 60 * 60 * 24 * 7,
-    count: 2000,
+    count: 10_000,
   },
 };
 

src/worker/tasks/cancelUnusedNoncesWorker.ts

@@ -10,13 +10,10 @@ import { CANCEL_UNUSED_NONCES_QUEUE_NAME } from "../queues/cancelUnusedNoncesQue
 import { logWorkerExceptions } from "../queues/queues";
 
 /**
- * Responsibilities:
- * - Loop through each unused nonce in all wallets.
- * - Cancel the transaction.
- * - If failed, add it back to the unused nonces list.
+ * Sends a cancel transaction for all recycled nonces.
  */
 const handler: Processor<any, void, string> = async (job: Job<string>) => {
-  const keys = await redis.keys("nonce-unused:*");
+  const keys = await redis.keys("nonce-recycled:*");
 
   for (const key of keys) {
     const { chainId, walletAddress } = fromUnusedNoncesKey(key);
@@ -41,6 +38,7 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
           if (isEthersErrorCode(e, ethers.errors.NONCE_EXPIRED)) {
             ignore.push(nonce);
           } else {
+            job.log(`Releasing nonce: ${nonce}`);
             await releaseNonce(chainId, walletAddress, nonce);
             fail.push(nonce);
           }
@@ -49,7 +47,7 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
 
       const message = `Cancelling nonces for ${key}. success=${success} fail=${fail} ignored=${ignore}`;
       job.log(message);
-      logger({ level: "info", message, service: "worker" });
+      logger({ service: "worker", level: "info", message });
     }
   }
 };

src/worker/tasks/sendTransactionWorker.ts

@@ -142,9 +142,9 @@ const _sendTransaction = async (
   }
 
   // Acquire an unused nonce for this transaction.
-  const nonce = await acquireNonce(chainId, from);
+  const { nonce, isRecycledNonce } = await acquireNonce(chainId, from);
+  job.log(`Acquired nonce ${nonce}. isRecycledNonce=${isRecycledNonce}`);
   populatedTransaction.nonce = nonce;
-
   job.log(`Sending transaction: ${stringify(populatedTransaction)}`);
 
   // Send transaction to RPC.
@@ -160,6 +160,7 @@ const _sendTransaction = async (
   } catch (error: unknown) {
     // Release the nonce if it has not expired.
     if (!isEthersErrorCode(error, ethers.errors.NONCE_EXPIRED)) {
+      job.log(`Releasing nonce: ${nonce}`);
       await releaseNonce(chainId, from, nonce);
     }
     throw error;
@@ -200,6 +201,10 @@ const _resendTransaction = async (
       client: thirdwebClient,
       chain: await getChain(chainId),
       ...sentTransaction,
+      // Unset gas values so it can be re-populated.
+      gasPrice: undefined,
+      maxFeePerGas: undefined,
+      maxPriorityFeePerGas: undefined,
     },
   });
   if (populatedTransaction.gasPrice) {