Merge branch 'main' into caner/rbuilder-reth2-testing

Author: canercidam

containers/helix.ts

@@ -1,8 +1,18 @@
 import type { ContainerDef, ContainerResult, Ctx, Ports } from "../utils/types.ts";
+import { RELAY_BUILDER_PUBKEY } from "./rbuilder.ts";
+
+// Optimistic relaying is per-builder: the builder's pubkey must be present in
+// `builders:` with is_optimistic + collateral ≥ bid value. 1e24 wei (1M ETH)
+// clears any devnet bid. accept_optimistic itself already defaults true in helix.
+const DEFAULT_COLLATERAL = "1000000000000000000000000";
 
 const DEFAULT_API_PORT = 4040;
 const DEFAULT_TCP_PORT = 4041;
 const DEFAULT_WEBSITE_PORT = 9060;
+// helix serves prometheus metrics from start_metrics_server on $METRICS_PORT
+// (default 9500). Exposed so the bench's prometheus can scrape helix-native
+// metrics (helix_request_latency_secs, helix_submission_trace_latency_us, …).
+const DEFAULT_METRICS_PORT = 9500;
 const DEFAULT_RELAY_KEY = "0x64496d4e301e541a6e1237d6ef13a8f8b8b6cb82be9d8ac90073a833dfc2af11";
 const DEFAULT_ADMIN_TOKEN = "decker";
 const DEFAULT_POSTGRES_PASSWORD = "helix";
@@ -11,9 +21,72 @@ export const ports: Ports = {
   http: DEFAULT_API_PORT,
   tcp: DEFAULT_TCP_PORT,
   website: DEFAULT_WEBSITE_PORT,
+  metrics: DEFAULT_METRICS_PORT,
+};
+
+type HelixYamlOpts = {
+  beaconUrl: string;
+  simUrl: string;
+  apiPort: number;
+  tcpPort: number;
+  headerDelay: boolean;
+  optimistic: boolean;
+  builderPubkey: string;
+  collateral: string;
+  coreCount: number;
 };
 
-function helixYaml(beaconUrl: string, simUrl: string, apiPort: number, tcpPort: number): string {
+// helix hard-pins each tile thread to a CPU id via core_affinity, and `cores` is
+// a required config block — so the layout determines whether helix's pipeline runs
+// in parallel or all on one core. Spread the tiles across the host's cores: the
+// auctioneer (the single-threaded serial stage) gets its own core, and the async
+// HTTP runtime (serves submitBlock + getHeader) and the decoder get the largest
+// shares; background tiles share core 0. On a small host pinning to high core ids
+// would fail, so fall back to the original single-core layout. coreCount is the
+// host's logical CPUs (the devnet sets no cpuset, so the container sees them all).
+function helixCoresYaml(coreCount: number): string {
+  if (coreCount < 8) {
+    return `cores:
+  auctioneer: 0
+  tokio: [0]
+  reg_workers: [0]
+  tcp_bid_submissions_tile: 0
+  decoder: [0]
+  simulator: 0
+  top_bid: 0`;
+  }
+  const pool = Array.from({ length: coreCount - 2 }, (_, i) => i + 2); // cores 2 … n-1
+  const tcp = pool.pop()!;
+  const sim = pool.pop()!;
+  const reg = [pool.pop()!, pool.pop()!];
+  const half = Math.ceil(pool.length / 2);
+  const tokio = pool.slice(0, half); // bigger share → HTTP runtime
+  const decoder = pool.slice(half); //  remainder → decode/deserialize
+  return `cores:
+  auctioneer: 1
+  tokio: [${tokio.join(", ")}]
+  reg_workers: [${reg.join(", ")}]
+  tcp_bid_submissions_tile: ${tcp}
+  decoder: [${decoder.join(", ")}]
+  simulator: ${sim}
+  top_bid: 0
+  data_gatherer: 0`;
+}
+
+// Register the builder in both modes so the comparison is a known builder either
+// way; is_optimistic toggles the path: false = pessimistic (wait on sim), true =
+// fast path (accept before sim). An unregistered builder is a different scenario,
+// not the sync baseline we want.
+function buildersBlock(o: HelixYamlOpts): string {
+  return `builders:
+  - pub_key: "${o.builderPubkey}"
+    builder_info:
+      collateral: "${o.collateral}"
+      is_optimistic: ${o.optimistic}
+      is_optimistic_for_regional_filtering: false`;
+}
+
+function helixYaml(o: HelixYamlOpts): string {
   return `\
 postgres:
   hostname: 127.0.0.1
@@ -23,15 +96,15 @@ postgres:
   region: 0
   region_name: "LOCAL"
 simulators:
-  - url: ${simUrl}
+  - url: ${o.simUrl}
 beacon_clients:
-  - url: ${beaconUrl}
+  - url: ${o.beaconUrl}
 relays: []
-builders: []
+${buildersBlock(o)}
 validator_preferences:
   filtering: global
   trusted_builders: null
-  header_delay: true
+  header_delay: ${o.headerDelay}
 router_config:
   enabled_routes:
     - route: All
@@ -44,16 +117,9 @@ is_submission_instance: true
 is_registration_instance: true
 website:
   enabled: false
-cores:
-  auctioneer: 0
-  tokio: [0]
-  reg_workers: [0]
-  tcp_bid_submissions_tile: 0
-  decoder: [0]
-  simulator: 0
-  top_bid: 0
-api_port: ${apiPort}
-tcp_port: ${tcpPort}
+${helixCoresYaml(o.coreCount)}
+api_port: ${o.apiPort}
+tcp_port: ${o.tcpPort}
 `;
 }
 
@@ -66,9 +132,18 @@ export function buildContainer(def: ContainerDef, ctx: Ctx): ContainerResult {
   const apiPort = (def.config?.apiPort as number | undefined) ?? DEFAULT_API_PORT;
   const tcpPort = (def.config?.tcpPort as number | undefined) ?? DEFAULT_TCP_PORT;
   const websitePort = (def.config?.websitePort as number | undefined) ?? DEFAULT_WEBSITE_PORT;
+  const metricsPort = (def.config?.metricsPort as number | undefined) ?? DEFAULT_METRICS_PORT;
   const relayKey = (def.config?.relayKey as string | undefined) ?? DEFAULT_RELAY_KEY;
   const adminToken = (def.config?.adminToken as string | undefined) ?? DEFAULT_ADMIN_TOKEN;
   const postgresPassword = (def.config?.postgresPassword as string | undefined) ?? DEFAULT_POSTGRES_PASSWORD;
+  // Bench knobs: optimistic enables the fast path for the builder; headerDelay
+  // off measures raw getHeader serve latency (defaults preserve standalone behaviour).
+  const optimistic = (def.config?.optimistic as boolean | undefined) ?? false;
+  const headerDelay = (def.config?.headerDelay as boolean | undefined) ?? true;
+  const builderPubkey = (def.config?.builderPubkey as string | undefined) ?? RELAY_BUILDER_PUBKEY;
+  const collateral = (def.config?.collateral as string | undefined) ?? DEFAULT_COLLATERAL;
+  // Distribute helix's tiles across the host's CPUs (override with config.coreCount).
+  const coreCount = (def.config?.coreCount as number | undefined) ?? navigator.hardwareConcurrency;
 
   return {
     container: {
@@ -78,8 +153,9 @@ export function buildContainer(def: ContainerDef, ctx: Ctx): ContainerResult {
         RELAY_KEY: relayKey,
         ADMIN_TOKEN: adminToken,
         POSTGRES_PASSWORD: postgresPassword,
+        METRICS_PORT: String(metricsPort),
       },
-      ports: { http: apiPort, tcp: tcpPort, website: websitePort },
+      ports: { http: apiPort, tcp: tcpPort, website: websitePort, metrics: metricsPort },
       volumeMounts: [
         { name: "relay-logs", mountPath: "/app/logs" },
       ],
@@ -90,7 +166,17 @@ export function buildContainer(def: ContainerDef, ctx: Ctx): ContainerResult {
     configs: [
       {
         filename: "helix.yml",
-        content: helixYaml(ctx.url(beacon, "http"), ctx.url(sim, "rpc"), apiPort, tcpPort),
+        content: helixYaml({
+          beaconUrl: ctx.url(beacon, "http"),
+          simUrl: ctx.url(sim, "rpc"),
+          apiPort,
+          tcpPort,
+          headerDelay,
+          optimistic,
+          builderPubkey,
+          collateral,
+          coreCount,
+        }),
         mountPath: "/config/helix.yml",
       },
     ],

containers/rbuilder.ts

@@ -2,6 +2,13 @@ import type { ContainerDef, ContainerResult, Ctx, HostCtx, ProcessDef, ProcessRe
 
 const DEFAULT_HTTP_PORT = 8745;
 
+// BLS pubkey (G1, 48 bytes) of relay_secret_key below — the builder identity the
+// relay sees on submitBlock. Relays mark THIS pubkey optimistic to enable the
+// fast path. (Derived from the secret key; the devnet reuses validator-0's BLS
+// key, so it coincides with the sole proposer's pubkey.)
+export const RELAY_BUILDER_PUBKEY =
+  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c";
+
 export const ports = {
   http: { port: DEFAULT_HTTP_PORT, protocol: "TCP" as const, service: false },
   // Telemetry servers (see rbuilderConfigFor): redacted = http+1, full = http+2.

recipes/contender-bench.ts

@@ -11,7 +11,7 @@ import type { Recipe } from "../utils/types.ts";
 // No `artifacts`: contender is a pure client and consumes none, so up() skips
 // generation entirely.
 export function contenderBench(
-  opts: { rpcUrl: string; txsUrl?: string; duration?: number; privKey?: string },
+  opts: { rpcUrl: string; txsUrl?: string; duration?: number; privKey?: string; tps?: number; scenario?: string },
 ): Recipe {
   return {
     pods: [
@@ -24,6 +24,8 @@ export function contenderBench(
             config: {
               rpcUrl: opts.rpcUrl,
               duration: opts.duration ?? 30,
+              ...(opts.tps ? { tps: opts.tps } : {}),
+              ...(opts.scenario ? { scenario: opts.scenario } : {}),
               ...(opts.txsUrl ? { txsUrl: opts.txsUrl } : {}),
               ...(opts.privKey ? { privKey: opts.privKey } : {}),
             },

recipes/relay-bench.ts

@@ -1,15 +1,11 @@
 import type { Recipe } from "../utils/types.ts";
-import { benchmarkRelays } from "../scripts/relay-bench.ts";
-import { recipe as helix } from "./relay/helix.ts";
-import { recipe as mevBoostRelay } from "./relay/mev-boost-relay.ts";
+import { benchmarkRelays, defaultTargets } from "../scripts/relay-bench.ts";
 
-// Parent: no devnet of its own. Its script brings up each base single-relay
-// recipe in turn, loads it, measures, tears it down, and prints the comparison.
-// `decker up relay-bench` runs the whole thing.
+// Parent: no devnet of its own. Its script benchmarks each relay in both sync and
+// optimistic mode — bringing up a fresh single-relay devnet per (relay, mode),
+// loading the one builder, measuring from the relay's native metrics, tearing it
+// down — then prints the comparison. `decker up relay-bench` runs the whole thing.
 export const recipe: Recipe = {
   pods: [],
-  scripts: [benchmarkRelays([
-    { name: "helix", label: "helix-1", recipe: helix, relayPort: 4040 },
-    { name: "mev-boost-relay", label: "mev-boost-relay-1", recipe: mevBoostRelay, relayPort: 9062 },
-  ])],
+  scripts: [benchmarkRelays(await defaultTargets())],
 };