feat: Handler.feePayer error handling

Author: jxom

.changeset/whole-lions-accept.md

@@ -0,0 +1,5 @@
+---
+"tempo.ts": patch
+---
+
+Added error handling to `Handler.feePayer`.

src/server/Handler.test.ts

@@ -785,5 +785,30 @@ describe('feePayer', () => {
         }
       `)
     })
+
+    test('behavior: internal error', async () => {
+      const response = await fetch(server.url, {
+        method: 'POST',
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'eth_signRawTransaction',
+          params: ['0xinvalid'],
+        }),
+      })
+
+      const data = await response.json()
+      expect(data).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": -32603,
+            "name": "RpcResponse.InternalError",
+            "stack": "",
+          },
+          "id": 1,
+          "jsonrpc": "2.0",
+        }
+      `)
+    })
   })
 })

src/server/Handler.ts

@@ -521,72 +521,86 @@ export function feePayer(options: feePayer.Options) {
   router.post(path, async ({ request: req }) => {
     const request = RpcRequest.from((await req.json()) as any)
 
-    await onRequest?.(request)
-
-    if (request.method === 'eth_signTransaction') {
-      const transactionRequest = formatTransaction(request.params?.[0] as never)
+    try {
+      await onRequest?.(request)
+
+      if (request.method === 'eth_signTransaction') {
+        const transactionRequest = formatTransaction(
+          request.params?.[0] as never,
+        )
+
+        const serializedTransaction = await signTransaction(client, {
+          ...transactionRequest,
+          account,
+          // @ts-expect-error
+          feePayer: account,
+        })
+
+        return Response.json(
+          RpcResponse.from({ result: serializedTransaction }, { request }),
+        )
+      }
 
-      const serializedTransaction = await signTransaction(client, {
-        ...transactionRequest,
-        account,
-        // @ts-expect-error
-        feePayer: account,
-      })
+      if ((request as any).method === 'eth_signRawTransaction') {
+        const serialized = request.params?.[0] as `0x76${string}`
+        const transaction = Transaction.deserialize(serialized)
 
-      return Response.json(
-        RpcResponse.from({ result: serializedTransaction }, { request }),
-      )
-    }
+        const serializedTransaction = await signTransaction(client, {
+          ...transaction,
+          account,
+          // @ts-expect-error
+          feePayer: account,
+        })
 
-    if ((request as any).method === 'eth_signRawTransaction') {
-      const serialized = request.params?.[0] as `0x76${string}`
-      const transaction = Transaction.deserialize(serialized)
+        return Response.json(
+          RpcResponse.from({ result: serializedTransaction }, { request }),
+        )
+      }
 
-      const serializedTransaction = await signTransaction(client, {
-        ...transaction,
-        account,
-        // @ts-expect-error
-        feePayer: account,
-      })
+      if (
+        request.method === 'eth_sendRawTransaction' ||
+        request.method === 'eth_sendRawTransactionSync'
+      ) {
+        const serialized = request.params?.[0] as `0x76${string}`
+        const transaction = Transaction.deserialize(serialized)
+
+        const serializedTransaction = await signTransaction(client, {
+          ...transaction,
+          account,
+          // @ts-expect-error
+          feePayer: account,
+        })
+
+        const result = await client.request({
+          method: request.method,
+          params: [serializedTransaction],
+        })
+
+        return Response.json(RpcResponse.from({ result }, { request }))
+      }
 
       return Response.json(
-        RpcResponse.from({ result: serializedTransaction }, { request }),
+        RpcResponse.from(
+          {
+            error: new RpcResponse.MethodNotSupportedError({
+              message: `Method not supported: ${request.method}`,
+            }),
+          },
+          { request },
+        ),
+      )
+    } catch (error) {
+      return Response.json(
+        RpcResponse.from(
+          {
+            error: new RpcResponse.InternalError({
+              message: (error as Error).message,
+            }),
+          },
+          { request },
+        ),
       )
     }
-
-    if (
-      request.method === 'eth_sendRawTransaction' ||
-      request.method === 'eth_sendRawTransactionSync'
-    ) {
-      const serialized = request.params?.[0] as `0x76${string}`
-      const transaction = Transaction.deserialize(serialized)
-
-      const serializedTransaction = await signTransaction(client, {
-        ...transaction,
-        account,
-        // @ts-expect-error
-        feePayer: account,
-      })
-
-      const result = await client.request({
-        method: request.method,
-        params: [serializedTransaction],
-      })
-
-      return Response.json(RpcResponse.from({ result }, { request }))
-    }
-
-    return Response.json(
-      RpcResponse.from(
-        {
-          error: new RpcResponse.MethodNotSupportedError({
-            message: `Method not supported: ${request.method}`,
-          }),
-        },
-        { request },
-      ),
-      { status: 400 },
-    )
   })
 
   return router