Merge branch 'main' into cleanup-executors

src/cli/alto.ts

@@ -14,7 +14,11 @@ import {
     serverOptions
 } from "./config"
 import { registerCommandToYargs } from "./util"
-import { TimeoutError, HttpRequestError, InternalRpcError } from "viem"
+import {
+    TimeoutError,
+    HttpRequestError,
+    InternalRpcError,
+} from "viem"
 
 // Load environment variables from .env file
 if (process.env.DOTENV_CONFIG_PATH) {
@@ -27,18 +31,22 @@ if (process.env.SENTRY_DSN) {
     const SENTRY_IGNORE_ERRORS = [
         InternalRpcError,
         HttpRequestError,
-        TimeoutError
+        TimeoutError,
     ]
 
     sentry.init({
         dsn: process.env.SENTRY_DSN,
         environment: process.env.ENVIRONMENT,
         beforeSend(event, hint) {
-            if (
-                SENTRY_IGNORE_ERRORS.some(
-                    (error) => hint.originalException instanceof error
-                )
-            ) {
+            const errorType = event.exception?.values?.[0]?.type
+
+            const shouldIgnore = SENTRY_IGNORE_ERRORS.some(
+                (error) =>
+                    hint.originalException instanceof error ||
+                    errorType === error.name
+            )
+
+            if (shouldIgnore) {
                 return null
             }
 

src/cli/config/bundler.ts

@@ -84,7 +84,8 @@ export const bundlerArgsSchema = z.object({
             )}`
         ),
     "enable-instant-bundling-endpoint": z.boolean(),
-    "enable-experimental-7702-endpoints": z.boolean()
+    "enable-experimental-7702-endpoints": z.boolean(),
+    "should-check-prefund": z.boolean()
 })
 
 export const executorArgsSchema = z.object({
@@ -177,7 +178,6 @@ export const logArgsSchema = z.object({
     "redis-queue-endpoint": z.string().optional(),
     "redis-event-manager-queue-name": z.string().optional(),
     json: z.boolean(),
-    "network-name": z.string(),
     "log-level": logLevel,
     "public-client-log-level": logLevel.optional(),
     "wallet-client-log-level": logLevel.optional(),

src/cli/config/options.ts

@@ -135,6 +135,12 @@ export const bundlerOptions: CliCommandOptions<IBundlerArgsInput> = {
             "Should the bundler enable the pimlico_experimental_sendUserOperation7702 and pimlico_experimental_estimateUserOperationGas7702 endpoint",
         type: "boolean",
         default: false
+    },
+    "should-check-prefund": {
+        description:
+            "Should the bundler check userOp's prefund before accepting it",
+        type: "boolean",
+        default: true
     }
 }
 
@@ -446,12 +452,6 @@ export const logOptions: CliCommandOptions<ILogArgsInput> = {
         require: true,
         default: false
     },
-    "network-name": {
-        description: "Name of the network (used for metrics)",
-        type: "string",
-        require: true,
-        default: "localhost"
-    },
     "log-level": {
         description: "Default log level",
         type: "string",

src/cli/handler.ts

@@ -83,7 +83,7 @@ export async function bundlerHandler(args_: IOptionsInput): Promise<void> {
 
     const chain: Chain = {
         id: chainId,
-        name: args.networkName,
+        name: 'chain-name', // isn't important, never used
         nativeCurrency: {
             name: "ETH",
             symbol: "ETH",
@@ -157,10 +157,6 @@ export async function bundlerHandler(args_: IOptionsInput): Promise<void> {
     await gasPriceManager.init()
 
     const registry = new Registry()
-    registry.setDefaultLabels({
-        network: chain.name,
-        chainId
-    })
     const metrics = createMetrics(registry)
 
     await preFlightChecks(config)

src/package.json

@@ -31,8 +31,6 @@
         "lint:fix": "eslint src/**/*.ts --fix"
     },
     "dependencies": {
-        "bull": "^4.15.1",
-        "@fastify/cors": "^9.0.1",
         "@fastify/websocket": "^10.0.1",
         "@opentelemetry/api": "^1.9.0",
         "@opentelemetry/core": "^1.25.1",
@@ -50,6 +48,7 @@
         "@types/ws": "^8.5.10",
         "abitype": "^0.8.0",
         "async-mutex": "^0.4.0",
+        "bull": "^4.15.1",
         "dotenv": "^16.0.3",
         "fastify": "^4.25.2",
         "ioredis": "^5.4.1",

src/rpc/rpcHandler.ts

@@ -749,8 +749,10 @@ export class RpcHandler implements IRpcEndpoint {
             })
         }
 
+        const shouldCheckPrefund =
+            apiVersion !== "v1" || this.config.shouldCheckPrefund
         const validationResult = await this.validator.validateUserOperation({
-            shouldCheckPrefund: apiVersion !== "v1",
+            shouldCheckPrefund,
             userOperation,
             queuedUserOperations,
             entryPoint

src/rpc/server.ts

@@ -8,7 +8,6 @@ import {
     jsonRpcSchema
 } from "@alto/types"
 import type { Metrics } from "@alto/utils"
-import cors from "@fastify/cors"
 import websocket from "@fastify/websocket"
 import * as sentry from "@sentry/node"
 import Fastify, {
@@ -21,9 +20,10 @@ import type { Registry } from "prom-client"
 import { toHex } from "viem"
 import type * as WebSocket from "ws"
 import { fromZodError } from "zod-validation-error"
+import type { AltoConfig } from "../createConfig"
+import rpcDecorators, { RpcStatus } from "../utils/fastify-rpc-decorators"
 import RpcReply from "../utils/rpc-reply"
 import type { IRpcEndpoint } from "./rpcHandler"
-import type { AltoConfig } from "../createConfig"
 
 // jsonBigIntOverride.ts
 const originalJsonStringify = JSON.stringify
@@ -59,16 +59,6 @@ JSON.stringify = (
     return originalJsonStringify(value, wrapperReplacer, space)
 }
 
-declare module "fastify" {
-    interface FastifyRequest {
-        rpcMethod: string
-    }
-
-    interface FastifyReply {
-        rpcStatus: "failed" | "success"
-    }
-}
-
 export class Server {
     private config: AltoConfig
     private fastify: FastifyInstance
@@ -101,20 +91,14 @@ export class Server {
             disableRequestLogging: true
         })
 
+        this.fastify.register(rpcDecorators)
+
         this.fastify.register(websocket, {
             options: {
                 maxPayload: config.websocketMaxPayloadSize
             }
         })
 
-        this.fastify.register(cors, {
-            origin: "*",
-            methods: ["POST", "GET", "OPTIONS"]
-        })
-
-        this.fastify.decorateRequest("rpcMethod", null)
-        this.fastify.decorateReply("rpcStatus", null)
-
         this.fastify.addHook("onResponse", (request, reply) => {
             const ignoredRoutes = ["/health", "/metrics"]
             if (ignoredRoutes.includes(request.routeOptions.url)) {
@@ -221,7 +205,6 @@ export class Server {
     }
 
     private async rpc(request: FastifyRequest, reply: RpcReply): Promise<void> {
-        reply.rpcStatus = "failed" // default to failed
         let requestId: number | null = null
 
         const versionParsingResult = altoVersions.safeParse(
@@ -283,7 +266,6 @@ export class Server {
                     bundlerRequestParsing.error
                 )
 
-                //
                 if (
                     validationError.message.includes(
                         "Missing/invalid userOpHash"
@@ -331,8 +313,11 @@ export class Server {
                 result: result.result
             }
 
-            await reply.status(200).send(jsonRpcResponse)
-            reply.rpcStatus = "success"
+            await reply
+                .setRpcStatus(RpcStatus.Success)
+                .status(200)
+                .send(jsonRpcResponse)
+
             this.fastify.log.info(
                 {
                     data:
@@ -359,7 +344,10 @@ export class Server {
                         code: err.code
                     }
                 }
-                await reply.status(200).send(rpcError)
+                await reply
+                    .setRpcStatus(RpcStatus.ClientError)
+                    .status(200)
+                    .send(rpcError)
                 this.fastify.log.info(rpcError, "error reply")
             } else if (err instanceof Error) {
                 sentry.captureException(err)
@@ -371,7 +359,10 @@ export class Server {
                     }
                 }
 
-                await reply.status(500).send(rpcError)
+                await reply
+                    .setRpcStatus(RpcStatus.ServerError)
+                    .status(500)
+                    .send(rpcError)
                 this.fastify.log.error(err, "error reply (non-rpc)")
             } else {
                 const rpcError = {
@@ -382,7 +373,10 @@ export class Server {
                     }
                 }
 
-                await reply.status(500).send(rpcError)
+                await reply
+                    .setRpcStatus(RpcStatus.ServerError)
+                    .status(500)
+                    .send(rpcError)
                 this.fastify.log.error(
                     { err },
                     "error reply (unhandled error type)"

src/utils/fastify-rpc-decorators.ts

@@ -0,0 +1,39 @@
+import type { FastifyPluginCallback, FastifyReply } from "fastify"
+
+declare module "fastify" {
+    interface FastifyRequest {
+        rpcMethod: string
+    }
+
+    interface FastifyReply {
+        rpcStatus: RpcStatus
+        setRpcStatus(rpcStatus: RpcStatus): FastifyReply
+    }
+}
+
+export enum RpcStatus {
+    Unset = "unset",
+    ServerError = "server_error",
+    ClientError = "client_error",
+    Success = "success"
+}
+
+// define plugin using callbacks
+const plugin: FastifyPluginCallback = (fastify, _, done) => {
+    fastify.decorateRequest("rpcMethod", null)
+    fastify.decorateReply("rpcStatus", RpcStatus.Unset)
+    fastify.decorateReply(
+        "setRpcStatus",
+        function (rpcStatus: RpcStatus): FastifyReply {
+            this.rpcStatus = rpcStatus
+            return this
+        }
+    )
+
+    done()
+}
+
+// Type assertion to allow symbol indexing
+;(plugin as any)[Symbol.for("skip-override")] = true
+
+export default plugin