fix(timeboost): multi-bid auction resolution + report accuracy

- auctionRunner: bidders now name distinct express-lane controllers
  (Bob→Carol, Alice→herself). The auctioneer bid cache is keyed by
  controller (nitro bid_cache.go), so identical controllers collapsed
  both bids into a single-bid auction that resolved at the reserve price.
  Distinct controllers keep both bids → multi-bid → second-price (100).
- auctionMonitor: read AuctionResolved second price from `args.price`
  (was secondPriceAmount/amount, which never exist → always showed "?").
- timeboostDemoRunner: no-bid control round now fires two parallel normal
  txs so the report's "both txs, no ordering advantage" narrative holds.

Verified end-to-end on Arbitrum Sepolia: auctioneer logs "Resolving
auction with two bids", report shows secondPrice=100, controller=Carol,
EL ~10ms vs normal ~220ms.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Jason-W123

src/playbooks/timeboost/auctionMonitor.ts

@@ -118,7 +118,10 @@ function describeEvent(name: string, args: Record<string, unknown>): string {
   if (name === 'AuctionResolved') {
     const round = args.round ?? args._round ?? '?';
     const winner = args.firstPriceBidder ?? args.winner ?? args.expressLaneController ?? '?';
-    const second = args.secondPriceAmount ?? args.amount ?? '?';
+    // The actual second-price (what the winner pays) is emitted as `price`.
+    // `firstPriceAmount` is the winner's own bid; keep the other names as
+    // forward-compat fallbacks in case nitro-contracts renames the field.
+    const second = args.price ?? args.secondPriceAmount ?? args.amount ?? '?';
     return `round=${round} winner=${winner} secondPrice=${second}`;
   }
   if (name === 'SetExpressLaneController') {

src/playbooks/timeboost/auctionRunner.ts

@@ -3,10 +3,17 @@
  *
  * Choreography per round:
  *   1. wait until we're in the bidding window (NOT in the auction-closed window)
- *   2. Alice + Bob each `submitBid()` for round N+1 with controller=Carol
+ *   2. Alice + Bob each `submitBid()` for round N+1, naming DIFFERENT express
+ *      lane controllers. This matters: the auctioneer's bid cache is keyed by
+ *      `expressLaneController` (nitro/timeboost/bid_cache.go:27), so two bids
+ *      naming the *same* controller would overwrite each other → only one bid
+ *      survives → single-bid resolution at the reserve price. Distinct
+ *      controllers keep both bids → multi-bid resolution at the second price.
+ *      Bob (higher bid) names the winner controller (Carol); Alice names herself.
  *   3. (auctioneer-server runs the resolution at T-auctionClosingSeconds)
  *   4. wait until round N+1 starts; assert via auctionMonitor that
- *      AuctionResolved + SetExpressLaneController fired with controller=Carol
+ *      AuctionResolved (two bids, second price) + SetExpressLaneController
+ *      (controller=Carol) fired.
  *
  * Returns metadata each round so the demo runner can record it.
  */
@@ -34,7 +41,12 @@ export interface RunOneAuctionInput {
   // Bidders (passed as private keys so the bidder can do raw-hash sign of Bid)
   aliceKey: Hex;
   bobKey: Hex;
-  controller: Address; // Carol
+  // Express lane controllers named in each bid. MUST be distinct (see header
+  // comment) or the auctioneer collapses both bids into a single-bid auction.
+  // Bob is the higher bidder, so `winnerController` is the address that ends up
+  // controlling the express lane for the round.
+  winnerController: Address; // named by Bob (the winning bid) — e.g. Carol
+  loserController: Address; // named by Alice (the losing bid) — e.g. Alice herself
 
   // Bid amounts (units = bidding token wei). Bob bids higher → wins.
   aliceBidAmount: bigint;
@@ -103,7 +115,7 @@ export async function runOneAuction(input: RunOneAuctionInput, events: AuctionEv
       auctionAddress: input.auctionAddress,
       bidValidatorUrl: input.bidValidatorUrl,
       round: bidForRound,
-      expressLaneController: input.controller,
+      expressLaneController: input.loserController,
       amount: input.aliceBidAmount,
     }),
   );
@@ -114,7 +126,7 @@ export async function runOneAuction(input: RunOneAuctionInput, events: AuctionEv
       auctionAddress: input.auctionAddress,
       bidValidatorUrl: input.bidValidatorUrl,
       round: bidForRound,
-      expressLaneController: input.controller,
+      expressLaneController: input.winnerController,
       amount: input.bobBidAmount,
     }),
   );

src/playbooks/timeboost/timeboostDemoRunner.ts

@@ -278,7 +278,10 @@ export async function runFullTimeboostDemo(ctx?: OperationContext): Promise<Time
         timing,
         aliceKey: accounts.alice.privateKey,
         bobKey: accounts.bob.privateKey,
-        controller: accounts.carol.account.address,
+        // Distinct controllers so the auctioneer keeps BOTH bids (multi-bid →
+        // second-price resolution). Bob wins, so Carol controls the express lane.
+        winnerController: accounts.carol.account.address,
+        loserController: accounts.alice.account.address,
         aliceBidAmount: parseUnits('100', 0),
         bobBidAmount: parseUnits('250', 0),
         aliceNeedsDeposit: i === 0,
@@ -362,27 +365,39 @@ export async function runFullTimeboostDemo(ctx?: OperationContext): Promise<Time
   const noBidRound = snapshotRound(timing).current + 1;
   await waitUntilRound(timing, noBidRound);
   await sleep(500);
-  // Just send one normal tx (no controller exists this round, so EL would be rejected).
+
+  // Fire TWO normal txs in parallel. There's no controller this round, so the
+  // 200ms penalty applies to nobody — both should come back timeboosted=false
+  // with near-identical low latency (no ordering advantage), the exact opposite
+  // of the winning-round experiment. (An express-lane tx isn't sent here: with
+  // no controller it would just be rejected.)
   const noBidStartedAtMs = Date.now();
-  const submission = await submitNormalTx({
-    senderAccount: accounts.dave.account,
-    childClient: restartedClient,
-    chainId,
-    to: accounts.alice.account.address,
-    label: 'no-bid',
-  });
-  const observation = await completeObservation({
-    lane: 'normal',
-    childClient: restartedClient,
-    txHash: submission.txHash,
-    sentAtMs: submission.sentAtMs,
-    sender: accounts.dave.account.address,
-    round: noBidRound,
-    timeoutMs: 30_000,
-  });
-  const noBidRounds: NoBidRoundRecord[] = [
-    { round: noBidRound, startedAtMs: noBidStartedAtMs, observations: [observation] },
-  ];
+  const observeNoBidTx = async (
+    from: ReturnType<typeof privateKeyToAccount>,
+    to: Address,
+  ): Promise<NoBidRoundRecord['observations'][number]> => {
+    const sub = await submitNormalTx({
+      senderAccount: from,
+      childClient: restartedClient,
+      chainId,
+      to,
+      label: 'no-bid',
+    });
+    return completeObservation({
+      lane: 'normal',
+      childClient: restartedClient,
+      txHash: sub.txHash,
+      sentAtMs: sub.sentAtMs,
+      sender: from.address,
+      round: noBidRound,
+      timeoutMs: 30_000,
+    });
+  };
+  const observations = await Promise.all([
+    observeNoBidTx(accounts.dave.account, accounts.alice.account.address),
+    observeNoBidTx(accounts.alice.account, accounts.dave.account.address),
+  ]);
+  const noBidRounds: NoBidRoundRecord[] = [{ round: noBidRound, startedAtMs: noBidStartedAtMs, observations }];
   ctx?.stepCompleted('No-bid round (control)');
 
   // -------------------------------------------------------------------------