@aztec/stdlib 5.0.0-rc.2 → 5.0.0

package/src/block/l2_block_stream/event_driven_l2_block_stream.ts

@@ -0,0 +1,207 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+
+import type { BlockData } from '../block_data.js';
+import type { L2Block } from '../l2_block.js';
+import {
+  type ArchiverEmitter,
+  type BlockQuery,
+  type BlocksQuery,
+  type L2BlockSource,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+  type L2BlockSourceUpdatedEvent,
+  type L2Tips,
+} from '../l2_block_source.js';
+import { type L2BlockStreamEventHandler, type L2BlockStreamLocalDataProvider, localTipsMatch } from './interfaces.js';
+import { L2BlockStream, type L2BlockStreamOptions, type L2BlockStreamSource } from './l2_block_stream.js';
+
+/** Derives the metadata-only {@link BlockData} view of a hydrated {@link L2Block}. */
+async function l2BlockToBlockData(block: L2Block): Promise<BlockData> {
+  return {
+    header: block.header,
+    archive: block.archive,
+    blockHash: await block.hash(),
+    checkpointNumber: block.checkpointNumber,
+    indexWithinCheckpoint: block.indexWithinCheckpoint,
+  };
+}
+
+/** Returns the event emitter of a source that exposes one, or undefined for plain (e.g. RPC-backed) sources. */
+function getEmitter(source: L2BlockSource | L2BlockSourceEventEmitter): ArchiverEmitter | undefined {
+  return 'events' in source ? source.events : undefined;
+}
+
+/** Fast-path context for a single sync pass: blocks to serve by number, plus the tips to report as the source's. */
+type ActiveUpdate = { byNumber: Map<number, L2Block>; toTips: L2Tips };
+
+/**
+ * Wraps a block source so a single sync pass can be served from blocks delivered by an aggregate update event,
+ * avoiding round-trips to archiver storage. The fast path is only armed (via {@link activate}) for a pass that is
+ * confirmed caught up to the event's pre-pass tips: in that case the event's `blocksAdded` contiguously cover the
+ * pass's download range and `toTips` is the exact post-pass tip, so `getL2Tips` can report it without querying the
+ * source. When the fast path is not armed, every read delegates to the source, so a stale or partial cache never
+ * changes the sync outcome.
+ */
+class HotBlockSourceAdapter implements L2BlockStreamSource {
+  /** Set for the duration of one fast-path pass; undefined when reads must delegate to the source. */
+  private active: ActiveUpdate | undefined;
+
+  constructor(
+    private readonly source: L2BlockStreamSource,
+    private readonly log: Logger,
+  ) {}
+
+  /** Arms the fast path for the current pass: serve these blocks and report `toTips` as the source tips. */
+  public activate(blocks: readonly L2Block[], toTips: L2Tips): void {
+    const byNumber = new Map<number, L2Block>();
+    for (const block of blocks) {
+      byNumber.set(block.number, block);
+    }
+    this.active = { byNumber, toTips };
+    this.log.trace(`Armed hot-block fast path`, { blocks: byNumber.size, toTips });
+  }
+
+  /** Disarms the fast path so subsequent reads delegate to the source again. */
+  public deactivate(): void {
+    this.active = undefined;
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    return this.active ? Promise.resolve(this.active.toTips) : this.source.getL2Tips();
+  }
+
+  public getBlocks(query: BlocksQuery): Promise<L2Block[]> {
+    const served = this.active ? this.tryServeBlocksFromCache(query) : undefined;
+    return served ? Promise.resolve(served) : this.source.getBlocks(query);
+  }
+
+  public getBlockData(query: BlockQuery): Promise<BlockData | undefined> {
+    if (this.active && 'number' in query) {
+      const block = this.active.byNumber.get(query.number);
+      if (block) {
+        return l2BlockToBlockData(block);
+      }
+    }
+    return this.source.getBlockData(query);
+  }
+
+  /** Serves a block range from the cache only when it is fully covered by contiguous cached blocks. */
+  private tryServeBlocksFromCache(query: BlocksQuery): L2Block[] | undefined {
+    // Only the by-range form is cacheable, and only for the full (not checkpointed-only) chain: the cache may hold
+    // uncheckpointed blocks that an onlyCheckpointed query must not receive.
+    if (!this.active || !('from' in query) || query.onlyCheckpointed) {
+      return undefined;
+    }
+    const from = query.from;
+    const to = from + query.limit - 1;
+    const blocks: L2Block[] = [];
+    for (let n = from; n <= to; n++) {
+      const block = this.active.byNumber.get(n);
+      if (!block) {
+        // A gap inside the requested range: bail out and let the source serve the whole range.
+        return undefined;
+      }
+      blocks.push(block);
+    }
+    return blocks;
+  }
+}
+
+/**
+ * Event-driven wrapper around {@link L2BlockStream}. Subscribes to the source's aggregate `l2BlockSourceUpdated`
+ * event (when the source exposes one) to trigger an immediate reconciliation, while keeping the periodic poll as
+ * the correctness fallback. Subsystems keep consuming the same {@link L2BlockStreamEvent}s; the archiver aggregate
+ * event is handled entirely here.
+ *
+ * The event is passed through to the sync pass via {@link RunningPromise.trigger}. If, at the time the pass runs,
+ * the stream's local tips match the event's `fromTips` (it is caught up to where the event began), the event's
+ * hydrated blocks are served back through a hot-block cache and the event's `toTips` is reported as the source tips
+ * — so the triggered sync re-reads neither block bodies nor tips from the archiver. Otherwise the pass delegates
+ * entirely to the source, and the periodic poll guarantees eventual catch-up.
+ */
+export class EventDrivenL2BlockStream {
+  private readonly adapter: HotBlockSourceAdapter;
+  private readonly blockStream: L2BlockStream;
+  private readonly runningPromise: RunningPromise<L2BlockSourceUpdatedEvent>;
+  private readonly emitter: ArchiverEmitter | undefined;
+  private started = false;
+
+  private readonly onSourceUpdated = (event: L2BlockSourceUpdatedEvent) => {
+    // Fire-and-forget: trigger coalesces with any in-flight or periodic pass (see RunningPromise.trigger), so a
+    // burst of events does not run passes concurrently. Errors are swallowed by the inner stream's own handler.
+    void this.runningPromise
+      .trigger(event)
+      .catch(err => this.log.error(`Error in event-triggered block stream sync`, err));
+  };
+
+  constructor(
+    source: L2BlockSource | L2BlockSourceEventEmitter,
+    private readonly localData: L2BlockStreamLocalDataProvider,
+    handler: L2BlockStreamEventHandler,
+    private readonly log = createLogger('types:event_driven_block_stream'),
+    opts: L2BlockStreamOptions = {},
+  ) {
+    this.adapter = new HotBlockSourceAdapter(source, log);
+    // The inner stream's own RunningPromise is never started; this wrapper owns the polling loop and drives the
+    // stream through `sync()` (which runs `work()` directly when the inner loop is stopped).
+    this.blockStream = new L2BlockStream(this.adapter, localData, handler, log, opts);
+    this.runningPromise = new RunningPromise<L2BlockSourceUpdatedEvent>(
+      this.runPass.bind(this),
+      log,
+      opts.pollIntervalMS ?? 1000,
+    );
+    this.emitter = getEmitter(source);
+  }
+
+  public start(): void {
+    if (this.started) {
+      this.log.warn(`Attempted to start an already-started event-driven block stream`);
+      return;
+    }
+    this.started = true;
+    this.emitter?.on(L2BlockSourceEvents.L2BlockSourceUpdated, this.onSourceUpdated);
+    this.runningPromise.start();
+  }
+
+  public async stop(): Promise<void> {
+    this.started = false;
+    this.emitter?.off(L2BlockSourceEvents.L2BlockSourceUpdated, this.onSourceUpdated);
+    await this.runningPromise.stop();
+    await this.blockStream.stop();
+  }
+
+  public isRunning(): boolean {
+    return this.runningPromise.isRunning();
+  }
+
+  /**
+   * Runs a synchronization pass now, bypassing the poll interval, and resolves once that pass completes. Concurrent
+   * callers and periodic ticks coalesce onto a single pass; a caller that coalesces onto an already in-flight pass
+   * can resolve against a pass that began just before it, so this guarantees freshness only up to that coalescing
+   * window. The periodic poll and per-pass reorg handling make the gap a latency effect, never a correctness one.
+   */
+  public sync(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  /**
+   * Runs a single pass over the underlying block stream. When triggered by an aggregate event and the stream is
+   * caught up to the event's pre-pass tips, the event's blocks and tips serve the pass directly; the fast path is
+   * always disarmed afterwards so a subsequent poll-driven pass reads from the source.
+   */
+  private async runPass(event?: L2BlockSourceUpdatedEvent): Promise<void> {
+    if (event) {
+      const localTips = await this.localData.getL2Tips();
+      if (localTipsMatch(localTips, event.fromTips)) {
+        this.adapter.activate(event.blocksAdded, event.toTips);
+      }
+    }
+
+    try {
+      await this.blockStream.sync();
+    } finally {
+      this.adapter.deactivate();
+    }
+  }
+}

package/src/block/l2_block_stream/index.ts

@@ -1,3 +1,4 @@
+export * from './event_driven_l2_block_stream.js';
 export * from './interfaces.js';
 export * from './l2_block_stream.js';
 export * from './l2_tips_memory_store.js';

package/src/block/l2_block_stream/interfaces.ts

@@ -1,7 +1,7 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 
 import type { L2Block } from '../l2_block.js';
-import type { CheckpointId, L2BlockId, L2TipId, LocalL2Tips } from '../l2_block_source.js';
+import type { CheckpointId, L2BlockId, L2TipId, L2Tips, LocalL2Tips } from '../l2_block_source.js';
 
 /** Provides the current chain tips. Implemented by world-state, l2-tips-store, and AztecNode. */
 export interface L2TipsProvider {
@@ -35,6 +35,40 @@ export interface L2BlockStreamLocalDataProvider {
   getL2BlockHash(number: number): Promise<string | undefined>;
 }
 
+/**
+ * Returns whether a local block id differs from a source block id. Compares block number and, when the local hash is
+ * known, block hash. The hash comparison is skipped when the local hash is undefined: world-state legitimately
+ * reports `undefined` hashes for tips ahead of its synced range, and comparing against an undefined hash would treat
+ * such a tip as different on every poll. An `undefined` local block (no local tip yet) always counts as differing.
+ */
+export function localBlockIdDiffers(localBlock: LocalL2BlockId | undefined, sourceBlock: L2BlockId): boolean {
+  if (localBlock === undefined) {
+    return true;
+  }
+  if (sourceBlock.number !== localBlock.number) {
+    return true;
+  }
+  if (localBlock.hash === undefined) {
+    return false;
+  }
+  return sourceBlock.hash !== localBlock.hash;
+}
+
+/**
+ * Returns whether the local chain tips agree with the given source tips on every tier the local provider exposes.
+ * Each tier is compared at the block level via {@link localBlockIdDiffers} (so an unresolved local hash matches on
+ * number alone); checkpoint ids are not compared, mirroring the stream's own tier reconciliation. The optional
+ * `checkpointed` tier is only compared when present (it is absent when the stream ignores checkpoints).
+ */
+export function localTipsMatch(local: LocalChainTips, source: L2Tips): boolean {
+  return (
+    !localBlockIdDiffers(local.proposed, source.proposed) &&
+    (local.checkpointed === undefined || !localBlockIdDiffers(local.checkpointed.block, source.checkpointed.block)) &&
+    !localBlockIdDiffers(local.proven.block, source.proven.block) &&
+    !localBlockIdDiffers(local.finalized.block, source.finalized.block)
+  );
+}
+
 /** Interface to a handler of events emitted. */
 export interface L2BlockStreamEventHandler {
   handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -4,22 +4,34 @@ import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
 import type { L2Block } from '../l2_block.js';
+import { type L2BlockId, type L2BlockSource, type LocalL2Tips, makeL2BlockId } from '../l2_block_source.js';
 import {
-  type L2BlockId,
-  type L2BlockSource,
-  type L2TipId,
-  type LocalL2Tips,
-  makeL2BlockId,
-} from '../l2_block_source.js';
-import type {
-  L2BlockStreamEvent,
-  L2BlockStreamEventHandler,
-  L2BlockStreamLocalDataProvider,
-  LocalL2BlockId,
+  type L2BlockStreamEvent,
+  type L2BlockStreamEventHandler,
+  type L2BlockStreamLocalDataProvider,
+  localBlockIdDiffers,
 } from './interfaces.js';
 
 /** Subset of the block source the stream depends on. Checkpoint payloads are no longer fetched here. */
-type L2BlockStreamSource = Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips'>;
+export type L2BlockStreamSource = Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips'>;
+
+/** Options accepted by {@link L2BlockStream} and {@link EventDrivenL2BlockStream}. */
+export type L2BlockStreamOptions = {
+  pollIntervalMS?: number;
+  batchSize?: number;
+  startingBlock?: number;
+  /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
+  skipFinalized?: boolean;
+  /** When true, checkpoint events will not be emitted. Blocks are still fetched but only blocks-added events are emitted. */
+  ignoreCheckpoints?: boolean;
+  /**
+   * When true, the block download loop is skipped entirely: `getBlocks` is never called and `blocks-added` is
+   * never emitted. Only the tip events (`chain-proposed`/`chain-checkpointed`/`chain-proven`/`chain-finalized`)
+   * and `chain-pruned` are emitted, driven by the `getL2Tips` snapshot. For consumers that track tips but never
+   * consume block payloads.
+   */
+  tipsOnly?: boolean;
+};
 
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
@@ -32,22 +44,7 @@ export class L2BlockStream {
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
-    private opts: {
-      pollIntervalMS?: number;
-      batchSize?: number;
-      startingBlock?: number;
-      /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
-      skipFinalized?: boolean;
-      /** When true, checkpoint events will not be emitted. Blocks are still fetched but only blocks-added events are emitted. */
-      ignoreCheckpoints?: boolean;
-      /**
-       * When true, the block download loop is skipped entirely: `getBlocks` is never called and `blocks-added` is
-       * never emitted. Only the tip events (`chain-proposed`/`chain-checkpointed`/`chain-proven`/`chain-finalized`)
-       * and `chain-pruned` are emitted, driven by the `getL2Tips` snapshot. For consumers that track tips but never
-       * consume block payloads.
-       */
-      tipsOnly?: boolean;
-    } = {},
+    private opts: L2BlockStreamOptions = {},
   ) {
     if (opts.tipsOnly && (opts.startingBlock !== undefined || opts.batchSize !== undefined || opts.skipFinalized)) {
       throw new Error(
@@ -181,19 +178,25 @@ export class L2BlockStream {
       // End-of-pass reconciliation: chain-proposed fires against the pre-pass baseline (a post-prune re-read would
       // equal the source tip and suppress it), then the tiers highest-to-lowest so the finalized <= proven <=
       // checkpointed <= proposed invariant holds mid-pass.
-      if (this.blockTipDiffers(prePassProposed, sourceTips.proposed)) {
+      if (localBlockIdDiffers(prePassProposed, sourceTips.proposed)) {
         await this.emitEvent({ type: 'chain-proposed', block: sourceTips.proposed });
       }
 
       const reconcileTips = pruned ? await this.localData.getL2Tips() : localTips;
-      if (!this.opts.ignoreCheckpoints && this.tipDiffers(reconcileTips.checkpointed?.block, sourceTips.checkpointed)) {
+      if (
+        !this.opts.ignoreCheckpoints &&
+        localBlockIdDiffers(reconcileTips.checkpointed?.block, sourceTips.checkpointed.block)
+      ) {
         await this.emitEvent({
           type: 'chain-checkpointed',
           block: sourceTips.checkpointed.block,
           checkpoint: sourceTips.checkpointed.checkpoint,
         });
       }
-      if (reconcileTips.proven !== undefined && this.tipDiffers(reconcileTips.proven.block, sourceTips.proven)) {
+      if (
+        reconcileTips.proven !== undefined &&
+        localBlockIdDiffers(reconcileTips.proven.block, sourceTips.proven.block)
+      ) {
         await this.emitEvent({
           type: 'chain-proven',
           block: sourceTips.proven.block,
@@ -202,7 +205,7 @@ export class L2BlockStream {
       }
       if (
         reconcileTips.finalized !== undefined &&
-        this.tipDiffers(reconcileTips.finalized.block, sourceTips.finalized)
+        localBlockIdDiffers(reconcileTips.finalized.block, sourceTips.finalized.block)
       ) {
         await this.emitEvent({
           type: 'chain-finalized',
@@ -286,36 +289,6 @@ export class L2BlockStream {
     return true;
   }
 
-  /**
-   * Returns whether the source tip differs from the local one and therefore warrants a tier event. Compares block
-   * number and, when both hashes are known, block hash. The hash comparison is skipped when the local hash is
-   * undefined or missing: world-state legitimately reports `undefined` hashes for tips ahead of its synced range,
-   * and comparing against an undefined hash would re-emit the event on every poll.
-   */
-  private tipDiffers(localBlock: LocalL2BlockId | undefined, sourceTip: L2TipId): boolean {
-    return this.blockTipDiffers(localBlock, sourceTip.block);
-  }
-
-  /**
-   * Block-only variant of {@link tipDiffers} for the proposed tip (an {@link L2BlockId}, with no checkpoint). Compares
-   * block number and, when the local hash is known, block hash. The hash comparison is skipped when the local hash is
-   * undefined: world-state reports `undefined` for its proposed hash, and a strict comparison would re-emit
-   * `chain-proposed` on every poll for it. ({@link L2TipsStoreBase} consumers always carry a hash, so the leniency is
-   * inert for them.)
-   */
-  private blockTipDiffers(localBlock: LocalL2BlockId | undefined, sourceBlock: L2BlockId): boolean {
-    if (localBlock === undefined) {
-      return true;
-    }
-    if (sourceBlock.number !== localBlock.number) {
-      return true;
-    }
-    if (localBlock.hash === undefined) {
-      return false;
-    }
-    return sourceBlock.hash !== localBlock.hash;
-  }
-
   /**
    * Returns whether the source and local agree on the block hash at a given height.
    * @param blockNumber - The block number to test.

package/src/block/proposal/attestations_and_signers.ts

@@ -1,5 +1,5 @@
 import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
-import { hexToBuffer } from '@aztec/foundation/string';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
@@ -76,8 +76,10 @@ export class CommitteeAttestationsAndSigners implements Signable {
     let totalDataSize = 0;
     for (const attestation of viemAttestations) {
       const signature = attestation.signature;
-      // Check if signature is empty (v = 0)
-      const isEmpty = signature.v === 0;
+      // A slot is empty (a non-signing member, packed as its address) only when r, s and v are all zero
+      // — matching Signature.isEmpty() and getSigners(), so the bitmap popcount and the signers list can
+      // never disagree (which would revert propose() with SignersSizeMismatch).
+      const isEmpty = signature.v === 0 && BigInt(signature.r) === 0n && BigInt(signature.s) === 0n;
 
       if (!isEmpty) {
         totalDataSize += 65; // v (1) + r (32) + s (32)
@@ -93,8 +95,8 @@ export class CommitteeAttestationsAndSigners implements Signable {
     for (const [i, attestation] of viemAttestations.entries()) {
       const signature = attestation.signature;
 
-      // Check if signature is empty
-      const isEmpty = signature.v === 0;
+      // Empty iff r, s and v are all zero (see the size-tally loop above).
+      const isEmpty = signature.v === 0 && BigInt(signature.r) === 0n && BigInt(signature.s) === 0n;
 
       if (!isEmpty) {
         // Set bit in bitmap (bit 7-0 in each byte, left to right)
@@ -102,8 +104,10 @@ export class CommitteeAttestationsAndSigners implements Signable {
         const bitIndex = 7 - (i % 8);
         signatureIndices[byteIndex] = (signatureIndices[byteIndex] ?? 0) | (1 << bitIndex);
 
-        // Pack signature: v + r + s
-        signaturesOrAddresses[dataIndex] = signature.v;
+        // Pack signature: v + r + s. Canonicalize a yParity recovery byte (v = 0/1) to 27/28 — it
+        // recovers to the same signer, but L1 ECDSA.recover only accepts 27/28. Any other value is left
+        // as-is so a genuinely malformed signature still fails on L1 rather than being silently rewritten.
+        signaturesOrAddresses[dataIndex] = signature.v === 0 || signature.v === 1 ? signature.v + 27 : signature.v;
         dataIndex++;
 
         // Pack r (32 bytes)
@@ -153,3 +157,45 @@ export class MaliciousCommitteeAttestationsAndSigners extends CommitteeAttestati
     return this.signers;
   }
 }
+
+/**
+ * Malicious extension of CommitteeAttestationsAndSigners that rewrites every non-proposer signature slot's
+ * recovery byte to yParity form (v ∈ {0, 1}) in the packed output, after the honest `packAttestations` has
+ * already canonicalized it to v ∈ {27, 28}. Models a malicious selected proposer that hand-crafts
+ * `propose()` calldata L1 accepts but no honest node can byte-replay: each rewritten signature still
+ * recovers to the same member (r, s and the recovery parity are preserved), the bitmap bits stay set, and
+ * `getSigners()` stays consistent, so `propose()` does not revert `SignersSizeMismatch` -- yet the
+ * checkpoint can never be proven (`ECDSA.recover` rejects v ∉ {27, 28}). The proposer's own slot is left
+ * canonical so L1 `verifyProposer` (which recovers that slot) still accepts the checkpoint. For testing only.
+ */
+export class MaliciousYParityCommitteeAttestationsAndSigners extends CommitteeAttestationsAndSigners {
+  constructor(
+    attestations: CommitteeAttestation[],
+    /** Committee index of the proposer's own slot, left canonical so `propose()` passes `verifyProposer`. */
+    private proposerIndex: number,
+    signatureContext: CoordinationSignatureContext,
+  ) {
+    super(attestations, signatureContext);
+  }
+
+  override getPackedAttestations(): ViemCommitteeAttestations {
+    const packed = super.getPackedAttestations();
+    const data = hexToBuffer(packed.signaturesOrAddresses);
+
+    // Walk the packed byte-vector and rewrite every non-proposer signed slot's v-byte to yParity form. A
+    // signed slot occupies 65 bytes (v, r, s); an empty slot occupies 20 bytes (address only).
+    let offset = 0;
+    for (let i = 0; i < this.attestations.length; i++) {
+      const isSigned = !this.attestations[i].signature.isEmpty();
+      if (isSigned && i !== this.proposerIndex) {
+        // `packAttestations` canonicalized v to 27/28; rewrite back to the equivalent yParity byte (0/1),
+        // preserving the recovery parity so the signature still recovers to the same member.
+        const v = data[offset];
+        data[offset] = v >= 27 ? v - 27 : v;
+      }
+      offset += isSigned ? 65 : 20;
+    }
+
+    return { signatureIndices: packed.signatureIndices, signaturesOrAddresses: bufferToHex(data) };
+  }
+}

package/src/block/validate_block_result.ts

@@ -1,7 +1,9 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
@@ -30,6 +32,14 @@ export type ValidateCheckpointNegativeResult =
       attestors: EthAddress[];
       /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
+      /**
+       * The exact packed `CommitteeAttestations` tuple as posted to L1 calldata, carried verbatim so the
+       * invalidation evidence is byte-faithful to the stored `attestationsHash`. A repack via
+       * `packAttestations` is not a round-trip inverse of `fromPacked`, so it would diverge from the hash
+       * and revert `invalidateBadAttestation`/`invalidateInsufficientAttestations`. Always populated on the
+       * calldata validation path, the only production source of invalidation evidence.
+       */
+      verbatimAttestations: ViemCommitteeAttestations;
       /** Reason for the checkpoint being invalid: not enough attestations were posted */
       reason: 'insufficient-attestations';
     }
@@ -47,6 +57,12 @@ export type ValidateCheckpointNegativeResult =
       attestors: EthAddress[];
       /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
+      /**
+       * The exact packed `CommitteeAttestations` tuple as posted to L1 calldata, carried verbatim so the
+       * invalidation evidence is byte-faithful to the stored `attestationsHash`. See the same field on the
+       * insufficient-attestations variant for why a repack cannot be used.
+       */
+      verbatimAttestations: ViemCommitteeAttestations;
       /** Reason for the checkpoint being invalid: an invalid attestation was posted */
       reason: 'invalid-attestation';
       /** Index in the attestations array of the invalid attestation posted */
@@ -56,6 +72,12 @@ export type ValidateCheckpointNegativeResult =
 /** Result type for validating checkpoint attestations */
 export type ValidateCheckpointResult = { valid: true } | ValidateCheckpointNegativeResult;
 
+/** Zod schema for the raw packed `CommitteeAttestations` viem tuple (two 0x-prefixed hex strings). */
+const ViemCommitteeAttestationsSchema: ZodFor<ViemCommitteeAttestations> = z.object({
+  signatureIndices: schemas.HexStringWith0x,
+  signaturesOrAddresses: schemas.HexStringWith0x,
+});
+
 export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
@@ -66,6 +88,7 @@ export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> =
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
+    verbatimAttestations: ViemCommitteeAttestationsSchema,
     reason: z.literal('insufficient-attestations'),
   }),
   z.object({
@@ -76,6 +99,7 @@ export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> =
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
+    verbatimAttestations: ViemCommitteeAttestationsSchema,
     reason: z.literal('invalid-attestation'),
     invalidIndex: z.number(),
   }),
@@ -87,6 +111,8 @@ export function serializeValidateCheckpointResult(result: ValidateCheckpointResu
   }
 
   const checkpointBuffer = serializeCheckpointInfo(result.checkpoint);
+  const signatureIndices = hexToBuffer(result.verbatimAttestations.signatureIndices);
+  const signaturesOrAddresses = hexToBuffer(result.verbatimAttestations.signaturesOrAddresses);
   return serializeToBuffer(
     result.valid,
     result.reason,
@@ -101,6 +127,10 @@ export function serializeValidateCheckpointResult(result: ValidateCheckpointResu
     result.attestations.length,
     result.attestations,
     result.reason === 'invalid-attestation' ? result.invalidIndex : 0,
+    signatureIndices.length,
+    signatureIndices,
+    signaturesOrAddresses.length,
+    signaturesOrAddresses,
   );
 }
 
@@ -118,10 +148,26 @@ export function deserializeValidateCheckpointResult(bufferOrReader: Buffer | Buf
   const attestors = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
   const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
   const invalidIndex = reader.readNumber();
+  const verbatimAttestations: ViemCommitteeAttestations = {
+    signatureIndices: bufferToHex(reader.readBuffer()),
+    signaturesOrAddresses: bufferToHex(reader.readBuffer()),
+  };
+
   if (reason === 'insufficient-attestations') {
-    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations, verbatimAttestations };
   } else if (reason === 'invalid-attestation') {
-    return { valid, reason, checkpoint, committee, epoch, seed, attestors, invalidIndex, attestations };
+    return {
+      valid,
+      reason,
+      checkpoint,
+      committee,
+      epoch,
+      seed,
+      attestors,
+      invalidIndex,
+      attestations,
+      verbatimAttestations,
+    };
   } else {
     const _: never = reason;
     throw new Error(`Unknown reason: ${reason}`);

package/src/config/network-consensus-config.ts

@@ -1,4 +1,4 @@
-import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type L1ContractsConfig, l1ContractsConfigMappings, validateSlotDurations } from '@aztec/ethereum/config';
 import { type EnvVar, pickConfigMappings } from '@aztec/foundation/config';
 
 import type { SequencerConfig } from '../interfaces/configs.js';
@@ -156,21 +156,10 @@ export function validateNetworkConsensusConfig(config: NetworkConsensusConfig):
     return errors;
   }
 
-  if (config.ethereumSlotDuration <= 0) {
-    errors.push(`ethereumSlotDuration must be positive (got ${config.ethereumSlotDuration})`);
-  }
+  errors.push(...validateSlotDurations(config));
   if (config.blockDurationMs <= 0) {
     errors.push(`blockDurationMs must be positive (got ${config.blockDurationMs})`);
   }
-  if (config.aztecSlotDuration <= 0) {
-    errors.push(`aztecSlotDuration must be positive (got ${config.aztecSlotDuration})`);
-  }
-  if (config.ethereumSlotDuration > 0 && config.aztecSlotDuration % config.ethereumSlotDuration !== 0) {
-    errors.push(
-      `aztecSlotDuration (${config.aztecSlotDuration}s) must be a multiple of ethereumSlotDuration ` +
-        `(${config.ethereumSlotDuration}s)`,
-    );
-  }
   if (config.blockDurationMs / 1000 > config.aztecSlotDuration) {
     errors.push(
       `blockDurationMs (${config.blockDurationMs}ms) exceeds aztecSlotDuration (${config.aztecSlotDuration}s)`,

package/src/contract/contract_address.ts

@@ -6,7 +6,8 @@ import { type FunctionAbi, FunctionSelector, encodeArguments } from '../abi/inde
 import type { AztecAddress } from '../aztec-address/index.js';
 import { computeVarArgsHash } from '../hash/hash.js';
 import { computeAddress } from '../keys/index.js';
-import type { ContractInstance } from './interfaces/contract_instance.js';
+import type { ContractInstance, ContractInstancePreimage } from './interfaces/contract_instance.js';
+import type { PartialAddress } from './partial_address.js';
 
 // TODO(@spalladino): Review all generator indices in this file
 
@@ -21,7 +22,7 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
  */
 export async function computeContractAddressFromInstance(
   instance:
-    | ContractInstance
+    | ContractInstancePreimage
     | ({ originalContractClassId: Fr; saltedInitializationHash: Fr } & Pick<ContractInstance, 'publicKeys'>),
 ): Promise<AztecAddress> {
   const partialAddress = await computePartialAddress(instance);
@@ -36,7 +37,7 @@ export async function computePartialAddress(
   instance:
     | Pick<ContractInstance, 'originalContractClassId' | 'initializationHash' | 'salt' | 'deployer' | 'immutablesHash'>
     | { originalContractClassId: Fr; saltedInitializationHash: Fr },
-): Promise<Fr> {
+): Promise<PartialAddress> {
   const saltedInitializationHash =
     'saltedInitializationHash' in instance
       ? instance.saltedInitializationHash