Merge branch 'main' into pb/fix-scalar

d4mr · web-flow · commit 7f0dc5cd579d · 2024-11-11T00:00:25.000+05:30
diff --git a/src/server/middleware/error.ts b/src/server/middleware/error.ts
@@ -53,7 +53,17 @@ const isZodError = (err: unknown): boolean => {
 
 export const withErrorHandler = async (server: FastifyInstance) => {
   server.setErrorHandler(
-    (error: Error | CustomError | ZodError, request, reply) => {
+    (error: string | Error | CustomError | ZodError, request, reply) => {
+      if (typeof error === "string") {
+        return reply.status(StatusCodes.INTERNAL_SERVER_ERROR).send({
+          error: {
+            statusCode: 500,
+            code: "INTERNAL_SERVER_ERROR",
+            message: error || ReasonPhrases.INTERNAL_SERVER_ERROR,
+          },
+        });
+      }
+
       // Ethers Error Codes
       if (parseEthersError(error)) {
         return reply.status(StatusCodes.BAD_REQUEST).send({
@@ -103,25 +113,24 @@ export const withErrorHandler = async (server: FastifyInstance) => {
           StatusCodes.INTERNAL_SERVER_ERROR;
 
         const message = error.message ?? ReasonPhrases.INTERNAL_SERVER_ERROR;
-        reply.status(statusCode).send({
+        return reply.status(statusCode).send({
           error: {
             code,
             message,
             statusCode,
             stack: env.NODE_ENV !== "production" ? error.stack : undefined,
           },
         });
-      } else {
-        // Handle non-custom errors
-        reply.status(StatusCodes.INTERNAL_SERVER_ERROR).send({
-          error: {
-            statusCode: 500,
-            code: "INTERNAL_SERVER_ERROR",
-            message: error.message || ReasonPhrases.INTERNAL_SERVER_ERROR,
-            stack: env.NODE_ENV !== "production" ? error.stack : undefined,
-          },
-        });
       }
+
+      reply.status(StatusCodes.INTERNAL_SERVER_ERROR).send({
+        error: {
+          statusCode: 500,
+          code: "INTERNAL_SERVER_ERROR",
+          message: error.message || ReasonPhrases.INTERNAL_SERVER_ERROR,
+          stack: env.NODE_ENV !== "production" ? error.stack : undefined,
+        },
+      });
     },
   );
 };
diff --git a/src/server/routes/contract/read/read.ts b/src/server/routes/contract/read/read.ts
@@ -2,6 +2,7 @@ import { Type } from "@sinclair/typebox";
 import type { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { getContract } from "../../../../utils/cache/getContract";
+import { prettifyError } from "../../../../utils/error";
 import { createCustomError } from "../../../middleware/error";
 import {
   readRequestQuerySchema,
@@ -64,22 +65,16 @@ export async function readContract(fastify: FastifyInstance) {
       });
 
       let returnData: unknown;
-
       try {
         returnData = await contract.call(functionName, parsedArgs ?? []);
       } catch (e) {
-        if (
-          e instanceof Error &&
-          (e.message.includes("is not a function") ||
-            e.message.includes("arguments, but"))
-        ) {
-          throw createCustomError(
-            e.message,
-            StatusCodes.BAD_REQUEST,
-            "BAD_REQUEST",
-          );
-        }
+        throw createCustomError(
+          prettifyError(e),
+          StatusCodes.BAD_REQUEST,
+          "BAD_REQUEST",
+        );
       }
+
       returnData = bigNumberReplacer(returnData);
 
       reply.status(StatusCodes.OK).send({
diff --git a/src/server/routes/index.ts b/src/server/routes/index.ts
@@ -109,6 +109,7 @@ import { createWebhookRoute } from "./webhooks/create";
 import { getWebhooksEventTypes } from "./webhooks/events";
 import { getAllWebhooksData } from "./webhooks/getAll";
 import { revokeWebhook } from "./webhooks/revoke";
+import { testWebhookRoute } from "./webhooks/test";
 
 export const withRoutes = async (fastify: FastifyInstance) => {
   // Backend Wallets
@@ -158,6 +159,7 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(createWebhookRoute);
   await fastify.register(revokeWebhook);
   await fastify.register(getWebhooksEventTypes);
+  await fastify.register(testWebhookRoute);
 
   // Permissions
   await fastify.register(getAllPermissions);
diff --git a/src/server/routes/transaction/retry-failed.ts b/src/server/routes/transaction/retry-failed.ts
@@ -69,10 +69,9 @@ export async function retryFailedTransaction(fastify: FastifyInstance) {
         );
       }
 
-      // temp do not handle userop
       if (transaction.isUserOp) {
         throw createCustomError(
-          `Transaction cannot be retried because it is a userop`,
+          "Transaction cannot be retried because it is a userop",
           StatusCodes.BAD_REQUEST,
           "TRANSACTION_CANNOT_BE_RETRIED",
         );
diff --git a/src/server/routes/webhooks/test.ts b/src/server/routes/webhooks/test.ts
@@ -0,0 +1,120 @@
+import { Type, type Static } from "@sinclair/typebox";
+import type { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { getWebhook } from "../../../db/webhooks/getWebhook";
+import { sendWebhookRequest } from "../../../utils/webhook";
+import { createCustomError } from "../../middleware/error";
+import { NumberStringSchema } from "../../schemas/number";
+import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
+import type { TransactionSchema } from "../../schemas/transaction";
+
+const paramsSchema = Type.Object({
+  webhookId: NumberStringSchema,
+});
+
+const responseBodySchema = Type.Object({
+  result: Type.Object({
+    ok: Type.Boolean(),
+    status: Type.Number(),
+    body: Type.String(),
+  }),
+});
+
+export async function testWebhookRoute(fastify: FastifyInstance) {
+  fastify.route<{
+    Params: Static<typeof paramsSchema>;
+    Reply: Static<typeof responseBodySchema>;
+  }>({
+    method: "POST",
+    url: "/webhooks/:webhookId/test",
+    schema: {
+      summary: "Test webhook",
+      description: "Send a test payload to a webhook.",
+      tags: ["Webhooks"],
+      operationId: "testWebhook",
+      params: paramsSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseBodySchema,
+      },
+    },
+    handler: async (req, res) => {
+      const { webhookId } = req.params;
+
+      const webhook = await getWebhook(Number.parseInt(webhookId));
+      if (!webhook) {
+        throw createCustomError(
+          "Webhook not found.",
+          StatusCodes.BAD_REQUEST,
+          "NOT_FOUND",
+        );
+      }
+
+      const webhookBody: Static<typeof TransactionSchema> = {
+        // Queue details
+        queueId: "1411246e-b1c8-4f5d-9a25-8c1f40b54e55",
+        status: "mined",
+        onchainStatus: "success",
+        queuedAt: "2023-09-29T22:01:31.031Z",
+        sentAt: "2023-09-29T22:01:41.580Z",
+        minedAt: "2023-09-29T22:01:44.000Z",
+        errorMessage: null,
+        cancelledAt: null,
+        retryCount: 0,
+
+        // Onchain details
+        chainId: "80002",
+        fromAddress: "0x3ecdbf3b911d0e9052b64850693888b008e18373",
+        toAddress: "0x365b83d67d5539c6583b9c0266a548926bf216f4",
+        data: "0xa9059cbb0000000000000000000000003ecdbf3b911d0e9052b64850693888b008e183730000000000000000000000000000000000000000000000000000000000000064",
+        value: "0x00",
+        nonce: 1786,
+        gasLimit: "39580",
+        maxFeePerGas: "2063100466",
+        maxPriorityFeePerGas: "1875545856",
+        gasPrice: "1875545871",
+        transactionType: 2,
+        transactionHash:
+          "0xc3ffa42dd4734b017d483e1158a2e936c8a97dd1aa4e4ce11df80ac8e81d2c7e",
+        sentAtBlockNumber: 40660021,
+        blockNumber: 40660026,
+
+        // User operation (account abstraction) details
+        signerAddress: null,
+        accountAddress: null,
+        accountFactoryAddress: null,
+        target: null,
+        sender: null,
+        initCode: null,
+        callData: null,
+        callGasLimit: null,
+        verificationGasLimit: null,
+        preVerificationGas: null,
+        paymasterAndData: null,
+        userOpHash: null,
+        accountSalt: null,
+
+        // Off-chain details
+        functionName: "transfer",
+        functionArgs: "0x3ecdbf3b911d0e9052b64850693888b008e18373,100",
+        extension: "none",
+        deployedContractAddress: null,
+        deployedContractType: null,
+
+        // Deprecated
+        retryGasValues: null,
+        retryMaxFeePerGas: null,
+        retryMaxPriorityFeePerGas: null,
+        effectiveGasPrice: null,
+        cumulativeGasUsed: null,
+        onChainTxStatus: 1,
+      };
+
+      const resp = await sendWebhookRequest(webhook, webhookBody);
+
+      res.status(StatusCodes.OK).send({
+        result: resp,
+      });
+    },
+  });
+}
diff --git a/src/server/schemas/transaction/index.ts b/src/server/schemas/transaction/index.ts
@@ -292,7 +292,10 @@ export const toTransactionSchema = (
     toAddress: transaction.to ?? null,
     data: transaction.data ?? null,
     value: transaction.value.toString(),
-    nonce: "nonce" in transaction ? transaction.nonce : null,
+    nonce:
+      "nonce" in transaction && transaction.nonce !== undefined
+        ? transaction.nonce
+        : null,
     deployedContractAddress: transaction.deployedContractAddress ?? null,
     deployedContractType: transaction.deployedContractType ?? null,
     functionName: transaction.functionName ?? null,
diff --git a/src/worker/tasks/nonceResyncWorker.ts b/src/worker/tasks/nonceResyncWorker.ts
@@ -8,6 +8,7 @@ import {
 } from "../../db/wallets/walletNonce";
 import { getConfig } from "../../utils/cache/getConfig";
 import { getChain } from "../../utils/chain";
+import { prettifyError } from "../../utils/error";
 import { logger } from "../../utils/logger";
 import { redis } from "../../utils/redis/redis";
 import { thirdwebClient } from "../../utils/sdk";
@@ -40,78 +41,49 @@ export const initNonceResyncWorker = async () => {
  */
 const handler: Processor<any, void, string> = async (job: Job<string>) => {
   const sentNoncesKeys = await redis.keys("nonce-sent*");
-  job.log(`Found ${sentNoncesKeys.length} nonce-sent* keys`);
+  if (sentNoncesKeys.length === 0) {
+    job.log("No active wallets.");
+    return;
+  }
 
   for (const sentNonceKey of sentNoncesKeys) {
-    const { chainId, walletAddress } = splitSentNoncesKey(sentNonceKey);
-
-    const rpcRequest = getRpcClient({
-      client: thirdwebClient,
-      chain: await getChain(chainId),
-    });
+    try {
+      const { chainId, walletAddress } = splitSentNoncesKey(sentNonceKey);
 
-    const [transactionCount, lastUsedNonceDb] = await Promise.all([
-      eth_getTransactionCount(rpcRequest, {
-        address: walletAddress,
-        blockTag: "latest",
-      }),
-      inspectNonce(chainId, walletAddress),
-    ]);
-
-    if (Number.isNaN(transactionCount)) {
-      job.log(
-        `Received invalid onchain transaction count for ${walletAddress}: ${transactionCount}`,
-      );
-      logger({
-        level: "error",
-        message: `[nonceResyncWorker] Received invalid onchain transaction count for ${walletAddress}: ${transactionCount}`,
-        service: "worker",
+      const rpcRequest = getRpcClient({
+        client: thirdwebClient,
+        chain: await getChain(chainId),
       });
-      continue;
-    }
+      const lastUsedNonceOnchain =
+        (await eth_getTransactionCount(rpcRequest, {
+          address: walletAddress,
+          blockTag: "latest",
+        })) - 1;
+      const lastUsedNonceDb = await inspectNonce(chainId, walletAddress);
 
-    const lastUsedNonceOnchain = transactionCount - 1;
-
-    job.log(
-      `${walletAddress} last used onchain nonce: ${lastUsedNonceOnchain} and last used db nonce: ${lastUsedNonceDb}`,
-    );
-    logger({
-      level: "debug",
-      message: `[nonceResyncWorker] last used onchain nonce: ${transactionCount} and last used db nonce: ${lastUsedNonceDb}`,
-      service: "worker",
-    });
-
-    // If the last used nonce onchain is the same as or ahead of the last used nonce in the db,
-    // There is no need to resync the nonce.
-    if (lastUsedNonceOnchain >= lastUsedNonceDb) {
-      job.log(`No need to resync nonce for ${walletAddress}`);
-      logger({
-        level: "debug",
-        message: `[nonceResyncWorker] No need to resync nonce for ${walletAddress}`,
-        service: "worker",
-      });
-      continue;
-    }
+      // Recycle all nonces between (onchain nonce, db nonce] if they aren't in-flight ("sent nonce").
+      const recycled: number[] = [];
+      for (
+        let nonce = lastUsedNonceOnchain + 1;
+        nonce <= lastUsedNonceDb;
+        nonce++
+      ) {
+        const exists = await isSentNonce(chainId, walletAddress, nonce);
+        if (!exists) {
+          await recycleNonce(chainId, walletAddress, nonce);
+          recycled.push(nonce);
+        }
+      }
 
-    //  for each nonce between last used db nonce and last used onchain nonce
-    //    check if nonce exists in nonce-sent set
-    //    if it does not exist, recycle it
-    for (
-      let _nonce = lastUsedNonceOnchain + 1;
-      _nonce < lastUsedNonceDb;
-      _nonce++
-    ) {
-      const exists = await isSentNonce(chainId, walletAddress, _nonce);
+      const message = `wallet=${chainId}:${walletAddress} lastUsedNonceOnchain=${lastUsedNonceOnchain} lastUsedNonceDb=${lastUsedNonceDb}, recycled=${recycled.join(",")}`;
+      job.log(message);
+      logger({ level: "debug", service: "worker", message });
+    } catch (error) {
       logger({
-        level: "debug",
-        message: `[nonceResyncWorker] nonce ${_nonce} exists in nonce-sent set: ${exists}`,
+        level: "error",
+        message: `[nonceResyncWorker] ${prettifyError(error)}`,
         service: "worker",
       });
-
-      // If nonce does not exist in nonce-sent set, recycle it
-      if (!exists) {
-        await recycleNonce(chainId, walletAddress, _nonce);
-      }
     }
   }
 };
diff --git a/src/worker/tasks/sendTransactionWorker.ts b/src/worker/tasks/sendTransactionWorker.ts
