feat: merge-train/spartan (#24834)

BEGIN_COMMIT_OVERRIDE
chore(spartan): lower mainnet inactivity slash target to 70% (#24827)
chore: add rate-limited testnet rpc client (#24836)
fix(ci): move nightly bench inclusion sweep to 06:00 UTC (#24830)
fix(bench): handle void worker-wallet returns in inclusion sweep
(#24843)
END_COMMIT_OVERRIDE

Author: AztecBot

.github/workflows/nightly-bench-inclusion-sweep.yml

@@ -9,7 +9,11 @@ name: Nightly Bench Inclusion Sweep
 
 on:
   schedule:
-    - cron: "30 3 * * *"
+    # 06:00 UTC, matching the other nightly consumers (spartan-bench, deploy-next-net).
+    # The nightly git tag + docker image this sweep resolves are produced by the
+    # Nightly Release Tag workflow at 04:00 UTC; running earlier races that job and
+    # fails "Verify source git ref" with "couldn't find remote ref".
+    - cron: "0 6 * * *"
   workflow_dispatch:
     inputs:
       docker_image:

spartan/environments/network-defaults.yml

@@ -365,7 +365,7 @@ networks:
     ENABLE_AUTO_SHUTDOWN: false
     # Slasher penalties - more lenient initially
     SLASH_DATA_WITHHOLDING_PENALTY: 0
-    SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8
+    SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7
     SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2
     SLASH_INACTIVITY_PENALTY: 2000e18
     SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2000e18

spartan/terraform/deploy-rpc/environments/testnet/main.tf

@@ -72,17 +72,30 @@ locals {
     })
   }
 
+  # Consumers listed here get no per-minute cap (rate_limit_minute = 0). Consumers that need a
+  # finite cap go in rate_limited_consumers instead, since this loop hardcodes 0 for every entry.
   consumer_secret_names = [
     "testnet-rpc-consumer-client1"
   ]
 
-  consumers = {
-    for name in local.consumer_secret_names : name => {
-      username                       = name
-      gcp_secret_manager_secret_name = name
-      rate_limit_minute              = 0
+  rate_limited_consumers = {
+    "testnet-rpc-consumer-client2" = {
+      username                       = "testnet-rpc-consumer-client2"
+      gcp_secret_manager_secret_name = "testnet-rpc-consumer-client2"
+      rate_limit_minute              = 3000
     }
   }
+
+  consumers = merge(
+    {
+      for name in local.consumer_secret_names : name => {
+        username                       = name
+        gcp_secret_manager_secret_name = name
+        rate_limit_minute              = 0
+      }
+    },
+    local.rate_limited_consumers
+  )
 }
 
 module "environment" {

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