feat: merge-train/spartan-v5 (#24851)

BEGIN_COMMIT_OVERRIDE
fix(foundation): always include a result key in json-rpc responses
(#24840)
feat(prover-node): make epoch proving robust to prune-induced fork
faults (#24678)
END_COMMIT_OVERRIDE

Author: AztecBot

yarn-project/end-to-end/src/single-node/proving/upload_failed_proof.test.ts

@@ -4,7 +4,7 @@ import type { Logger } from '@aztec/aztec.js/log';
 import { tryRmDir } from '@aztec/foundation/fs';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
-import { downloadEpochProvingJob, rerunEpochProvingJob } from '@aztec/prover-node';
+import { downloadEpochProvingJob, rerunCheckpointProvingJob, rerunEpochProvingJob } from '@aztec/prover-node';
 import type { TestProverNode } from '@aztec/prover-node/test';
 
 import { jest } from '@jest/globals';
@@ -61,11 +61,11 @@ describe('single-node/proving/upload_failed_proof', () => {
     await tryRmDir(rerunDownloadDir, logger);
   });
 
-  // Makes the prover's top-tree prove always throw (v5 uses the session's topTreeProveOverride hook;
-  // pre-v5 it patched finalizeEpoch), intercepts tryUploadSessionFailure (pre-v5 tryUploadEpochFailure)
-  // to capture the upload URL, then waits for epoch 1 to start and for the upload to complete. Tears
-  // down the live context, downloads the proving job data, and re-runs it via rerunEpochProvingJob with
-  // fake proofs on a fresh config.
+  // Makes the prover's top-tree prove always throw. Because every checkpoint prover still succeeds, the
+  // session fails on its own account (state 'failed'), which the session manager treats as a genuine,
+  // race-free failure and uploads a post-mortem eagerly via tryUploadEpochFailure(sessionId, checkpoints).
+  // Intercepts that to capture the upload URL, then tears down the live context, downloads the proving
+  // job data, and re-runs it via rerunEpochProvingJob with fake proofs on a fresh config.
   it('uploads failed proving job state and re-runs it on a fresh instance', async () => {
     // Make initial prover node fail to prove, via the session's top-tree-prove hook.
     const proverNode = test.proverNodes[0].getProverNode() as TestProverNode;
@@ -77,19 +77,20 @@ describe('single-node/proving/upload_failed_proof', () => {
       },
     });
 
-    // And track when the epoch failure upload is complete
+    // Track when the epoch failure upload is complete. It fires eagerly when a full session fails with
+    // healthy provers (a top-tree failure here).
     const { promise: epochUploaded, resolve: onEpochUploaded } = promiseWithResolvers<string>();
-    const origTryUploadEpochFailure = proverNode.tryUploadSessionFailure.bind(proverNode);
-    proverNode.tryUploadSessionFailure = async (session: any) => {
-      const url = await origTryUploadEpochFailure(session);
+    const origTryUploadEpochFailure = proverNode.tryUploadEpochFailure.bind(proverNode);
+    proverNode.tryUploadEpochFailure = async (id: any, checkpoints: any) => {
+      const url = await origTryUploadEpochFailure(id, checkpoints);
       if (url !== undefined) {
         onEpochUploaded(url);
       }
       return url;
     };
 
-    // Warp to the start of epoch one so prover node starts proving epoch 0,
-    // and wait for the data to be uploaded to the remote file store
+    // Warp to the start of epoch one so the prover node starts proving, fails at the top tree, and
+    // uploads the failed proving-job data to the remote file store.
     await test.warpToEpochStart(1);
     const epochUploadUrl = await epochUploaded;
 
@@ -122,4 +123,62 @@ describe('single-node/proving/upload_failed_proof', () => {
 
     logger.info(`Test succeeded`);
   });
+
+  // Same shape as above, one level down: forces a single checkpoint's sub-tree to fail (every checkpoint
+  // prover fails, via the test hook), which uploads that checkpoint's proving data on its own. Intercepts
+  // tryUploadCheckpointFailure for the URL, then downloads and re-proves just that checkpoint via
+  // rerunCheckpointProvingJob (no epoch top-tree / L1 submit).
+  it('uploads failed checkpoint proving state and re-proves it on a fresh instance', async () => {
+    const proverNode = test.proverNodes[0].getProverNode() as TestProverNode;
+    proverNode.setCheckpointHooks({
+      checkpointProveOverride: async () => {
+        await sleep(1000);
+        logger.warn(`Triggering error on checkpoint sub-tree prove`);
+        throw new Error(`Fake error while proving checkpoint`);
+      },
+    });
+
+    // The checkpoint post-mortem upload fires eagerly when a CheckpointProver's block proofs reject.
+    const { promise: checkpointUploaded, resolve: onCheckpointUploaded } = promiseWithResolvers<string>();
+    const origTryUploadCheckpointFailure = proverNode.tryUploadCheckpointFailure.bind(proverNode);
+    proverNode.tryUploadCheckpointFailure = async (prover: any) => {
+      const url = await origTryUploadCheckpointFailure(prover);
+      if (url !== undefined) {
+        onCheckpointUploaded(url);
+      }
+      return url;
+    };
+
+    // Warp so the prover node starts registering checkpoints; the first one's sub-tree fails and uploads.
+    await test.warpToEpochStart(1);
+    const checkpointUploadUrl = await checkpointUploaded;
+
+    await test.teardown();
+
+    const rerunDownloadPath = join(rerunDownloadDir, 'data.bin');
+    logger.warn(`Downloading checkpoint proving job data and state`, { rerunDataDir, rerunDownloadPath });
+    await downloadEpochProvingJob(checkpointUploadUrl, logger, {
+      dataDirectory: rerunDataDir,
+      jobDataDownloadPath: rerunDownloadPath,
+    });
+
+    logger.warn(`Rerunning checkpoint proving job from ${rerunDownloadPath}`);
+    await rerunCheckpointProvingJob(
+      rerunDownloadPath,
+      logger,
+      {
+        ...config,
+        realProofs: false,
+        dataStoreMapSizeKb: 1024 * 1024,
+        dataDirectory: rerunDataDir,
+        proverAgentCount: 2,
+        proverId: EthAddress.random(),
+        ...(await getACVMConfig(logger)),
+        ...(await getBBConfig(logger)),
+      },
+      context.genesis,
+    );
+
+    logger.info(`Test succeeded`);
+  });
 });

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;