reuse rpc request

Author: arcoraven

src/db/wallets/walletNonce.ts

@@ -1,7 +1,7 @@
-import { Address, eth_getTransactionCount, getRpcClient } from "thirdweb";
+import { Address, eth_getTransactionCount } from "thirdweb";
 import { getChain } from "../../utils/chain";
 import { redis } from "../../utils/redis/redis";
-import { thirdwebClient } from "../../utils/sdk";
+import { getRpcRequest } from "../../utils/sdk";
 
 // Data type: String
 const lastUsedNonceKey = (chainId: number, walletAddress: Address) =>
@@ -68,10 +68,7 @@ const _syncNonce = async (
   chainId: number,
   walletAddress: Address,
 ): Promise<number> => {
-  const rpcRequest = getRpcClient({
-    client: thirdwebClient,
-    chain: await getChain(chainId),
-  });
+  const rpcRequest = getRpcRequest(await getChain(chainId));
 
   // The next unused nonce = transactionCount.
   const transactionCount = await eth_getTransactionCount(rpcRequest, {

src/server/middleware/error.ts

@@ -2,6 +2,7 @@ import { FastifyInstance } from "fastify";
 import { ReasonPhrases, StatusCodes } from "http-status-codes";
 import { ZodError } from "zod";
 import { env } from "../../utils/env";
+import { parseEthersError } from "../../utils/ethers";
 import { logger } from "../../utils/logger";
 
 export type CustomError = {
@@ -21,41 +22,6 @@ export const createCustomError = (
   code,
 });
 
-// https://github.com/ethers-io/ethers.js/blob/main/src.ts/utils/errors.ts
-const ETHERS_ERROR_CODES = new Set([
-  // Generic Errors
-  "UNKNOWN_ERROR",
-  "NOT_IMPLEMENTED",
-  "UNSUPPORTED_OPERATION",
-  "NETWORK_ERROR",
-  "SERVER_ERROR",
-  "TIMEOUT",
-  "BAD_DATA",
-  "CANCELLED",
-
-  // Operational Errors
-  "BUFFER_OVERRUN",
-  "NUMERIC_FAULT",
-
-  // Argument Errors
-  "INVALID_ARGUMENT",
-  "MISSING_ARGUMENT",
-  "UNEXPECTED_ARGUMENT",
-  "VALUE_MISMATCH",
-
-  // Blockchain Errors
-  "CALL_EXCEPTION",
-  "INSUFFICIENT_FUNDS",
-  "NONCE_EXPIRED",
-  "REPLACEMENT_UNDERPRICED",
-  "TRANSACTION_REPLACED",
-  "UNCONFIGURED_NAME",
-  "OFFCHAIN_FAULT",
-
-  // User Interaction
-  "ACTION_REJECTED",
-]);
-
 export const createCustomDateTimestampError = (key: string): CustomError => {
   return createCustomError(
     `Invalid ${key} Value. Needs to new Date() / new Date().toISOstring() / new Date().getTime() / Unix Epoch`,
@@ -73,15 +39,6 @@ const isZodError = (err: unknown): boolean => {
   );
 };
 
-const isEthersError = (error: any): boolean => {
-  return (
-    error &&
-    typeof error === "object" &&
-    "code" in error &&
-    ETHERS_ERROR_CODES.has(error.code)
-  );
-};
-
 export const withErrorHandler = async (server: FastifyInstance) => {
   server.setErrorHandler(
     (error: Error | CustomError | ZodError, request, reply) => {
@@ -93,7 +50,7 @@ export const withErrorHandler = async (server: FastifyInstance) => {
       });
 
       // Ethers Error Codes
-      if (isEthersError(error)) {
+      if (parseEthersError(error)) {
         return reply.status(StatusCodes.BAD_REQUEST).send({
           error: {
             code: "BAD_REQUEST",

src/server/routes/transaction/blockchain/sendSignedTx.ts

@@ -1,9 +1,9 @@
 import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { eth_sendRawTransaction, getRpcClient, isHex } from "thirdweb";
+import { eth_sendRawTransaction, isHex } from "thirdweb";
 import { getChain } from "../../../../utils/chain";
-import { thirdwebClient } from "../../../../utils/sdk";
+import { getRpcRequest } from "../../../../utils/sdk";
 import { createCustomError } from "../../../middleware/error";
 import { standardResponseSchema } from "../../../schemas/sharedApiSchemas";
 import { walletChainParamSchema } from "../../../schemas/wallet";
@@ -52,12 +52,9 @@ export async function sendSignedTransaction(fastify: FastifyInstance) {
         );
       }
 
-      const rpc = getRpcClient({
-        chain: await getChain(chainId),
-        client: thirdwebClient,
-      });
+      const rpcRequest = getRpcRequest(await getChain(chainId));
       const transactionHash = await eth_sendRawTransaction(
-        rpc,
+        rpcRequest,
         signedTransaction,
       );
 

src/utils/block.ts

@@ -1,7 +1,7 @@
-import { eth_blockNumber, getRpcClient } from "thirdweb";
+import { eth_blockNumber } from "thirdweb";
 import { getChain } from "./chain";
 import { redis } from "./redis/redis";
-import { thirdwebClient } from "./sdk";
+import { getRpcRequest } from "./sdk";
 
 /**
  * Returns the latest block number. Falls back to the last known block number.
@@ -11,16 +11,12 @@ import { thirdwebClient } from "./sdk";
  * @returns bigint - The latest block number.
  */
 export const getBlockNumberish = async (chainId: number): Promise<bigint> => {
-  const chain = await getChain(chainId);
-  const rpcRequest = getRpcClient({
-    client: thirdwebClient,
-    chain,
-  });
+  const rpcRequest = getRpcRequest(await getChain(chainId));
 
   const key = `latestBlock:${chainId}`;
   try {
     const blockNumber = await eth_blockNumber(rpcRequest);
-    // Non-blocking cache.
+    // Non-blocking update to cache.
     redis.set(key, blockNumber.toString()).catch((e) => {});
     return blockNumber;
   } catch (e) {

src/utils/error.ts

@@ -1,7 +1,7 @@
 import { ethers } from "ethers";
 import { getChainMetadata } from "thirdweb/chains";
 import { getChain } from "./chain";
-import { EthersError } from "./ethers";
+import { isEthersErrorCode } from "./ethers";
 import { simulateQueuedTransaction } from "./transaction/simulateQueuedTransaction";
 import { AnyTransaction } from "./transaction/types";
 
@@ -10,19 +10,13 @@ export const prettifyError = async (
   error: Error,
 ): Promise<string> => {
   if (!transaction.isUserOp) {
-    if (
-      (error as unknown as EthersError)?.code ===
-      ethers.errors.INSUFFICIENT_FUNDS
-    ) {
+    if (isEthersErrorCode(error, ethers.errors.INSUFFICIENT_FUNDS)) {
       const chain = await getChain(transaction.chainId);
       const metadata = await getChainMetadata(chain);
       return `Insufficient ${metadata.nativeCurrency?.symbol} on ${metadata.name} in ${transaction.from}.`;
     }
 
-    if (
-      (error as unknown as EthersError)?.code ===
-      ethers.errors.UNPREDICTABLE_GAS_LIMIT
-    ) {
+    if (isEthersErrorCode(error, ethers.errors.UNPREDICTABLE_GAS_LIMIT)) {
       const simulateError = await simulateQueuedTransaction(transaction);
       if (simulateError) {
         return simulateError;

src/utils/ethers.ts

@@ -1,7 +1,51 @@
-export interface EthersError {
-  reason: string;
-  code: string;
-  error: any;
-  method: string;
-  transaction: any;
+// import { EthersError } from "@ethersproject/logger";
+import { ethers } from "ethers";
+
+// Copied from: https://github.com/ethers-io/ethers.js/blob/main/src.ts/utils/errors.ts#L156
+// EthersError in ethers isn't exported.
+export interface EthersError extends Error {
+  /**
+   *  The string error code.
+   */
+  code: ethers.errors;
+
+  /**
+   *  A short message describing the error, with minimal additional
+   *  details.
+   */
+  shortMessage: string;
+
+  /**
+   *  Additional info regarding the error that may be useful.
+   *
+   *  This is generally helpful mostly for human-based debugging.
+   */
+  info?: Record<string, any>;
+
+  /**
+   *  Any related error.
+   */
+  error?: Error;
 }
+
+export const ETHERS_ERROR_CODES = new Set(Object.values(ethers.errors));
+
+/**
+ * Returns an EthersError, or null if the error is not an ethers error.
+ * @param error
+ * @returns EthersError | null
+ */
+export const parseEthersError = (error: any): EthersError | null => {
+  if (
+    error &&
+    typeof error === "object" &&
+    "code" in error &&
+    ETHERS_ERROR_CODES.has(error.code)
+  ) {
+    return error as EthersError;
+  }
+  return null;
+};
+
+export const isEthersErrorCode = (error: any, code: ethers.errors) =>
+  parseEthersError(error)?.code === code;

src/utils/sdk.ts

@@ -1,5 +1,5 @@
 import { sha256HexSync } from "@thirdweb-dev/crypto";
-import { createThirdwebClient } from "thirdweb";
+import { Chain, createThirdwebClient, getRpcClient } from "thirdweb";
 import { env } from "./env";
 
 export const thirdwebClientId = sha256HexSync(
@@ -10,6 +10,21 @@ export const thirdwebClient = createThirdwebClient({
   secretKey: env.THIRDWEB_API_SECRET_KEY,
 });
 
+/**
+ * Share rpcRequest objects to reuse cached data.
+ */
+const _rpcClientByChain: Record<number, ReturnType<typeof getRpcClient>> = {};
+
+export const getRpcRequest = (chain: Chain) => {
+  if (!(chain.id in _rpcClientByChain)) {
+    _rpcClientByChain[chain.id] = getRpcClient({
+      client: thirdwebClient,
+      chain,
+    });
+  }
+  return _rpcClientByChain[chain.id];
+};
+
 /**
  * Helper functions to handle v4 -> v5 SDK migration.
  */

src/worker/tasks/cancelUnusedNoncesWorker.ts

@@ -1,6 +1,8 @@
 import { Job, Processor, Worker } from "bullmq";
+import { ethers } from "ethers";
 import { Address } from "thirdweb";
 import { releaseNonce } from "../../db/wallets/walletNonce";
+import { isEthersErrorCode } from "../../utils/ethers";
 import { logger } from "../../utils/logger";
 import { redis } from "../../utils/redis/redis";
 import { sendCancellationTransaction } from "../../utils/transaction/cancelTransaction";
@@ -13,15 +15,19 @@ import { logWorkerExceptions } from "../queues/queues";
  * - Cancel the transaction.
  * - If failed, add it back to the unused nonces list.
  */
-const handler: Processor<any, void, string> = async (_: Job<string>) => {
+const handler: Processor<any, void, string> = async (job: Job<string>) => {
   const keys = await redis.keys("nonce-unused:*");
+
   for (const key of keys) {
     const { chainId, walletAddress } = fromUnusedNoncesKey(key);
 
     const unusedNonces = await getAndDeleteUnusedNonces(key);
+    job.log(`Found unused nonces: key=${key} nonces=${unusedNonces}`);
+
     if (unusedNonces.length > 0) {
       const success: number[] = [];
       const fail: number[] = [];
+      const ignore: number[] = [];
       for (const nonce of unusedNonces) {
         try {
           await sendCancellationTransaction({
@@ -33,7 +39,7 @@ const handler: Processor<any, void, string> = async (_: Job<string>) => {
         } catch (e: unknown) {
           // If the error suggests the nonce is already used, do not release the nonce.
           if (isNonceUsedOnchain(e)) {
-            success.push(nonce);
+            ignore.push(nonce);
             continue;
           }
 
@@ -43,11 +49,9 @@ const handler: Processor<any, void, string> = async (_: Job<string>) => {
         }
       }
 
-      logger({
-        level: "info",
-        message: `Cancelling nonces for ${key}. success=${success} fail=${fail}`,
-        service: "worker",
-      });
+      const message = `Cancelling nonces for ${key}. success=${success} fail=${fail} ignored=${ignore}`;
+      job.log(message);
+      logger({ level: "info", message, service: "worker" });
     }
   }
 };
@@ -75,13 +79,11 @@ const getAndDeleteUnusedNonces = async (key: string) => {
 /**
  * Returns true if the error suggests the nonce is used onchain.
  * @param error
- * @returns
+ * @returns true if the nonce is already used.
  */
 const isNonceUsedOnchain = (error: unknown) => {
-  if (error instanceof Error) {
-    if (error.message.toLowerCase().includes("nonce too low")) {
-      return true;
-    }
+  if (isEthersErrorCode(error, ethers.errors.NONCE_EXPIRED)) {
+    return true;
   }
   return false;
 };

src/worker/tasks/mineTransactionWorker.ts

@@ -4,7 +4,6 @@ import {
   Address,
   eth_getTransactionByHash,
   eth_getTransactionReceipt,
-  getRpcClient,
 } from "thirdweb";
 import { stringify } from "thirdweb/utils";
 import { getUserOpReceiptRaw } from "thirdweb/wallets/smart";
@@ -17,7 +16,7 @@ import { msSince } from "../../utils/date";
 import { env } from "../../utils/env";
 import { logger } from "../../utils/logger";
 import { redis } from "../../utils/redis/redis";
-import { thirdwebClient } from "../../utils/sdk";
+import { getRpcRequest, thirdwebClient } from "../../utils/sdk";
 import {
   ErroredTransaction,
   MinedTransaction,
@@ -103,13 +102,8 @@ const _handleTransaction = async (
 ): Promise<MinedTransaction | null> => {
   const { queueId, chainId, sentTransactionHashes } = sentTransaction;
 
-  const chain = await getChain(chainId);
-  const rpcRequest = getRpcClient({
-    client: thirdwebClient,
-    chain,
-  });
-
   // Check all sent transaction hashes since any retry could succeed.
+  const rpcRequest = getRpcRequest(await getChain(chainId));
   const receiptResults = await Promise.allSettled(
     sentTransactionHashes.map((hash) =>
       eth_getTransactionReceipt(rpcRequest, { hash }),
@@ -172,17 +166,14 @@ const _handleUserOp = async (
 ): Promise<MinedTransaction> => {
   const { chainId, userOpHash } = sentTransaction;
   const chain = await getChain(chainId);
-  const rpcRequest = getRpcClient({
-    client: thirdwebClient,
-    chain,
-  });
 
   const userOpReceiptRaw = await getUserOpReceiptRaw({
     client: thirdwebClient,
     chain,
     userOpHash,
   });
   if (userOpReceiptRaw) {
+    const rpcRequest = getRpcRequest(chain);
     const transaction = await eth_getTransactionByHash(rpcRequest, {
       hash: userOpReceiptRaw.receipt.transactionHash,
     });