@aztec/p2p 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/mem_pools/tx_pool_v2/tx_pool_v2_impl.ts

@@ -1,4 +1,5 @@
 import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { FifoSet } from '@aztec/foundation/fifo-set';
 import type { Logger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
@@ -17,6 +18,7 @@ import {
   EvictionManager,
   FeePayerBalanceEvictionRule,
   FeePayerBalancePreAddRule,
+  InsufficientFeePerGasEvictionRule,
   InvalidTxsAfterMiningRule,
   InvalidTxsAfterReorgRule,
   LowPriorityEvictionRule,
@@ -39,6 +41,13 @@ import {
 import { type TxMetaData, type TxState, buildTxMetaData, checkNullifierConflict } from './tx_metadata.js';
 import { TxPoolIndices } from './tx_pool_indices.js';
 
+/**
+ * Maximum number of full transactions to load into memory at once when finalizing a block.
+ * Bounds peak memory while archiving and hard-deleting mined txs (~23k txs/epoch at 10 TPS would
+ * otherwise OOM the node).
+ */
+const FINALIZE_BLOCK_CHUNK_SIZE = 100;
+
 /**
  * Callbacks for the implementation to notify the outer class about events and metrics.
  */
@@ -56,7 +65,10 @@ export interface TxPoolV2Callbacks {
 export class TxPoolV2Impl {
   // === Persistence ===
   #store: AztecAsyncKVStore;
+  /** Tx data without its proof. Proofs live in #proofsDB so a tx can be read without loading its proof. */
   #txsDB: AztecAsyncMap<string, Buffer>;
+  /** Tx proofs, keyed by tx hash. Written and deleted in lockstep with #txsDB. */
+  #proofsDB: AztecAsyncMap<string, Buffer>;
 
   // === Dependencies ===
   #l2BlockSource: L2BlockSource;
@@ -74,7 +86,7 @@ export class TxPoolV2Impl {
   #evictionManager: EvictionManager;
   #dateProvider: DateProvider;
   #instrumentation: TxPoolV2Instrumentation;
-  #evictedTxHashes: Set<string> = new Set();
+  #evictedTxHashes: FifoSet<string>;
   #log: Logger;
   #callbacks: TxPoolV2Callbacks;
 
@@ -90,6 +102,7 @@ export class TxPoolV2Impl {
   ) {
     this.#store = store;
     this.#txsDB = store.openMap('txs');
+    this.#proofsDB = store.openMap('tx_proofs');
 
     this.#l2BlockSource = deps.l2BlockSource;
     this.#worldStateSynchronizer = deps.worldStateSynchronizer;
@@ -97,8 +110,9 @@ export class TxPoolV2Impl {
     this.#checkAllowedSetupCalls = deps.checkAllowedSetupCalls;
 
     this.#config = { ...DEFAULT_TX_POOL_V2_CONFIG, ...config };
+    this.#evictedTxHashes = FifoSet.withLimit<string>(this.#config.evictedTxCacheSize);
     this.#archive = new TxArchive(archiveStore, this.#config.archivedTxLimit, log);
-    this.#deletedPool = new DeletedPool(store, this.#txsDB, log);
+    this.#deletedPool = new DeletedPool(store, txHashStr => this.#deleteTxData(txHashStr), log);
     this.#dateProvider = dateProvider;
     this.#instrumentation = new TxPoolV2Instrumentation(telemetry, () => this.#indices.getTotalMetadataBytes());
     this.#log = log;
@@ -116,6 +130,7 @@ export class TxPoolV2Impl {
 
     // Post-event eviction rules (run after events to check ALL pending txs)
     this.#evictionManager.registerRule(new InvalidTxsAfterMiningRule());
+    this.#evictionManager.registerRule(new InsufficientFeePerGasEvictionRule(deps.blockMinFeesProvider));
     this.#evictionManager.registerRule(new InvalidTxsAfterReorgRule(deps.worldStateSynchronizer));
     this.#evictionManager.registerRule(new FeePayerBalanceEvictionRule(deps.worldStateSynchronizer));
     // LowPriorityEvictionRule handles cases where txs become pending via prepareForSlot (unprotect)
@@ -138,46 +153,74 @@ export class TxPoolV2Impl {
     // Step 0: Hydrate deleted pool state
     await this.#deletedPool.hydrateFromDatabase();
 
-    // Step 1: Load all transactions from DB (excluding soft-deleted)
-    const { loaded, errors: deserializationErrors } = await this.#loadAllTxsFromDb();
+    // Step 1: Stream txs from DB, building metadata and mined status one at a time.
+    const minedMetas: TxMetaData[] = [];
+    const pendingMetas: TxMetaData[] = [];
+    const deserializationErrors: string[] = [];
 
-    // Step 2: Check mined status for each tx
-    await this.#markMinedStatusBatch(loaded.map(l => l.meta));
+    for await (const [txHashStr, buffer] of this.#txsDB.entriesAsync()) {
+      // Skip soft-deleted transactions - they stay in DB but not in indices
+      if (this.#deletedPool.isSoftDeleted(txHashStr)) {
+        continue;
+      }
 
-    // Step 3: Partition by mined status
-    const mined: TxMetaData[] = [];
-    const nonMined: { tx: Tx; meta: TxMetaData }[] = [];
-    for (const entry of loaded) {
-      if (entry.meta.minedL2BlockId !== undefined) {
-        mined.push(entry.meta);
+      let meta: TxMetaData;
+      let txEffect: Awaited<ReturnType<L2BlockSource['getTxEffect']>>;
+      try {
+        const tx = Tx.fromBuffer(buffer);
+        // Resolve allowed-setup-calls and the tx effect concurrently
+        // getTxEffect failures are non-fatal (we just treat the tx as not-yet-mined), so
+        // its rejection is swallowed before the Promise.all so it can't fail-fast the batch.
+        const txEffectPromise = this.#l2BlockSource.getTxEffect(tx.getTxHash()).catch(err => {
+          this.#log.warn(`Failed to check mined status for tx ${txHashStr}`, { err });
+          return undefined;
+        });
+        const [allowedSetupCalls, fetchedTxEffect] = await Promise.all([
+          this.#checkAllowedSetupCalls(tx),
+          txEffectPromise,
+        ]);
+        meta = await buildTxMetaData(tx, allowedSetupCalls);
+        txEffect = fetchedTxEffect;
+      } catch (err) {
+        this.#log.warn(`Failed to deserialize tx ${txHashStr}, deleting`, { err });
+        deserializationErrors.push(txHashStr);
+        continue;
+      }
+
+      if (txEffect) {
+        meta.minedL2BlockId = {
+          number: txEffect.l2BlockNumber,
+          hash: txEffect.l2BlockHash.toString(),
+        };
+      }
+
+      if (meta.minedL2BlockId !== undefined) {
+        minedMetas.push(meta);
       } else {
-        nonMined.push(entry);
+        pendingMetas.push(meta);
       }
     }
 
-    // Step 4: Validate non-mined transactions
-    const { valid, invalid } = await this.#revalidateMetadata(
-      nonMined.map(e => e.meta),
-      'on startup',
-    );
+    // Step 2: Validate non-mined transactions
+    const { valid, invalid } = await this.#revalidateMetadata(pendingMetas, 'on startup');
 
-    // Step 5: Populate mined indices (these don't need conflict resolution)
-    for (const meta of mined) {
+    // Step 3: Populate mined indices (these don't need conflict resolution)
+    for (const meta of minedMetas) {
       this.#indices.addMined(meta);
     }
 
-    // Step 6: Rebuild pending pool by running pre-add rules for each tx
+    // Step 4: Rebuild pending pool by running pre-add rules for each tx
     // This resolves nullifier conflicts, fee payer balance issues, and pool size limits
     const { rejected } = await this.#rebuildPendingPool(valid);
 
-    // Step 7: Delete invalid and rejected txs from DB only (indices were never populated for these)
+    // Step 5: Delete invalid and rejected txs from DB only (indices were never populated for these)
     const toDelete = [...deserializationErrors, ...invalid, ...rejected];
     if (toDelete.length === 0) {
       return;
     }
     await this.#store.transactionAsync(async () => {
       for (const txHashStr of toDelete) {
-        await this.#txsDB.delete(txHashStr);
+        await this.#deleteTxData(txHashStr);
       }
     });
     this.#log.info(`Deleted ${toDelete.length} invalid/rejected transactions on startup`, { txHashes: toDelete });
@@ -423,10 +466,11 @@ export class TxPoolV2Impl {
           // Update protection for existing tx
           this.#indices.updateProtection(txHashStr, slotNumber);
         } else if (this.#deletedPool.isSoftDeleted(txHashStr)) {
-          // Resurrect soft-deleted tx as protected
+          // Resurrect soft-deleted tx as protected. Load the proof too: #addTx rewrites both entries, so re-adding
+          // a proofless tx would wipe the stored proof.
           const buffer = await this.#txsDB.getAsync(txHashStr);
           if (buffer) {
-            const tx = Tx.fromBuffer(buffer);
+            const tx = await this.#loadTxWithProof(txHashStr, buffer);
             await this.#addTx(tx, { protected: slotNumber });
             softDeletedHits++;
           } else {
@@ -541,29 +585,62 @@ export class TxPoolV2Impl {
       }
 
       this.#log.info(`Preparing for slot ${slotNumber}: unprotecting ${txsToRestore.length} txs`);
+      await this.#restoreUnprotectedToPending(txsToRestore, 'during prepareForSlot');
+    });
+  }
 
-      // Step 4: Validate for pending pool
-      const { valid, invalid } = await this.#revalidateMetadata(txsToRestore, 'during prepareForSlot');
+  async unprotectTxs(txHashes: TxHash[], slotNumber: SlotNumber): Promise<void> {
+    const hashStrs = txHashes.map(h => h.toString());
 
-      // Step 5: Resolve nullifier conflicts and add winners to pending indices
-      const { added, toEvict } = this.#applyNullifierConflictResolution(valid);
+    await this.#store.transactionAsync(async () => {
+      // Only release entries still recorded at this exact slot. A tx that another, still-live proposal
+      // raised to a higher slot via updateProtection must keep that protection. Mined txs have no
+      // protection entry and so are never matched here.
+      const matching = this.#indices.findProtectedTxsAtSlot(hashStrs, slotNumber);
+      if (matching.length === 0) {
+        this.#log.debug(`Unprotecting txs for slot ${slotNumber}: no matching protections to release`);
+        return;
+      }
 
-      // Step 6: Delete invalid txs and evict conflict losers
-      await this.#deleteTxsBatch(invalid);
-      await this.#evictTxs(toEvict, 'NullifierConflict');
+      this.#indices.clearProtection(matching);
 
-      // Step 7: Run eviction rules (enforce pool size limit)
-      if (added.length > 0) {
-        const feePayers = added.map(meta => meta.feePayer);
-        const uniqueFeePayers = new Set<string>(feePayers);
-        await this.#evictionManager.evictAfterNewTxs(
-          added.map(m => m.txHash),
-          [...uniqueFeePayers],
-        );
+      const txsToRestore = this.#indices.filterRestorable(matching);
+      if (txsToRestore.length === 0) {
+        return;
       }
+
+      this.#log.info(`Unprotecting ${txsToRestore.length} txs from failed proposal at slot ${slotNumber}`);
+      await this.#restoreUnprotectedToPending(txsToRestore, 'during unprotectTxs');
     });
   }
 
+  /**
+   * Returns just-unprotected txs to the pending pool: revalidates them, resolves nullifier
+   * conflicts, deletes losers, then enforces the pool size limit. Must run inside a store
+   * transaction; callers clear the protection entries before invoking.
+   */
+  async #restoreUnprotectedToPending(txsToRestore: TxMetaData[], context: string): Promise<void> {
+    // Step 1: Validate for pending pool
+    const { valid, invalid } = await this.#revalidateMetadata(txsToRestore, context);
+
+    // Step 2: Resolve nullifier conflicts and add winners to pending indices
+    const { added, toEvict } = this.#applyNullifierConflictResolution(valid);
+
+    // Step 3: Delete invalid txs and evict conflict losers
+    await this.#deleteTxsBatch(invalid);
+    await this.#evictTxs(toEvict, 'NullifierConflict');
+
+    // Step 4: Run eviction rules (enforce pool size limit)
+    if (added.length > 0) {
+      const feePayers = added.map(meta => meta.feePayer);
+      const uniqueFeePayers = new Set<string>(feePayers);
+      await this.#evictionManager.evictAfterNewTxs(
+        added.map(m => m.txHash),
+        [...uniqueFeePayers],
+      );
+    }
+  }
+
   async handlePrunedBlocks(latestBlock: L2BlockId, options?: { deleteAllTxs?: boolean }): Promise<void> {
     // Step 1: Find transactions mined after the prune point
     const txsToUnmine = this.#indices.findTxsMinedAfter(latestBlock.number);
@@ -638,28 +715,29 @@ export class TxPoolV2Impl {
     // Step 1: Find mined txs at or before finalized block
     const minedTxsToFinalize = this.#indices.findTxsMinedAtOrBefore(blockNumber);
 
-    await this.#store.transactionAsync(async () => {
-      // Step 2: Collect mined txs for archiving (before deletion)
-      const txsToArchive: Tx[] = [];
-      if (this.#archive.isEnabled()) {
-        for (const txHashStr of minedTxsToFinalize) {
+    // Step 2: Archive in chunks if archiving is enabled. Hydrating an entire epoch's worth of
+    // mined txs at once would OOM under load. When archiving is disabled there is no need to hydrate the txs at all.
+    if (this.#archive.isEnabled()) {
+      for (let i = 0; i < minedTxsToFinalize.length; i += FINALIZE_BLOCK_CHUNK_SIZE) {
+        const chunk = minedTxsToFinalize.slice(i, i + FINALIZE_BLOCK_CHUNK_SIZE);
+        const txsToArchive: Tx[] = [];
+        for (const txHashStr of chunk) {
           const buffer = await this.#txsDB.getAsync(txHashStr);
           if (buffer) {
             txsToArchive.push(Tx.fromBuffer(buffer));
           }
         }
+        if (txsToArchive.length > 0) {
+          await this.#archive.archiveTxs(txsToArchive);
+        }
       }
+    }
 
-      // Step 3: Delete mined txs from active pool
+    // Step 3: Delete mined txs from the active pool and finalize soft-deleted txs in one
+    // transaction. Only tx hashes are touched here, so memory is bounded and atomicity is preserved.
+    await this.#store.transactionAsync(async () => {
       await this.#deleteTxsBatch(minedTxsToFinalize);
-
-      // Step 4: Finalize soft-deleted txs
       await this.#deletedPool.finalizeBlock(blockNumber);
-
-      // Step 5: Archive mined txs
-      if (txsToArchive.length > 0) {
-        await this.#archive.archiveTxs(txsToArchive);
-      }
     });
 
     if (minedTxsToFinalize.length > 0) {
@@ -671,20 +749,36 @@ export class TxPoolV2Impl {
 
   // === Query Methods ===
 
-  async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
-    const buffer = await this.#txsDB.getAsync(txHash.toString());
-    return buffer ? Tx.fromBuffer(buffer) : undefined;
+  async getTxByHash(txHash: TxHash, opts: { includeProof?: boolean } = {}): Promise<Tx | undefined> {
+    const txHashStr = txHash.toString();
+    const buffer = await this.#txsDB.getAsync(txHashStr);
+    if (!buffer) {
+      return undefined;
+    }
+    return opts.includeProof === false ? Tx.fromBuffer(buffer) : this.#loadTxWithProof(txHashStr, buffer);
   }
 
-  async getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+  async getTxsByHash(txHashes: TxHash[], opts: { includeProof?: boolean } = {}): Promise<(Tx | undefined)[]> {
     const results: (Tx | undefined)[] = [];
     for (const h of txHashes) {
-      const buffer = await this.#txsDB.getAsync(h.toString());
-      results.push(buffer ? Tx.fromBuffer(buffer) : undefined);
+      results.push(await this.getTxByHash(h, opts));
     }
     return results;
   }
 
+  /** Deserializes a tx blob loaded from #txsDB together with its separately-stored proof. */
+  async #loadTxWithProof(txHashStr: string, buffer: Buffer): Promise<Tx> {
+    const proofBuffer = await this.#proofsDB.getAsync(txHashStr);
+    if (!proofBuffer) {
+      // #addTx always writes a proof entry (an empty proof serializes to a 4-byte sentinel), so a missing entry
+      // means the blob/proof invariant is broken. Return the proofless tx but flag it, since a consumer that needs
+      // the proof (eg serving peers) would otherwise fail far away from the root cause.
+      this.#log.warn(`Missing stored proof for tx ${txHashStr}`, { txHash: txHashStr });
+      return Tx.fromBuffer(buffer);
+    }
+    return Tx.fromBuffers(buffer, proofBuffer);
+  }
+
   hasTxs(txHashes: TxHash[]): boolean[] {
     return txHashes.map(h => {
       const hashStr = h.toString();
@@ -811,7 +905,8 @@ export class TxPoolV2Impl {
     const meta = precomputedMeta ?? (await buildTxMetaData(tx));
     meta.receivedAt = this.#dateProvider.now();
 
-    await this.#txsDB.set(txHashStr, tx.toBuffer());
+    await this.#txsDB.set(txHashStr, tx.withoutProof().toBuffer());
+    await this.#proofsDB.set(txHashStr, tx.chonkProof.toBuffer());
     await this.#deletedPool.clearSoftDeleted(txHashStr);
     this.#callbacks.onTxsAdded([tx], opts);
 
@@ -850,6 +945,12 @@ export class TxPoolV2Impl {
     await this.#deletedPool.deleteTx(txHashStr);
   }
 
+  /** Hard-deletes a tx's stored data (tx blob and proof) from the DB. */
+  async #deleteTxData(txHashStr: string): Promise<void> {
+    await this.#txsDB.delete(txHashStr);
+    await this.#proofsDB.delete(txHashStr);
+  }
+
   /** Deletes a batch of transactions, emitting callbacks individually for each. */
   async #deleteTxsBatch(txHashes: string[]): Promise<void> {
     for (const txHashStr of txHashes) {
@@ -865,21 +966,11 @@ export class TxPoolV2Impl {
     this.#instrumentation.recordEvictions(txHashes.length, reason);
     for (const txHashStr of txHashes) {
       this.#log.debug(`Evicting tx ${txHashStr}`, { txHash: txHashStr, reason });
-      this.#addToEvictedCache(txHashStr);
+      this.#evictedTxHashes.add(txHashStr);
     }
     await this.#deleteTxsBatch(txHashes);
   }
 
-  /** Adds a tx hash to the bounded evicted cache, evicting the oldest entry if at capacity. */
-  #addToEvictedCache(txHashStr: string): void {
-    if (this.#evictedTxHashes.size >= this.#config.evictedTxCacheSize) {
-      // FIFO eviction: remove the first (oldest) entry
-      const oldest = this.#evictedTxHashes.values().next().value!;
-      this.#evictedTxHashes.delete(oldest);
-    }
-    this.#evictedTxHashes.add(txHashStr);
-  }
-
   // ============================================================================
   // PRIVATE HELPERS - Validation & Conflict Resolution
   // ============================================================================
@@ -974,51 +1065,6 @@ export class TxPoolV2Impl {
     };
   }
 
-  /** Loads all transactions from the database, returning loaded txs and deserialization errors */
-  async #loadAllTxsFromDb(): Promise<{
-    loaded: { tx: Tx; meta: TxMetaData }[];
-    errors: string[];
-  }> {
-    const loaded: { tx: Tx; meta: TxMetaData }[] = [];
-    const errors: string[] = [];
-
-    for await (const [txHashStr, buffer] of this.#txsDB.entriesAsync()) {
-      // Skip soft-deleted transactions - they stay in DB but not in indices
-      if (this.#deletedPool.isSoftDeleted(txHashStr)) {
-        continue;
-      }
-
-      try {
-        const tx = Tx.fromBuffer(buffer);
-        const allowedSetupCalls = await this.#checkAllowedSetupCalls(tx);
-        const meta = await buildTxMetaData(tx, allowedSetupCalls);
-        loaded.push({ tx, meta });
-      } catch (err) {
-        this.#log.warn(`Failed to deserialize tx ${txHashStr}, deleting`, { err });
-        errors.push(txHashStr);
-      }
-    }
-
-    return { loaded, errors };
-  }
-
-  /** Queries block source and marks mined status on transaction metadata */
-  async #markMinedStatusBatch(metas: TxMetaData[]): Promise<void> {
-    for (const meta of metas) {
-      try {
-        const txEffect = await this.#l2BlockSource.getTxEffect(TxHash.fromString(meta.txHash));
-        if (txEffect) {
-          meta.minedL2BlockId = {
-            number: txEffect.l2BlockNumber,
-            hash: txEffect.l2BlockHash.toString(),
-          };
-        }
-      } catch (err) {
-        this.#log.warn(`Failed to check mined status for tx ${meta.txHash}`, { err });
-      }
-    }
-  }
-
   /**
    * Rebuilds the pending pool by processing each tx through pre-add rules.
    * Starts with an empty pending pool and adds txs one by one, resolving conflicts.
@@ -1093,7 +1139,7 @@ export class TxPoolV2Impl {
         const publicStateSource = new DatabasePublicStateSource(db);
         const balance = await publicStateSource.storageRead(
           ProtocolContractAddress.FeeJuice,
-          await computeFeePayerBalanceStorageSlot(AztecAddress.fromString(feePayer)),
+          await computeFeePayerBalanceStorageSlot(AztecAddress.fromStringUnsafe(feePayer)),
         );
         return balance.toBigInt();
       },

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -3,19 +3,33 @@ import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   type CheckpointAttestation,
+  type CoordinationSignatureContext,
   type P2PValidator,
   PeerErrorSeverity,
   type ValidationResult,
+  hasValidSignatureContext,
 } from '@aztec/stdlib/p2p';
-
-import { isWithinClockTolerance } from '../clock_tolerance.js';
+import type { ConsensusTimetable } from '@aztec/stdlib/timetable';
 
 export class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
   protected epochCache: EpochCacheInterface;
   protected logger: Logger;
+  private readonly timetable: ConsensusTimetable;
+  protected readonly signatureContext: CoordinationSignatureContext;
+  private readonly clockDisparityMs: number;
 
-  constructor(epochCache: EpochCacheInterface) {
+  constructor(
+    epochCache: EpochCacheInterface,
+    timetable: ConsensusTimetable,
+    opts: {
+      signatureContext: CoordinationSignatureContext;
+      clockDisparityMs: number;
+    },
+  ) {
     this.epochCache = epochCache;
+    this.timetable = timetable;
+    this.signatureContext = opts.signatureContext;
+    this.clockDisparityMs = opts.clockDisparityMs;
     this.logger = createLogger('p2p:checkpoint-attestation-validator');
   }
 
@@ -23,19 +37,36 @@ export class CheckpointAttestationValidator implements P2PValidator<CheckpointAt
     const slotNumber = message.payload.header.slotNumber;
 
     try {
-      // Use target slots since proposals target pipeline slots (slot + 1 when pipelining)
-      const { targetSlot, nextSlot } = this.epochCache.getTargetAndNextSlot();
+      // Cross-chain replay check: reject attestations that carry a foreign signing domain.
+      if (!hasValidSignatureContext(message.payload, this.signatureContext)) {
+        this.logger.warn(`Rejecting checkpoint attestation with foreign signature context for slot ${slotNumber}`, {
+          chainId: message.payload.signatureContext.chainId,
+          rollupAddress: message.payload.signatureContext.rollupAddress.toString(),
+          expectedChainId: this.signatureContext.chainId,
+          expectedRollupAddress: this.signatureContext.rollupAddress.toString(),
+        });
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
+      }
 
-      if (slotNumber !== targetSlot && slotNumber !== nextSlot) {
-        // Check if message is for previous slot and within clock tolerance
-        if (!isWithinClockTolerance(slotNumber, targetSlot, this.epochCache)) {
-          this.logger.warn(
-            `Checkpoint attestation slot ${slotNumber} is not current (${targetSlot}) or next (${nextSlot}) slot`,
-          );
-          return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
-        }
-        this.logger.debug(`Ignoring checkpoint attestation for previous slot ${slotNumber} within clock tolerance`);
-        return { result: 'ignore' };
+      // Accept attestations whose explicit per-slot receive window contains the current wall-clock time.
+      // The window spans the build-frame start (attestation_receive_start) to the attestation deadline
+      // (target_slot_start + S - 2E), widened by the configured clock-disparity tolerance on both ends, so
+      // it covers the build slot, the target slot, and clock-disparity grace. This is the sole arrival
+      // gate; attestations are otherwise attributed by content, not by current/next slot.
+      const startSeconds = this.timetable.getAttestationReceiveStart(slotNumber);
+      const deadlineSeconds = this.timetable.getAttestationDeadline(slotNumber);
+      const nowMs = Number(this.epochCache.getEpochAndSlotNow().nowMs);
+      if (
+        nowMs < startSeconds * 1000 - this.clockDisparityMs ||
+        nowMs > deadlineSeconds * 1000 + this.clockDisparityMs
+      ) {
+        this.logger.warn(`Checkpoint attestation slot ${slotNumber} is outside its receive window`, {
+          slotNumber,
+          nowMs,
+          windowStartSeconds: startSeconds,
+          windowDeadlineSeconds: deadlineSeconds,
+        });
+        return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
       }
 
       // Verify the signature is valid

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -1,5 +1,11 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type CheckpointAttestation, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
+import {
+  type CheckpointAttestation,
+  type CoordinationSignatureContext,
+  PeerErrorSeverity,
+  type ValidationResult,
+} from '@aztec/stdlib/p2p';
+import type { ConsensusTimetable } from '@aztec/stdlib/timetable';
 import { Attributes, Metrics, type TelemetryClient, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 
 import type { AttestationPoolApi } from '../../mem_pools/attestation_pool/attestation_pool.js';
@@ -18,10 +24,15 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
 
   constructor(
     epochCache: EpochCacheInterface,
+    timetable: ConsensusTimetable,
     private attestationPool: AttestationPoolApi,
     telemetryClient: TelemetryClient,
+    opts: {
+      signatureContext: CoordinationSignatureContext;
+      clockDisparityMs: number;
+    },
   ) {
-    super(epochCache);
+    super(epochCache, timetable, opts);
     this.logger = this.logger.createChild('[FISHERMAN]');
 
     const meter = telemetryClient.getMeter('FishermanAttestationValidator');
@@ -54,8 +65,7 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
       return { result: 'accept' };
     }
 
-    const proposalId = message.archive.toString();
-    const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
+    const proposal = await this.attestationPool.getCheckpointProposal(message.payload.header.slotNumber);
 
     if (proposal) {
       // Compare the attestation payload with the proposal payload
@@ -84,9 +94,7 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
       }
     } else {
       // We might receive attestations before proposals in some cases
-      this.logger.debug(
-        `Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`,
-      );
+      this.logger.debug(`Received attestation for slot ${slotNumberBigInt} but proposal not found yet.`);
     }
 
     return { result: 'accept' };

package/src/msg_validators/proposal_validator/README.md

@@ -53,7 +53,7 @@ Only runs on validator nodes. Non-validator nodes use a default handler that tri
 
 **Escape hatch**: during escape hatch periods (`isEscapeHatchOpenAtSlot`), re-execution and slashing are both disabled, and the proposal is rejected locally.
 
-**Conditional re-execution**: rules 22-24 only run when at least one condition is true: `fishermanMode` enabled, `slashBroadcastedInvalidBlockPenalty > 0` with `validatorReexecute`, committee membership with `validatorReexecute`, `alwaysReexecuteBlockProposals`, or `blobClient.canUpload()`.
+**Conditional re-execution**: rules 22-24 only run when at least one condition is true: `fishermanMode` enabled, `slashBroadcastedInvalidBlockPenalty > 0`, committee membership, `alwaysReexecuteBlockProposals`, or `blobClient.canUpload()`.
 
 **Slashing**: only `state_mismatch` and `failed_txs` trigger on-chain slashing (`OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL`, gated by `slashBroadcastedInvalidBlockPenalty > 0`). Unknown errors during re-execution do NOT slash.
 

package/src/msg_validators/proposal_validator/block_proposal_validator.ts

@@ -1,13 +1,25 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type { BlockProposal, P2PValidator, ValidationResult } from '@aztec/stdlib/p2p';
+import type { BlockProposal, CoordinationSignatureContext, P2PValidator, ValidationResult } from '@aztec/stdlib/p2p';
+import type { ConsensusTimetable } from '@aztec/stdlib/timetable';
 
 import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
 
 export class BlockProposalValidator implements P2PValidator<BlockProposal> {
   private proposalValidator: ProposalValidator;
 
-  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean; maxTxsPerBlock?: number }) {
-    this.proposalValidator = new ProposalValidator(epochCache, opts, 'p2p:block_proposal_validator');
+  constructor(
+    epochCache: EpochCacheInterface,
+    timetable: ConsensusTimetable,
+    opts: {
+      txsPermitted: boolean;
+      maxTxsPerBlock?: number;
+      maxBlocksPerCheckpoint?: number;
+      skipSlotValidation?: boolean;
+      signatureContext: CoordinationSignatureContext;
+      clockDisparityMs: number;
+    },
+  ) {
+    this.proposalValidator = new ProposalValidator(epochCache, timetable, opts, 'p2p:block_proposal_validator');
   }
 
   async validate(proposal: BlockProposal): Promise<ValidationResult> {