fix(bench): handle void worker-wallet returns in inclusion sweep

WorkerWallet.call unconditionally JSON.parse'd the transport response, but
void-returning methods (registerContract, registerContractClass) come back as
`undefined` from the worker. JSON.parse(undefined) throws
`SyntaxError: "undefined" is not valid JSON`, which crashed registerSponsoredFPC
during n_tps.test.ts setup and failed every nightly bench inclusion-sweep point
(1/5/10 TPS) deterministically.

Pass an undefined response straight to the method's schema, whose z.void() output
accepts it, and widen callRaw's return type to string | undefined to match.

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> {