fix(bench): handle void worker-wallet returns in inclusion sweep [backport to merge-train/spartan-v5] (#24961)

## Backport

Backports the WorkerWallet fix from `next`
([#24843](#24843),
commit `fc2d7444fc2`) onto `merge-train/spartan-v5`. Cherry-pick applied
cleanly; the void-return fix hunks are byte-identical to the original,
and the branch's own `registerAccount(signingKey)` signature was
preserved untouched.

## Problem

`WorkerWallet.call` unconditionally `JSON.parse`'d the worker's
transport response. But void-returning methods — `registerContract`,
`registerContractClass` (both `output: z.void()` in `WalletSchema`) —
return nothing, and arrive at the client as the JS value `undefined`.
`JSON.parse(undefined)` coerces to `JSON.parse("undefined")` and throws
`SyntaxError: "undefined" is not valid JSON`.

This crashed `registerSponsoredFPC` during `n_tps.test.ts` setup and
failed every nightly bench inclusion-sweep point (1/5/10 TPS)
deterministically, ~5ms into the test body.

## Fix

Pass an `undefined` response straight to the method's schema (its
`z.void()` output accepts `undefined`) instead of `JSON.parse`-ing it,
and widen `callRaw`'s return type to `string | undefined`. Adds a
`worker_wallet.test.ts` unit test covering the void-return path.

Refs
[#24843](#24843).

---
*Created by
[claudebox](https://claudebox.work/v2/sessions/29aeafd6e697c027/jobs/1)
· group: `slackbot` · requested by Phil Windle · [Slack
thread](https://aztecprotocol.slack.com/archives/C0AU8BULZHC/p1784891623684979?thread_ts=1784891623.684979&cid=C0AU8BULZHC)*

Author: PhilWindle

yarn-project/end-to-end/src/test-wallet/worker_wallet.test.ts

@@ -0,0 +1,22 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { ContractInstancePreimage } from '@aztec/stdlib/contract';
+
+import { WorkerWallet } from './worker_wallet.js';
+
+describe('WorkerWallet', () => {
+  // The private constructor spawns a worker; call() only touches the transport client, so we build the
+  // instance directly with a stub client and never start a worker.
+  const walletRespondingWith = (requestResult: unknown): WorkerWallet => {
+    const client = { request: () => Promise.resolve(requestResult) };
+    return Reflect.construct(WorkerWallet, [undefined, client]);
+  };
+
+  // registerContract / registerContractClass return void, which the worker serializes as `undefined`.
+  // Feeding that to JSON.parse throws `"undefined" is not valid JSON` — the crash that failed every
+  // inclusion-sweep bench point during setup.
+  it('resolves a void-returning method when the worker responds with undefined', async () => {
+    const wallet = walletRespondingWith(undefined);
+    await expect(wallet.registerContract({} as ContractInstancePreimage)).resolves.toBeUndefined();
+    await expect(wallet.registerContractClass({} as ContractArtifact)).resolves.toBeUndefined();
+  });
+});

yarn-project/end-to-end/src/test-wallet/worker_wallet.ts

@@ -116,15 +116,17 @@ export class WorkerWallet implements Wallet {
     return wallet;
   }
 
-  private async callRaw(fn: string, ...args: any[]): Promise<string> {
+  private async callRaw(fn: string, ...args: any[]): Promise<string | undefined> {
     const argsJson = jsonStringify(args);
-    return (await this.client.request({ fn, args: argsJson })) as string;
+    return (await this.client.request({ fn, args: argsJson })) as string | undefined;
   }
 
   private async call(fn: string, ...args: any[]): Promise<any> {
     const resultJson = await this.callRaw(fn, ...args);
     const methodSchema = (WorkerWalletSchema as ApiSchema)[fn];
-    return getSchemaReturnType(methodSchema).parseAsync(JSON.parse(resultJson));
+    // Void-returning methods (e.g. registerContract) serialize to `undefined` on the worker side, which
+    // JSON.parse cannot handle; hand it straight to the schema, whose `z.void()` output accepts undefined.
+    return getSchemaReturnType(methodSchema).parseAsync(resultJson === undefined ? undefined : JSON.parse(resultJson));
   }
 
   getChainInfo(): Promise<ChainInfo> {