feat: merge-train/spartan

barretenberg/cpp/CMakePresets.json

@@ -19,7 +19,6 @@
       },
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "TARGET_ARCH": "skylake",
         "ENABLE_PIC": "ON"
       }
     },

barretenberg/cpp/bootstrap.sh

@@ -7,7 +7,7 @@ else
   export native_preset=${NATIVE_PRESET:-clang20-no-avm}
 fi
 export hash=$(hash_str $(../../avm-transpiler/bootstrap.sh hash) $(cache_content_hash .rebuild_patterns))
-export native_build_dir=$(scripts/preset-build-dir)
+export native_build_dir=$(scripts/preset-build-dir $native_preset)
 
 # Injects version number into a given bb binary.
 # Means we don't actually need to rebuild bb to release a new version if code hasn't changed.

barretenberg/cpp/cmake/arch.cmake

@@ -5,7 +5,16 @@ if(WASM)
     add_compile_options(-fno-exceptions -fno-slp-vectorize)
 endif()
 
-if(NOT WASM AND NOT ARM AND TARGET_ARCH)
+# Auto-detect TARGET_ARCH on x86_64 if not explicitly set (native builds only).
+# On ARM, we skip -march entirely — the zig wrappers use an explicit aarch64 target
+# to produce generic ARM64 code without CPU-specific extensions (e.g. SVE).
+# Skip auto-detection when cross-compiling — the toolchain (e.g. Zig -mcpu) handles
+# architecture targeting, and injecting -march here conflicts with it.
+if(NOT WASM AND NOT TARGET_ARCH AND NOT ARM AND NOT CMAKE_CROSSCOMPILING)
+    set(TARGET_ARCH "skylake")
+endif()
+
+if(NOT WASM AND TARGET_ARCH)
     message(STATUS "Target architecture: ${TARGET_ARCH}")
     add_compile_options(-march=${TARGET_ARCH})
 endif()

barretenberg/cpp/scripts/zig-c++.sh

@@ -1,8 +1,15 @@
 #!/bin/bash
 # Wrapper for zig c++ that pins glibc 2.35 on Linux (Ubuntu 22.04+ compat)
 # and uses native target on macOS.
+# On ARM64 Linux, use an explicit aarch64 target instead of 'native' to produce
+# generic ARM64 code. This prevents CPU-specific instructions (e.g. SVE on Graviton)
+# from being emitted, ensuring binaries work across all ARM64 machines including
+# Apple Silicon in devcontainers.
 if [[ "$(uname -s)" == "Linux" ]]; then
-  exec zig c++ -target native-linux-gnu.2.35 "$@"
+  case "$(uname -m)" in
+    aarch64|arm64) exec zig c++ -target aarch64-linux-gnu.2.35 "$@" ;;
+    *)             exec zig c++ -target native-linux-gnu.2.35 "$@" ;;
+  esac
 else
   exec zig c++ "$@"
 fi

barretenberg/cpp/scripts/zig-cc.sh

@@ -1,8 +1,15 @@
 #!/bin/bash
 # Wrapper for zig cc that pins glibc 2.35 on Linux (Ubuntu 22.04+ compat)
 # and uses native target on macOS.
+# On ARM64 Linux, use an explicit aarch64 target instead of 'native' to produce
+# generic ARM64 code. This prevents CPU-specific instructions (e.g. SVE on Graviton)
+# from being emitted, ensuring binaries work across all ARM64 machines including
+# Apple Silicon in devcontainers.
 if [[ "$(uname -s)" == "Linux" ]]; then
-  exec zig cc -target native-linux-gnu.2.35 "$@"
+  case "$(uname -m)" in
+    aarch64|arm64) exec zig cc -target aarch64-linux-gnu.2.35 "$@" ;;
+    *)             exec zig cc -target native-linux-gnu.2.35 "$@" ;;
+  esac
 else
   exec zig cc "$@"
 fi

barretenberg/cpp/src/barretenberg/crypto/merkle_tree/node_store/cached_content_addressed_tree_store.hpp

@@ -867,17 +867,17 @@ void ContentAddressedCachedTreeStore<LeafValueType>::advance_finalized_block(con
         ReadTransactionPtr readTx = create_read_transaction();
         get_meta(uncommittedMeta);
         get_meta(committedMeta, *readTx, false);
+        // do nothing if the block is already finalized
+        if (committedMeta.finalizedBlockHeight >= blockNumber) {
+            return;
+        }
         if (!dataStore_->read_block_data(blockNumber, blockPayload, *readTx)) {
             throw std::runtime_error(format("Unable to advance finalized block: ",
                                             blockNumber,
                                             ". Failed to read block data. Tree name: ",
                                             forkConstantData_.name_));
         }
     }
-    // do nothing if the block is already finalized
-    if (committedMeta.finalizedBlockHeight >= blockNumber) {
-        return;
-    }
 
     // can currently only finalize up to the unfinalized block height
     if (committedMeta.finalizedBlockHeight > committedMeta.unfinalizedBlockHeight) {

barretenberg/sol/scripts/init_honk.sh

@@ -1,14 +1,22 @@
 #!/usr/bin/env bash
+set -eu
 # the verification key is the same for ultra and ultra zk
 SRS_PATH="$HOME/.bb-crs"
 OUTPUT_PATH="./src/honk"
+KEYGEN="../cpp/build/bin/honk_solidity_key_gen"
+
+if [ ! -x "$KEYGEN" ]; then
+  echo "Error: honk_solidity_key_gen binary not found at $KEYGEN" >&2
+  echo "Run barretenberg/cpp bootstrap first." >&2
+  exit 1
+fi
 
 mkdir -p './src/honk/keys'
 
-../cpp/build/bin/honk_solidity_key_gen add2 $OUTPUT_PATH $SRS_PATH
-../cpp/build/bin/honk_solidity_key_gen blake $OUTPUT_PATH $SRS_PATH
-../cpp/build/bin/honk_solidity_key_gen ecdsa $OUTPUT_PATH $SRS_PATH
-../cpp/build/bin/honk_solidity_key_gen recursive $OUTPUT_PATH $SRS_PATH
+$KEYGEN add2 $OUTPUT_PATH $SRS_PATH
+$KEYGEN blake $OUTPUT_PATH $SRS_PATH
+$KEYGEN ecdsa $OUTPUT_PATH $SRS_PATH
+$KEYGEN recursive $OUTPUT_PATH $SRS_PATH
 
 echo ""
 echo "✓ VK generation complete"

boxes/boxes/vanilla/app/main.ts

@@ -198,7 +198,7 @@ async function updateVoteTally(wallet: Wallet, from: AztecAddress) {
     )
   );
 
-  const batchResult = await new BatchCall(wallet, payloads).simulate({ from });
+  const { result: batchResult } = await new BatchCall(wallet, payloads).simulate({ from });
 
   batchResult.forEach(({ result: value }, i) => {
     results[i + 1] = value;

noir/bootstrap.sh

@@ -25,7 +25,12 @@ function build_native {
   set -euo pipefail
 
   if ! cache_download noir-$hash.tar.gz; then
-    (cd noir-repo && cargo build --locked --release --target-dir target)
+    # Serialize cargo operations to avoid race conditions with avm-transpiler
+    # which may run in parallel and share the same CARGO_HOME.
+    (
+      flock -x 200
+      cd noir-repo && cargo build --locked --release --target-dir target
+    ) 200>/tmp/rustup.lock
     cache_upload noir-$hash.tar.gz noir-repo/target/release/{nargo,acvm,noir-profiler}
   fi
 }

spartan/bootstrap.sh

@@ -120,14 +120,24 @@ function run_network_tests {
   fi
 }
 
+function slack_notify_scenario_pass {
+  local label="$1"
+  if [[ "${REF_NAME:-}" == v* ]]; then
+    slack_notify "Scenario ${label} tests PASSED on *${REF_NAME}*" "#alerts-next-scenario"
+  fi
+}
+
 function network_tests_1 {
   run_network_tests "$1" "smoke.test.ts" "${NETWORK_TESTS_1[@]}"
+  slack_notify_scenario_pass "set-1"
 }
 function network_tests_2 {
   run_network_tests "$1" "smoke.test.ts" "${NETWORK_TESTS_2[@]}"
+  slack_notify_scenario_pass "set-2"
 }
 function network_tests {
   run_network_tests "$1" "smoke.test.ts" "${NETWORK_TESTS_1[@]}" "${NETWORK_TESTS_2[@]}"
+  slack_notify_scenario_pass "all"
 }
 
 function network_bench_cmds {

spartan/scripts/extract_proving_metrics.ts

@@ -79,6 +79,7 @@ const config = parseArgs(process.argv);
 
 interface LogEntry {
   timestamp: string;
+  trace?: string;
   jsonPayload?: {
     message?: string;
     [key: string]: any;
@@ -88,7 +89,7 @@ interface LogEntry {
 
 function buildFilter(
   textFilter: string,
-  opts?: { module?: string; pod?: string },
+  opts?: { module?: string; pod?: string; trace?: string },
 ): string {
   const pod = opts?.pod ?? config.pod;
   let filter =
@@ -101,13 +102,16 @@ function buildFilter(
   if (opts?.module) {
     filter += ` AND jsonPayload.module="${opts.module}"`;
   }
+  if (opts?.trace) {
+    filter += ` AND trace="${opts.trace}"`;
+  }
   return filter;
 }
 
 async function queryLogs(
   name: string,
   textFilter: string,
-  opts?: { module?: string; pod?: string },
+  opts?: { module?: string; pod?: string; trace?: string },
 ): Promise<LogEntry[]> {
   const filter = buildFilter(textFilter, opts);
   const cmd = [
@@ -134,7 +138,7 @@ async function queryLogs(
 
 // ── Epoch auto-detection ─────────────────────────────────────────────────────
 
-async function scanForEpoch(): Promise<{ start: string; end: string }> {
+async function scanForEpoch(): Promise<{ start: string; end: string; trace?: string }> {
   process.stderr.write(
     `Scanning for epoch in ${config.start} to ${config.end}...\n\n`,
   );
@@ -151,6 +155,7 @@ async function scanForEpoch(): Promise<{ start: string; end: string }> {
     epoch: number;
     txCount: number;
     timestamp: string;
+    trace?: string;
   }[] = [];
   for (const entry of epochStarts) {
     const m = msg(entry);
@@ -163,6 +168,7 @@ async function scanForEpoch(): Promise<{ start: string; end: string }> {
         epoch: parseInt(epochMatch[1]),
         txCount: p.epochSizeTxs ?? 0,
         timestamp: entry.timestamp,
+        trace: entry.trace,
       });
     }
   }
@@ -178,20 +184,20 @@ async function scanForEpoch(): Promise<{ start: string; end: string }> {
       process.stderr.write(
         `Warning: epoch ${config.epoch} not found in scan window. Using full window.\n`,
       );
-      return { start: config.start, end: config.end };
+      return { start: config.start, end: config.end, trace: undefined };
     }
   } else {
     target = starts.find((s) => s.txCount >= 1);
     if (!target) {
       process.stderr.write(
         `Warning: no epoch with >=1 tx found in scan window. Using full window.\n`,
       );
-      return { start: config.start, end: config.end };
+      return { start: config.start, end: config.end, trace: undefined };
     }
   }
 
   process.stderr.write(
-    `Found epoch ${target.epoch} (${target.txCount} txs) at ${target.timestamp}\n`,
+    `Found epoch ${target.epoch} (${target.txCount} txs) at ${target.timestamp}${target.trace ? ` trace=${target.trace}` : ""}\n`,
   );
 
   // Find matching finalized entry
@@ -226,7 +232,7 @@ async function scanForEpoch(): Promise<{ start: string; end: string }> {
     `Narrowed window: ${narrowedStart} to ${narrowedEnd}\n\n`,
   );
 
-  return { start: narrowedStart, end: narrowedEnd };
+  return { start: narrowedStart, end: narrowedEnd, trace: target.trace };
 }
 
 // ── Pipeline order for proving job types ─────────────────────────────────────
@@ -249,11 +255,15 @@ const PIPELINE_ORDER = [
 
 // ── Query definitions ────────────────────────────────────────────────────────
 
-async function fetchAllData() {
+async function fetchAllData(trace?: string) {
   process.stderr.write(
     `Fetching logs for ${config.pod} in ${config.namespace}\n`,
   );
-  process.stderr.write(`Time range: ${config.start} to ${config.end}\n\n`);
+  process.stderr.write(`Time range: ${config.start} to ${config.end}\n`);
+  if (trace) {
+    process.stderr.write(`Trace filter: ${trace}\n`);
+  }
+  process.stderr.write("\n");
 
   const brokerPod = `${config.namespace}-prover-broker-0`;
 
@@ -268,15 +278,16 @@ async function fetchAllData() {
     brokerNewJobs,
     brokerCompleteJobs,
   ] = await Promise.all([
-    queryLogs("epoch-start", "Starting epoch.*proving job"),
-    queryLogs("blob-fields", "Blob fields per checkpoint"),
-    queryLogs("blob-batching", "Final blob batching"),
+    queryLogs("epoch-start", "Starting epoch.*proving job", { trace }),
+    queryLogs("blob-fields", "Blob fields per checkpoint", { trace }),
+    queryLogs("blob-batching", "Final blob batching", { trace }),
     queryLogs("starting-block", "Starting block", {
       module: "prover-client:orchestrator",
+      trace,
     }),
-    queryLogs("processed-txs", "Processed.*successful txs"),
-    queryLogs("adding-txs", "Adding.*transactions to block"),
-    queryLogs("epoch-finalized", "Finalized proof for epoch"),
+    queryLogs("processed-txs", "Processed.*successful txs", { trace }),
+    queryLogs("adding-txs", "Adding.*transactions to block", { trace }),
+    queryLogs("epoch-finalized", "Finalized proof for epoch", { trace }),
     queryLogs("broker-new-jobs", "New proving job", { pod: brokerPod }),
     queryLogs("broker-complete-jobs", "Proving job complete", {
       pod: brokerPod,
@@ -841,7 +852,7 @@ async function main() {
   config.start = scanResult.start;
   config.end = scanResult.end;
 
-  const data = await fetchAllData();
+  const data = await fetchAllData(scanResult.trace);
   const output = formatOutput(data);
   console.log(output);
 }

yarn-project/.claude/skills/unit-test-implementation/SKILL.md

@@ -23,6 +23,28 @@ beforeEach(() => {
 });
 ```
 
+### NEVER Pass Complex Objects as mock() Props
+
+`jest-mock-extended`'s `mock<T>(props)` deep-processes any objects passed as initial properties. When those objects contain class instances with internal state (like `Fr`, `EthAddress`, `AztecAddress`, `GasFees`, `Buffer`, etc.), this causes **O(2^n) exponential slowdown** across tests — each test doubles the time of the previous one.
+
+```typescript
+// ❌ NEVER: Passing complex domain objects as mock props
+// This causes exponential test slowdown (1s → 2s → 4s → 8s → ...)
+const constants = { chainId: new Fr(1), coinbase: EthAddress.random(), gasFees: GasFees.empty() };
+beforeEach(() => {
+  builder = mock<CheckpointBuilder>({ checkpointNumber, constants });
+});
+
+// ✅ GOOD: Create mock without props, then set properties directly
+beforeEach(() => {
+  builder = mock<CheckpointBuilder>();
+  Object.defineProperty(builder, 'checkpointNumber', { value: checkpointNumber });
+  Object.defineProperty(builder, 'constants', { value: constants });
+});
+```
+
+Simple primitives (strings, numbers, booleans) and arrow functions are safe to pass as props. The issue is specifically with class instances that have complex prototypes.
+
 ### When to Use Real Instances vs Mocks
 
 **Mock external dependencies** that are:

yarn-project/archiver/src/config.ts

@@ -8,7 +8,12 @@ import {
   getConfigFromMappings,
   numberConfigHelper,
 } from '@aztec/foundation/config';
-import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import {
+  type ChainConfig,
+  type PipelineConfig,
+  chainConfigMappings,
+  pipelineConfigMappings,
+} from '@aztec/stdlib/config';
 import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
 
 /**
@@ -21,11 +26,13 @@ import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
 export type ArchiverConfig = ArchiverSpecificConfig &
   L1ReaderConfig &
   L1ContractsConfig &
+  PipelineConfig & // required to pass through to epoch cache
   BlobClientConfig &
   ChainConfig;
 
 export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   ...blobClientConfigMapping,
+  ...pipelineConfigMappings,
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',

yarn-project/archiver/src/modules/data_store_updater.ts

@@ -457,7 +457,7 @@ export class ArchiverDataStoreUpdater {
       if (validFnCount > 0) {
         this.log.verbose(`Storing ${validFnCount} functions for contract class ${contractClassId.toString()}`);
       }
-      return await this.store.addFunctions(contractClassId, validPrivateFns, validUtilityFns);
+      await this.store.addFunctions(contractClassId, validPrivateFns, validUtilityFns);
     }
     return true;
   }

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -111,6 +111,7 @@ import {
   createBlockProposalHandler,
   createValidatorClient,
 } from '@aztec/validator-client';
+import type { SlashingProtectionDatabase } from '@aztec/validator-ha-signer/types';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
 import { createPublicClient } from 'viem';
@@ -195,6 +196,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       dateProvider?: DateProvider;
       p2pClientDeps?: P2PClientDeps;
       proverNodeDeps?: Partial<ProverNodeDeps>;
+      slashingProtectionDb?: SlashingProtectionDatabase;
     } = {},
     options: {
       prefilledPublicData?: PublicDataTreeLeaf[];
@@ -377,6 +379,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
         l1ToL2MessageSource: archiver,
         keyStoreManager,
         blobClient,
+        slashingProtectionDb: deps.slashingProtectionDb,
       });
 
       // If we have a validator client, register it as a source of offenses for the slasher,