fix(foundation): always include a result key in json-rpc responses (#24840)

## Problem
The safe JSON-RPC server built success responses as `{ jsonrpc, id,
result }`. When a handler returns `undefined`, `JSON.stringify` drops
the `result` key, producing `{"jsonrpc":"2.0","id":N}` — a response with
**neither `result` nor `error`**, which violates JSON-RPC 2.0 and leaves
raw/external callers unable to tell "not found" from a malformed reply.

Surfaced via `node_getContract` on an undeployed (but valid) address:
the response had no `result` field at all.

## Fix
One line in the shared server (`safe_json_rpc_server.ts`): coerce an
`undefined` return to `null` (`result: result ?? null`, so
`0`/`false`/`''` are preserved). The `result` key is now always present.

## Blast radius
Framework-level, so it fixes every method that can return `undefined` —
~20 on the node interface (`getContract`, `getContractClass`,
`getTxEffect`, `getTxByHash`, `getBlock`, the witness getters, synced
slot/epoch, validator stats, …) plus every other server on this
framework (PXE, prover-node, archiver). Void methods now also return
`result: null`.

## Why it's safe for existing clients
The TS client short-circuits `null`/`undefined`/`'null'`/`'undefined'`
**before** schema validation, so it never runs `null` through an
`.optional()` schema — omitted vs `result: null` both resolve to
`undefined` client-side. Only raw/external callers change, and they now
get a spec-compliant response.

## Testing
- Added a test: a handler returning `undefined` now yields `{ jsonrpc,
result: null }` (red before, green after).
- Updated the existing void-method (`clear`) assertions, single and
batch, to the new shape.
- Added integration tests (`test/integration.test.ts`) pinning that
optional result schemas tolerate `null` responses:
- end-to-end: the wire response for an undefined return carries an
explicit `result: null`, and the safe client resolves it to `undefined`;
- client-isolated: a stubbed fetch returning `result: null` verbatim
resolves to `undefined` against an `.optional()` schema instead of
throwing a `ZodError`. Both go red if the client's null short-circuit is
removed (verified: `Invalid input: expected object, received null`).
- Full `json-rpc` suite: 102 passed; `foundation` lint clean.

Author: aminsammara

yarn-project/foundation/src/json-rpc/server/safe_json_rpc_server.test.ts

@@ -76,10 +76,17 @@ describe('SafeJsonRpcServer', () => {
     it('calls an RPC function with no inputs nor outputs', async () => {
       const response = await send({ method: 'clear', params: [] });
       expect(response.status).toBe(200);
-      expect(response.text).toEqual(JSON.stringify({ jsonrpc }));
+      expect(response.text).toEqual(JSON.stringify({ jsonrpc, result: null }));
       expect(testState.notes).toEqual([]);
     });
 
+    it('returns an explicit null result (not an omitted field) when a handler returns undefined', async () => {
+      const response = await send({ method: 'getNote', params: [99] });
+      expect(response.status).toBe(200);
+      expect(response.text).toEqual(JSON.stringify({ jsonrpc, result: null }));
+      expect(JSON.parse(response.text)).toHaveProperty('result', null);
+    });
+
     it('calls an RPC function that returns a primitive object and a bigint', async () => {
       const response = await send({ method: 'getStatus', params: [] });
       expect(response.status).toBe(200);
@@ -185,7 +192,7 @@ describe('SafeJsonRpcServer', () => {
       expect(resp.text).toEqual(
         JSON.stringify([
           { jsonrpc: '2.0', id: 42, result: { status: 'ok', count: '2' } },
-          { jsonrpc: '2.0', id: 43 },
+          { jsonrpc: '2.0', id: 43, result: null },
         ]),
       );
     });
@@ -210,7 +217,7 @@ describe('SafeJsonRpcServer', () => {
       expect(resp.text).toEqual(
         JSON.stringify([
           { jsonrpc: '2.0', id: 42, error: { code: -32601, message: 'Method not found: toString' } },
-          { jsonrpc: '2.0', id: 43 },
+          { jsonrpc: '2.0', id: 43, result: null },
         ]),
       );
     });
@@ -221,7 +228,7 @@ describe('SafeJsonRpcServer', () => {
       expect(resp.status).toEqual(200);
       expect(resp.text).toEqual(
         JSON.stringify([
-          { jsonrpc: '2.0', id: 43 },
+          { jsonrpc: '2.0', id: 43, result: null },
           { jsonrpc: '2.0', error: { code: -32600, message: 'Invalid Request' }, id: null },
         ]),
       );

yarn-project/foundation/src/json-rpc/server/safe_json_rpc_server.ts

@@ -224,7 +224,11 @@ export class SafeJsonRpcServer {
           result = await this.proxy.call(method, params);
         }
 
-        return { jsonrpc, id, result };
+        // Coerce an undefined return value to null so the response always carries a `result` key.
+        // JSON.stringify drops undefined-valued keys, which would otherwise produce a JSON-RPC
+        // response with neither `result` nor `error` — a spec violation that leaves callers unable
+        // to distinguish "not found" from a malformed response.
+        return { jsonrpc, id, result: result ?? null };
       } catch (err: any) {
         if (err && err instanceof ZodError) {
           const message = err.issues.map(e => `${e.message} (${e.path.join('.')})`).join('. ') || 'Validation error';

yarn-project/foundation/src/json-rpc/test/integration.test.ts

@@ -1,3 +1,4 @@
+import type { JsonRpcFetch } from '../client/fetch.js';
 import { createSafeJsonRpcClient } from '../client/safe_json_rpc_client.js';
 import { TestNote, TestState, type TestStateApi, TestStateSchema } from '../fixtures/test_state.js';
 import { startHttpRpcServer } from '../server/safe_json_rpc_server.js';
@@ -125,6 +126,37 @@ describe('JsonRpc integration', () => {
     });
   });
 
+  describe('null results against optional schemas', () => {
+    let client: TestStateApi;
+    let url: string;
+
+    beforeEach(async () => {
+      ({ server, httpServer, client, url } = await createJsonRpcTestSetup(testState, TestStateSchema));
+    });
+
+    it('client accepts the explicit null result the server sends for an undefined return', async () => {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 0, method: 'getNote', params: [10] }),
+      });
+      expect(await response.json()).toEqual({ jsonrpc: '2.0', id: 0, result: null });
+
+      await expect(client.getNote(10)).resolves.toBeUndefined();
+    });
+
+    it('client resolves undefined when any server returns null for an optional result schema', async () => {
+      const nullResultFetch: JsonRpcFetch = (_host, body) =>
+        Promise.resolve({
+          response: body.map((req: { id: number }) => ({ jsonrpc: '2.0', id: req.id, result: null })),
+          headers: { get: () => undefined },
+        });
+      const nullClient = createSafeJsonRpcClient<TestStateApi>(url, TestStateSchema, { fetch: nullResultFetch });
+
+      await expect(nullClient.getNote(0)).resolves.toBeUndefined();
+    });
+  });
+
   describe('namespaced', () => {
     let lettersState: TestState;
     let numbersState: TestState;