remove simulation in send eoa transaction

Author: arcoraven

src/utils/sdk.ts

@@ -8,6 +8,9 @@ export const thirdwebClientId = sha256HexSync(
 
 export const thirdwebClient = createThirdwebClient({
   secretKey: env.THIRDWEB_API_SECRET_KEY,
+  config: {
+    rpc: { maxBatchSize: 50 },
+  },
 });
 
 /**

src/worker/queues/sendTransactionQueue.ts

@@ -13,7 +13,10 @@ export class SendTransactionQueue {
 
   private static q = new Queue<string>(this.name, {
     connection: redis,
-    defaultJobOptions,
+    defaultJobOptions: {
+      ...defaultJobOptions,
+      attempts: 5,
+    },
   });
 
   // Allow enqueing the same queueId for multiple retries.

src/worker/tasks/cancelUnusedNoncesWorker.ts

@@ -37,15 +37,13 @@ const handler: Processor<any, void, string> = async (job: Job<string>) => {
           });
           success.push(nonce);
         } catch (e: unknown) {
-          // If the error suggests the nonce is already used, do not release the nonce.
-          if (isNonceUsedOnchain(e)) {
+          // Release the nonce if it has not expired.
+          if (isEthersErrorCode(e, ethers.errors.NONCE_EXPIRED)) {
             ignore.push(nonce);
-            continue;
+          } else {
+            await releaseNonce(chainId, walletAddress, nonce);
+            fail.push(nonce);
           }
-
-          // Otherwise release the nonce so it can be re-used or cancelled again later.
-          await releaseNonce(chainId, walletAddress, nonce);
-          fail.push(nonce);
         }
       }
 
@@ -76,18 +74,6 @@ const getAndDeleteUnusedNonces = async (key: string) => {
   return results.map(parseInt);
 };
 
-/**
- * Returns true if the error suggests the nonce is used onchain.
- * @param error
- * @returns true if the nonce is already used.
- */
-const isNonceUsedOnchain = (error: unknown) => {
-  if (isEthersErrorCode(error, ethers.errors.NONCE_EXPIRED)) {
-    return true;
-  }
-  return false;
-};
-
 // Worker
 const _worker = new Worker(CANCEL_UNUSED_NONCES_QUEUE_NAME, handler, {
   concurrency: 1,

src/worker/tasks/sendTransactionWorker.ts

@@ -1,8 +1,10 @@
 import { Job, Processor, Worker } from "bullmq";
+import { ethers } from "ethers";
 import superjson from "superjson";
 import { Hex, toSerializableTransaction } from "thirdweb";
 import { stringify } from "thirdweb/utils";
 import { bundleUserOp } from "thirdweb/wallets/smart";
+import type { TransactionSerializable } from "viem";
 import { getContractAddress } from "viem";
 import { TransactionDB } from "../../db/transactions/db";
 import { acquireNonce, releaseNonce } from "../../db/wallets/walletNonce";
@@ -12,9 +14,9 @@ import { getChain } from "../../utils/chain";
 import { msSince } from "../../utils/date";
 import { env } from "../../utils/env";
 import { prettifyError } from "../../utils/error";
+import { isEthersErrorCode } from "../../utils/ethers";
 import { redis } from "../../utils/redis/redis";
 import { thirdwebClient } from "../../utils/sdk";
-import { simulateQueuedTransaction } from "../../utils/transaction/simulateQueuedTransaction";
 import {
   ErroredTransaction,
   QueuedTransaction,
@@ -76,15 +78,6 @@ const _handleQueuedTransaction = async (
   const { chainId, from } = queuedTransaction;
   const chain = await getChain(chainId);
 
-  const simulateError = await simulateQueuedTransaction(queuedTransaction);
-  if (simulateError) {
-    return {
-      ...queuedTransaction,
-      status: "errored",
-      errorMessage: simulateError,
-    };
-  }
-
   // Handle sending an AA user operation.
   if (queuedTransaction.isUserOp) {
     const signedUserOp = await generateSignedUserOperation(queuedTransaction);
@@ -110,33 +103,45 @@ const _handleQueuedTransaction = async (
     };
   }
 
-  // Prepare nonce + gas settings.
-  const populatedTransaction = await toSerializableTransaction({
-    from,
-    transaction: {
-      client: thirdwebClient,
-      chain,
+  let populatedTransaction: TransactionSerializable;
+  try {
+    populatedTransaction = await toSerializableTransaction({
+      from,
+      transaction: {
+        client: thirdwebClient,
+        chain,
+        ...queuedTransaction,
+      },
+    });
+  } catch (error: unknown) {
+    // If the transaction will revert, error.message contains the human-readable error.
+    const errorMessage = (error as Error)?.message ?? `${error}`;
+    return {
       ...queuedTransaction,
-    },
-  });
-  job.log(`Populated transaction: ${stringify(populatedTransaction)}`);
+      status: "errored",
+      errorMessage,
+    };
+  }
 
   // Acquire an unused nonce for this transaction.
   const nonce = await acquireNonce(chainId, from);
+  populatedTransaction.nonce = nonce;
+  job.log(`Populated transaction: ${stringify(populatedTransaction)}`);
 
   // Send transaction to RPC.
   let transactionHash: Hex;
   try {
     const account = await getAccount({ chainId, from });
-    const sendTransactionResult = await account.sendTransaction({
-      ...populatedTransaction,
-      nonce,
-    });
+    const sendTransactionResult = await account.sendTransaction(
+      populatedTransaction,
+    );
     transactionHash = sendTransactionResult.transactionHash;
-  } catch (e) {
-    // This transaction was rejected by RPC. Release the nonce to be reused by a future transaction.
-    await releaseNonce(chainId, from, nonce);
-    throw e;
+  } catch (error: unknown) {
+    // Release the nonce if it has not expired.
+    if (!isEthersErrorCode(error, ethers.errors.NONCE_EXPIRED)) {
+      await releaseNonce(chainId, from, nonce);
+    }
+    throw error;
   }
 
   return {