fix(sequencer): override pending-tip slotNumber so canPruneAtTime can't bypass pending override

When pipelining with a proposed parent, the canProposeAt simulation overrides
`tips.pending` to the parent's checkpoint number but the centralised override
helper was not setting `tempCheckpointLogs[pending].slotNumber`. The L1
`STFLib.canPruneAtTime(_ts)` reads that slot via `getEpochForCheckpoint(proven + 1)`;
with the override unset it falls back to 0 (epoch 0), which at any non-trivial
simulation timestamp is far past its proof-submission window. `canPruneAtTime`
returns true, `getEffectivePendingCheckpointNumber` collapses pending back to
proven, the pending override is silently bypassed, and
`canProposeAtTime` then compares the supplied archive against
`archives[proven]` (= genesis on a fresh chain), reverting with
`Rollup__InvalidArchive(genesis, syncedTo.archive)`. This was the cause of the
"Rollup contract check failed" / proposer-rollup-check-failed reverts across
the e2e_epochs_mbps, epochs_missed_l1_slot, and e2e_l1_publisher tests after
7c9268f centralised the override helper and dropped the
`withPendingTempCheckpointLogFields` call the pre-refactor helper had.

Restore the slotNumber override (only) in the centralised helper. The other
fields the pre-refactor helper set (headerHash, outHash, payloadDigest) were
only consumed by the propose-call simulation that 85b6a02 removed; the
post-refactor enqueue-time simulations (canProposeAt and validateBlockHeader
with ignoreSignatures: true) do not read them. To make the partial override
expressible, loosen `withPendingTempCheckpointLogFields` to accept any subset
of fields — the underlying `makeTempCheckpointLogOverride` already emits a
stateDiff entry per field actually set.

Also switch `archiveForCheck` and `lastArchiveRoot` from `syncedTo.archive` to
`syncedTo.proposedCheckpointData.archive.root` when pipelining with a proposed
parent. The two values agree in steady state but can transiently diverge when
world-state has not yet applied the proposed parent's blocks locally; the
proposed-checkpoint archive is the value L1 will actually see at archives[pending]
once the parent lands, and using it on both sides of the comparison keeps the
override and the supplied archive in lockstep.

Diagnosed against /tmp/a1442bdbf1cf22fe.log (epochs_mbps) and
/tmp/b84862271b974e83.log (e2e_l1_publisher); confirmed independently by codex.

Author: spalladino

yarn-project/ethereum/src/contracts/chain_state_override.ts

@@ -87,15 +87,21 @@ export class SimulationOverridesBuilder {
   }
 
   /**
-   * Overrides the locally-derivable `tempCheckpointLogs` cell fields for the configured pending
-   * checkpoint. Callers populate these together because they all come from the same proposed
-   * checkpoint payload — there is no use case for setting them independently.
+   * Overrides one or more `tempCheckpointLogs` cell fields for the configured pending checkpoint.
+   * Fields are independent: any subset can be provided. The translator (`makeTempCheckpointLogOverride`)
+   * emits a stateDiff entry per field actually set, so unspecified fields stay at their on-chain
+   * values.
+   *
+   * `slotNumber` is load-bearing for `STFLib.canPruneAtTime`: when the simulation overrides `pending`
+   * to a checkpoint that has no on-chain `tempCheckpointLogs` entry yet, the missing slotNumber falls
+   * back to 0 and the contract treats the pending tip as belonging to epoch 0, triggering a phantom
+   * prune that silently undoes the `pending` override.
    */
   public withPendingTempCheckpointLogFields(fields: {
-    headerHash: Fr;
-    outHash: Fr;
-    payloadDigest: Buffer32;
-    slotNumber: SlotNumber;
+    headerHash?: Fr;
+    outHash?: Fr;
+    payloadDigest?: Buffer32;
+    slotNumber?: SlotNumber;
   }): this {
     this.assertPendingCheckpointNumber();
     this.pendingCheckpointState = { ...(this.pendingCheckpointState ?? {}), ...fields };

yarn-project/sequencer-client/src/sequencer/chain_state_overrides.ts

@@ -44,6 +44,19 @@ export async function buildCheckpointSimulationOverridesPlan(
     if (input.lastArchiveRoot !== undefined) {
       builder.withPendingArchive(input.lastArchiveRoot);
     }
+    // When pipelining with a proposed parent we must also override the parent's
+    // tempCheckpointLogs.slotNumber: without it `STFLib.canPruneAtTime` reads a slotNumber of 0
+    // for the overridden pending tip, decides the tip is in a long-expired epoch, and reports the
+    // chain as prunable. `getEffectivePendingCheckpointNumber` then collapses pending back to
+    // proven and the pending override is silently bypassed, producing a spurious
+    // `Rollup__InvalidArchive` against the on-chain genesis archive. The invalidate-only override
+    // path does not have a proposed parent to read the slot from; it relies on the absence of an
+    // unproven pending tip to avoid this code path.
+    if (input.proposedCheckpointData) {
+      builder.withPendingTempCheckpointLogFields({
+        slotNumber: input.proposedCheckpointData.header.slotNumber,
+      });
+    }
   }
   if (feeHeader) {
     builder.withPendingFeeHeader(feeHeader);

yarn-project/sequencer-client/src/sequencer/sequencer.ts

@@ -393,6 +393,12 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         `Building on top of proposed checkpoint (pending=${syncedTo.proposedCheckpointData?.checkpointNumber}) for target slot ${targetSlot}`,
         { targetSlot, parentCheckpointNumber: CheckpointNumber(checkpointNumber - 1) },
       );
+      // Match what L1 will see at archives[pending] once the proposed parent lands: the parent's
+      // own archive root from the gossiped proposal. `syncedTo.archive` is the world-state-local
+      // view and can transiently diverge from the proposed parent (e.g. before the proposed
+      // parent's blocks have been applied locally); diverging here would cause the canProposeAt
+      // override to set archives[pending] to one value while we present another for comparison.
+      archiveForCheck = syncedTo.proposedCheckpointData!.archive.root;
       // Clear the invalidation - the proposed checkpoint should handle it.
       invalidateCheckpoint = undefined;
     } else if (invalidateCheckpoint) {
@@ -410,7 +416,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       proposedCheckpointData:
         isPipelining && syncedTo.hasProposedCheckpoint ? syncedTo.proposedCheckpointData : undefined,
       invalidateToPendingCheckpointNumber: invalidateCheckpoint?.forcePendingCheckpointNumber,
-      lastArchiveRoot: isPipelining && syncedTo.hasProposedCheckpoint ? syncedTo.archive : undefined,
+      lastArchiveRoot:
+        isPipelining && syncedTo.hasProposedCheckpoint ? syncedTo.proposedCheckpointData!.archive.root : undefined,
       rollup: this.rollupContract,
       log: this.log,
     });