@aztec/p2p 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.0.1-commit.2f68f620",
+  "version": "0.0.1-commit.3100065",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -67,18 +67,18 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.2f68f620",
-    "@aztec/epoch-cache": "0.0.1-commit.2f68f620",
-    "@aztec/ethereum": "0.0.1-commit.2f68f620",
-    "@aztec/foundation": "0.0.1-commit.2f68f620",
-    "@aztec/kv-store": "0.0.1-commit.2f68f620",
-    "@aztec/noir-contracts.js": "0.0.1-commit.2f68f620",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.2f68f620",
-    "@aztec/protocol-contracts": "0.0.1-commit.2f68f620",
-    "@aztec/simulator": "0.0.1-commit.2f68f620",
-    "@aztec/standard-contracts": "0.0.1-commit.2f68f620",
-    "@aztec/stdlib": "0.0.1-commit.2f68f620",
-    "@aztec/telemetry-client": "0.0.1-commit.2f68f620",
+    "@aztec/constants": "0.0.1-commit.3100065",
+    "@aztec/epoch-cache": "0.0.1-commit.3100065",
+    "@aztec/ethereum": "0.0.1-commit.3100065",
+    "@aztec/foundation": "0.0.1-commit.3100065",
+    "@aztec/kv-store": "0.0.1-commit.3100065",
+    "@aztec/noir-contracts.js": "0.0.1-commit.3100065",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3100065",
+    "@aztec/protocol-contracts": "0.0.1-commit.3100065",
+    "@aztec/simulator": "0.0.1-commit.3100065",
+    "@aztec/standard-contracts": "0.0.1-commit.3100065",
+    "@aztec/stdlib": "0.0.1-commit.3100065",
+    "@aztec/telemetry-client": "0.0.1-commit.3100065",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/libp2p-yamux": "^6.0.2",
@@ -101,12 +101,11 @@
     "semver": "^7.6.0",
     "sha3": "^2.1.4",
     "snappy": "^7.2.2",
-    "tslib": "^2.4.0",
-    "xxhash-wasm": "^1.1.0"
+    "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.2f68f620",
-    "@aztec/world-state": "0.0.1-commit.2f68f620",
+    "@aztec/archiver": "0.0.1-commit.3100065",
+    "@aztec/world-state": "0.0.1-commit.3100065",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/bootstrap/bootstrap.ts

@@ -84,15 +84,21 @@ export class BootstrapNode implements P2PBootstrapApi {
       this.logger.info('Advertised socket address updated', { addr: addr.toString() });
     });
     this.node.on('discovered', async (enr: SignableENR) => {
-      const addr = await enr.getFullMultiaddr('udp');
-      this.logger.verbose(`Discovered new peer`, { enr: enr.encodeTxt(), addr: addr?.toString() });
-      // discv5's discovered() only updates routing table entries that already exist. Nodes that
-      // established a session with an empty-IP ENR are never inserted, so even after their ENR
-      // gains a valid socket address the routing table stays empty and FINDNODE always returns 0
-      // peers. Calling addEnr() here does an insertOrUpdate regardless of prior state, fixing
-      // the routing table so these nodes become discoverable to other peers.
-      if (addr) {
-        this.node.addEnr(enr);
+      try {
+        const addr = await enr.getFullMultiaddr('udp');
+        this.logger.verbose(`Discovered new peer`, { enr: enr.encodeTxt(), addr: addr?.toString() });
+        // discv5's discovered() only updates routing table entries that already exist. Nodes that
+        // established a session with an empty-IP ENR are never inserted, so even after their ENR
+        // gains a valid socket address the routing table stays empty and FINDNODE always returns 0
+        // peers. Calling addEnr() here does an insertOrUpdate regardless of prior state, fixing
+        // the routing table so these nodes become discoverable to other peers.
+        if (addr) {
+          this.node.addEnr(enr);
+        }
+      } catch (err) {
+        // A malformed ENR address field makes the parser throw. As an async listener this would crash
+        // the bootnode on an unhandled rejection — catch, log, and drop the ENR instead.
+        this.logger.warn(`Dropping discovered ENR with unparseable address`, { err });
       }
     });
 

package/src/client/factory.ts

@@ -7,7 +7,7 @@ import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
 import type { BlockHash, L2BlockSource } from '@aztec/stdlib/block';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { BlockMinFeesProvider } from '@aztec/stdlib/gas';
+import { type BlockMinFeesProvider, getNetworkTxGasLimits } from '@aztec/stdlib/gas';
 import type { AztecNode, ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -75,7 +75,10 @@ export async function createP2PClient(
   }
 
   const bindings = logger.getBindings();
-  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, bindings));
+  // Schema version 4: L2 tips store resolves checkpoint tips from per-tip ids in l2_tip_checkpoints; the
+  // block->checkpoint mapping and checkpoint maps were dropped. Bumped to wipe stores whose tips predate
+  // per-tip ids, which would otherwise make getL2Tips throw on every read.
+  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 4, config, bindings));
   const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, bindings);
   const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, bindings);
   const attestationStore = await createStore(P2P_ATTESTATION_STORE_NAME, 2, config, bindings);
@@ -108,14 +111,14 @@ export async function createP2PClient(
           const { ts: nextSlotTimestamp } = epochCache.getEpochAndSlotInNextL1Slot();
           const l1Constants = await archiver.getL1Constants();
           const gasFees = await blockMinFeesProvider.getCurrentMinFees();
+          const networkTxGasLimits = getNetworkTxGasLimits(config, l1Constants);
           return createTxValidatorForTransactionsEnteringPendingTxPool(
             worldStateSynchronizer,
             nextSlotTimestamp,
             BlockNumber(currentBlockNumber + 1),
             {
-              rollupManaLimit: l1Constants.rollupManaLimit,
-              maxBlockL2Gas: config.validateMaxL2BlockGas,
-              maxBlockDAGas: config.validateMaxDABlockGas,
+              maxTxL2Gas: networkTxGasLimits.l2Gas,
+              maxTxDAGas: networkTxGasLimits.daGas,
             },
             gasFees,
           );
@@ -129,6 +132,7 @@ export async function createP2PClient(
         minTxPoolAgeMs: config.minTxPoolAgeMs,
         dropTransactionsProbability: config.dropTransactionsProbability,
         priceBumpPercentage: config.priceBumpPercentage,
+        keepFinalizedTxsForSlots: config.keepFinalizedTxsForSlots,
       },
       dateProvider,
     );

package/src/client/interface.ts

@@ -13,6 +13,7 @@ import type { ReqRespSubProtocol, ReqRespSubProtocolHandler } from '../services/
 import type {
   DuplicateAttestationInfo,
   DuplicateProposalInfo,
+  OversizedProposalInfo,
   P2PBlockReceivedCallback,
   P2PCheckpointAttestationCallback,
   P2PCheckpointReceivedCallback,
@@ -97,6 +98,14 @@ export type P2P = P2PClient & {
    */
   registerDuplicateProposalCallback(callback: (info: DuplicateProposalInfo) => void): void;
 
+  /**
+   * Registers a callback invoked when an oversized block proposal (index at or beyond the consensus
+   * per-checkpoint block limit) is stored and re-broadcast as slashing evidence.
+   *
+   * @param callback - Function called with info about the oversized proposal
+   */
+  registerOversizedProposalCallback(callback: (info: OversizedProposalInfo) => void): void;
+
   /**
    * Registers a callback invoked when a duplicate attestation is detected (equivocation).
    * A validator signing attestations for different proposals at the same slot.
@@ -124,16 +133,18 @@ export type P2P = P2PClient & {
   /**
    * Returns a transaction in the transaction pool by its hash.
    * @param txHash  - Hash of tx to return.
+   * @param opts - Set `includeProof: false` to skip loading the tx proof from the DB.
    * @returns A single tx or undefined.
    */
-  getTxByHashFromPool(txHash: TxHash): Promise<Tx | undefined>;
+  getTxByHashFromPool(txHash: TxHash, opts?: { includeProof?: boolean }): Promise<Tx | undefined>;
 
   /**
    * Returns transactions in the transaction pool by hash.
    * @param txHashes  - Hashes of txs to return.
+   * @param opts - Set `includeProof: false` to skip loading tx proofs from the DB.
    * @returns An array of txs or undefined.
    */
-  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  getTxsByHashFromPool(txHashes: TxHash[], opts?: { includeProof?: boolean }): Promise<(Tx | undefined)[]>;
 
   /**
    * Checks if transactions exist in the pool
@@ -156,15 +167,27 @@ export type P2P = P2PClient & {
    */
   getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
 
-  /** Returns an iterator over pending txs on the mempool. */
-  iteratePendingTxs(): AsyncIterableIterator<Tx>;
+  /**
+   * Returns an iterator over pending txs on the mempool.
+   * Set `includeProof: false` to skip loading tx proofs from the DB.
+   */
+  iteratePendingTxs(opts?: { includeProof?: boolean }): AsyncIterableIterator<Tx>;
 
-  /** Returns an iterator over pending txs that have been in the pool long enough to be eligible for block building. */
-  iterateEligiblePendingTxs(): AsyncIterableIterator<Tx>;
+  /**
+   * Returns an iterator over pending txs that have been in the pool long enough to be eligible for block building.
+   * Set `includeProof: false` to skip loading tx proofs from the DB.
+   */
+  iterateEligiblePendingTxs(opts?: { includeProof?: boolean }): AsyncIterableIterator<Tx>;
 
   /** Returns the number of pending txs in the mempool. */
   getPendingTxCount(): Promise<number>;
 
+  /**
+   * Returns whether at least `minCount` pending txs have been in the pool long enough to be eligible for block
+   * building. Early-exits once the threshold is met instead of counting every eligible tx.
+   */
+  hasEligiblePendingTxs(minCount: number): Promise<boolean>;
+
   /**
    * Protects existing transactions by hash for a given slot.
    * Returns hashes of transactions that weren't found in the pool.

package/src/client/p2p_client.ts

@@ -6,7 +6,6 @@ import {
   SlotNumber,
 } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/promise';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
@@ -15,17 +14,17 @@ import {
   type BlockHash,
   type CheckpointId,
   type EthAddress,
+  EventDrivenL2BlockStream,
   type L2Block,
   type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
-  type L2Tips,
   type L2TipsStore,
+  type LocalL2Tips,
 } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
-import { type PeerInfo, tryStop } from '@aztec/stdlib/interfaces/server';
+import { type GetTxByHashOptions, type PeerInfo, tryStop } from '@aztec/stdlib/interfaces/server';
 import { type BlockProposal, CheckpointAttestation, type CheckpointProposal, type TopicType } from '@aztec/stdlib/p2p';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { Attributes, type TelemetryClient, WithTracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
@@ -43,6 +42,7 @@ import { ReqRespSubProtocol, type ReqRespSubProtocolHandler } from '../services/
 import type {
   DuplicateAttestationInfo,
   DuplicateProposalInfo,
+  OversizedProposalInfo,
   P2PBlockReceivedCallback,
   P2PCheckpointReceivedCallback,
   P2PService,
@@ -74,7 +74,7 @@ export class P2PClient extends WithTracer implements P2P {
 
   private config: P2PConfig;
 
-  private blockStream: L2BlockStream | undefined;
+  private blockStream: EventDrivenL2BlockStream | undefined;
 
   private txProvider: TxProvider;
 
@@ -83,9 +83,6 @@ export class P2PClient extends WithTracer implements P2P {
   /** Tracks the last slot for which we called prepareForSlot */
   private lastSlotProcessed: SlotNumber = SlotNumber.ZERO;
 
-  /** Polls for slot changes and calls prepareForSlot on the tx pool */
-  private slotMonitor: RunningPromise | undefined;
-
   constructor(
     private store: AztecAsyncKVStore,
     private l2BlockSource: L2BlockSource & ContractDataSource,
@@ -152,7 +149,7 @@ export class P2PClient extends WithTracer implements P2P {
     this.p2pService.updateConfig(config);
   }
 
-  public getL2Tips(): Promise<L2Tips> {
+  public getL2Tips(): Promise<LocalL2Tips> {
     return this.l2Tips.getL2Tips();
   }
 
@@ -178,10 +175,12 @@ export class P2PClient extends WithTracer implements P2P {
         break;
       case 'chain-pruned':
         this.txCollection.stopCollectingForBlocksAfter(event.block.number);
-        await this.handlePruneL2Blocks(event.block, event.checkpoint);
+        await this.handlePruneL2Blocks(event.block, event.checkpointed.checkpoint);
         break;
       case 'chain-checkpointed':
         break;
+      case 'chain-proposed':
+        break;
       default: {
         const _: never = event;
         break;
@@ -268,14 +267,6 @@ export class P2PClient extends WithTracer implements P2P {
     this.blockStream.start();
     this.txFileStore?.start();
 
-    // Start slot monitor to call prepareForSlot when the slot changes
-    this.slotMonitor = new RunningPromise(
-      () => this.maybeCallPrepareForSlot(),
-      this.log,
-      this.config.slotCheckIntervalMS,
-    );
-    this.slotMonitor.start();
-
     return this.syncPromise;
   }
 
@@ -286,7 +277,7 @@ export class P2PClient extends WithTracer implements P2P {
   private initBlockStream(startingBlock?: BlockNumber) {
     if (!this.blockStream) {
       const { blockRequestBatchSize: batchSize, blockCheckIntervalMS: pollIntervalMS } = this.config;
-      this.blockStream = new L2BlockStream(
+      this.blockStream = new EventDrivenL2BlockStream(
         this.l2BlockSource,
         this,
         this,
@@ -302,8 +293,6 @@ export class P2PClient extends WithTracer implements P2P {
    */
   public async stop() {
     this.log.debug('Stopping p2p client...');
-    await this.slotMonitor?.stop();
-    this.log.debug('Stopped slot monitor');
     await tryStop(this.txCollection);
     this.log.debug('Stopped tx collection service');
     await this.txFileStore?.stop();
@@ -406,6 +395,10 @@ export class P2PClient extends WithTracer implements P2P {
     return this.attestationPool.hasBlockProposalsForSlot(slot);
   }
 
+  public hasCheckpointProposalForSlot(slot: SlotNumber): Promise<boolean> {
+    return this.attestationPool.hasCheckpointProposalForSlot(slot);
+  }
+
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
   // ^ This pattern is not my favorite (md)
   public registerBlockProposalHandler(handler: P2PBlockReceivedCallback): void {
@@ -424,6 +417,10 @@ export class P2PClient extends WithTracer implements P2P {
     this.p2pService.registerDuplicateProposalCallback(callback);
   }
 
+  public registerOversizedProposalCallback(callback: (info: OversizedProposalInfo) => void): void {
+    this.p2pService.registerOversizedProposalCallback(callback);
+  }
+
   public registerDuplicateAttestationCallback(callback: (info: DuplicateAttestationInfo) => void): void {
     this.p2pService.registerDuplicateAttestationCallback(callback);
   }
@@ -432,7 +429,7 @@ export class P2PClient extends WithTracer implements P2P {
     this.p2pService.registerCheckpointAttestationCallback(callback);
   }
 
-  public async getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]> {
+  public async getPendingTxs(limit?: number, after?: TxHash, options?: GetTxByHashOptions): Promise<Tx[]> {
     if (limit !== undefined && limit <= 0) {
       throw new TypeError('limit must be greater than 0');
     }
@@ -451,7 +448,9 @@ export class P2PClient extends WithTracer implements P2P {
     const endIndex = limit !== undefined ? startIndex + limit : undefined;
     txHashes = txHashes.slice(startIndex, endIndex);
 
-    const maybeTxs = await Promise.all(txHashes.map(txHash => this.txPool.getTxByHash(txHash)));
+    // This is a public-facing API (exposed via both the node and the p2p RPC), so proofs are opt-in.
+    const includeProof = !!options?.includeProof;
+    const maybeTxs = await Promise.all(txHashes.map(txHash => this.txPool.getTxByHash(txHash, { includeProof })));
     return maybeTxs.filter((tx): tx is Tx => !!tx);
   }
 
@@ -459,18 +458,22 @@ export class P2PClient extends WithTracer implements P2P {
     return this.txPool.getPendingTxCount();
   }
 
-  public async *iteratePendingTxs(): AsyncIterableIterator<Tx> {
+  public hasEligiblePendingTxs(minCount: number): Promise<boolean> {
+    return this.txPool.hasEligiblePendingTxs(minCount);
+  }
+
+  public async *iteratePendingTxs(opts?: { includeProof?: boolean }): AsyncIterableIterator<Tx> {
     for (const txHash of await this.txPool.getPendingTxHashes()) {
-      const tx = await this.txPool.getTxByHash(txHash);
+      const tx = await this.txPool.getTxByHash(txHash, opts);
       if (tx) {
         yield tx;
       }
     }
   }
 
-  public async *iterateEligiblePendingTxs(): AsyncIterableIterator<Tx> {
+  public async *iterateEligiblePendingTxs(opts?: { includeProof?: boolean }): AsyncIterableIterator<Tx> {
     for (const txHash of await this.txPool.getEligiblePendingTxHashes()) {
-      const tx = await this.txPool.getTxByHash(txHash);
+      const tx = await this.txPool.getTxByHash(txHash, opts);
       if (tx) {
         yield tx;
       }
@@ -480,19 +483,21 @@ export class P2PClient extends WithTracer implements P2P {
   /**
    * Returns a transaction in the transaction pool by its hash.
    * @param txHash - Hash of the transaction to look for in the pool.
+   * @param opts - Set `includeProof: false` to skip loading the tx proof from the DB.
    * @returns A single tx or undefined.
    */
-  getTxByHashFromPool(txHash: TxHash): Promise<Tx | undefined> {
-    return this.txPool.getTxByHash(txHash);
+  getTxByHashFromPool(txHash: TxHash, opts?: { includeProof?: boolean }): Promise<Tx | undefined> {
+    return this.txPool.getTxByHash(txHash, opts);
   }
 
   /**
    * Returns transactions in the transaction pool by hash.
    * @param txHashes - Hashes of the transactions to look for.
+   * @param opts - Set `includeProof: false` to skip loading tx proofs from the DB.
    * @returns The txs found, in the same order as the requested hashes. If a tx is not found, it will be undefined.
    */
-  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return this.txPool.getTxsByHash(txHashes);
+  getTxsByHashFromPool(txHashes: TxHash[], opts?: { includeProof?: boolean }): Promise<(Tx | undefined)[]> {
+    return this.txPool.getTxsByHash(txHashes, opts);
   }
 
   hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]> {
@@ -634,11 +639,16 @@ export class P2PClient extends WithTracer implements P2P {
       return;
     }
 
+    const lastBlock = blocks.at(-1)!;
+    const lastSlot = lastBlock.header.getSlot();
+
+    // Mark txs mined before releasing protections: a block landing at this slot supersedes any
+    // protection for txs it includes, so mined-marking must run first to keep just-landed txs from
+    // being unprotected into pending where they could be evicted before they are recorded as mined.
     await this.handleMinedBlocks(blocks);
-    await this.maybeCallPrepareForSlot();
+    await this.maybeCallPrepareForSlot(lastSlot);
     await this.collectingMissingTxs(blocks);
-    const lastBlock = blocks.at(-1)!;
-    await this.synchedLatestSlot.set(BigInt(lastBlock.header.getSlot()));
+    await this.synchedLatestSlot.set(BigInt(lastSlot));
   }
 
   /** Request txs for unproven blocks so the prover node can prove. */
@@ -733,20 +743,8 @@ export class P2PClient extends WithTracer implements P2P {
     return isEpochPrune;
   }
 
-  /** Checks if the slot has changed and calls prepareForSlot if so. */
-  private async maybeCallPrepareForSlot(): Promise<void> {
-    // If we have a proposed checkpoint available, we want to prepare the target slot - otherwise we prepare the current slot
-    const l2Tips = await this.l2Tips.getL2Tips();
-    const hasProposedCheckpoint = l2Tips.proposedCheckpoint.checkpoint.number > l2Tips.checkpointed.checkpoint.number;
-
-    let slot;
-    if (hasProposedCheckpoint) {
-      const { targetSlot } = this.epochCache.getTargetAndNextSlot();
-      slot = targetSlot;
-    } else {
-      const { currentSlot } = this.epochCache.getCurrentAndNextSlot();
-      slot = currentSlot;
-    }
+  /** Calls prepareForSlot for the given slot if it advances past the last slot we prepared for. */
+  private async maybeCallPrepareForSlot(slot: SlotNumber): Promise<void> {
     if (slot <= this.lastSlotProcessed) {
       return;
     }

package/src/config.ts

@@ -3,6 +3,7 @@ import {
   SecretValue,
   bigintConfigHelper,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -42,34 +43,26 @@ export interface P2PConfig
     TxFileStoreConfig,
     Pick<
       SequencerConfig,
-      | 'blockDurationMs'
       | 'expectedBlockProposalsPerSlot'
-      | 'l1PublishingTime'
       | 'maxTxsPerBlock'
-      | 'attestationPropagationTime'
+      | 'checkpointProposalSyncGraceSeconds'
       | 'maxBlocksPerCheckpoint'
-    > {
+    >,
+    // `blockDurationMs` is optional on the loose `SequencerConfig` but is always populated for p2p via
+    // the shared `numberConfigHelper(3000)` mapping, so it is required here.
+    Required<Pick<SequencerConfig, 'blockDurationMs'>> {
   /** Maximum transactions per block for validation. Overrides maxTxsPerBlock for gossip validation when set. */
   validateMaxTxsPerBlock?: number;
 
   /** Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set. */
   validateMaxTxsPerCheckpoint?: number;
 
-  /** Maximum L2 gas per block for validation. When set, txs exceeding this limit are rejected. */
-  validateMaxL2BlockGas?: number;
-
-  /** Maximum DA gas per block for validation. When set, txs exceeding this limit are rejected. */
-  validateMaxDABlockGas?: number;
-
   /** A flag dictating whether the P2P subsystem should be enabled. */
   p2pEnabled: boolean;
 
   /** The frequency in which to check for new L2 blocks. */
   blockCheckIntervalMS: number;
 
-  /** The frequency in which to check for new L2 slots. */
-  slotCheckIntervalMS: number;
-
   /** The number of blocks to fetch in a single batch. */
   blockRequestBatchSize: number;
 
@@ -150,6 +143,13 @@ export interface P2PConfig
   /** How long to keep message IDs in the seen cache (ms). */
   gossipsubSeenTTL: number;
 
+  /**
+   * Maximum clock-disparity tolerance (ms) applied to proposal/attestation gossip receive windows. Both
+   * ends of each acceptance window are widened by this much so peers are not penalized for messages valid
+   * when sent but arriving slightly early or late due to clock skew (Ethereum's MAXIMUM_GOSSIP_CLOCK_DISPARITY).
+   */
+  maxGossipClockDisparityMs: number;
+
   /** The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it. */
   doubleSpendSeverePeerPenaltyWindow: number;
 
@@ -165,6 +165,9 @@ export interface P2PConfig
   /** The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors. */
   peerPenaltyValues: number[];
 
+  /** How long (in seconds) a peer is banned for once its score drops below the ban threshold. */
+  peerBanDurationSeconds: number;
+
   /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
   archivedTxLimit: number;
 
@@ -241,6 +244,12 @@ export interface P2PConfig
   /** Minimum percentage fee increase required to replace an existing tx via RPC (0 = no bump). */
   priceBumpPercentage: bigint;
 
+  /**
+   * Number of slots behind the finalized tip to keep finalized txs for before deleting them. 0 deletes
+   * at the finalized tip (default).
+   */
+  keepFinalizedTxsForSlots: number;
+
   /** Drop incoming block and checkpoint proposals at the libp2p dispatch layer (for testing only) */
   skipIncomingProposals?: boolean;
 
@@ -278,16 +287,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set.',
     ...optionalNumberConfigHelper(),
   },
-  validateMaxL2BlockGas: {
-    env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
-    description: 'Maximum L2 gas per block for validation. When set, txs exceeding this limit are rejected.',
-    ...optionalNumberConfigHelper(),
-  },
-  validateMaxDABlockGas: {
-    env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
-    description: 'Maximum DA gas per block for validation. When set, txs exceeding this limit are rejected.',
-    ...optionalNumberConfigHelper(),
-  },
   p2pEnabled: {
     env: 'P2P_ENABLED',
     description: 'A flag dictating whether the P2P subsystem should be enabled.',
@@ -303,11 +302,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The frequency in which to check for new L2 blocks.',
     ...numberConfigHelper(100),
   },
-  slotCheckIntervalMS: {
-    env: 'P2P_SLOT_CHECK_INTERVAL_MS',
-    description: 'The frequency in which to check for new L2 slots.',
-    ...numberConfigHelper(1000),
-  },
   debugDisableColocationPenalty: {
     env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
     description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
@@ -439,20 +433,26 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'How long to keep message IDs in the seen cache.',
     ...numberConfigHelper(20 * 60 * 1000),
   },
+  maxGossipClockDisparityMs: {
+    env: 'P2P_MAX_GOSSIP_CLOCK_DISPARITY_MS',
+    description:
+      'Maximum clock-disparity tolerance (ms) applied to both ends of proposal/attestation gossip receive windows.',
+    ...numberConfigHelper(500),
+  },
   gossipsubTxTopicWeight: {
     env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
     description: 'The weight of the tx topic for the gossipsub protocol.',
-    ...numberConfigHelper(1),
+    ...floatConfigHelper(1),
   },
   gossipsubTxInvalidMessageDeliveriesWeight: {
     env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_WEIGHT',
     description: 'The weight of the tx invalid message deliveries for the gossipsub protocol.',
-    ...numberConfigHelper(-20),
+    ...floatConfigHelper(-20),
   },
   gossipsubTxInvalidMessageDeliveriesDecay: {
     env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_DECAY',
     description: 'Determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.',
-    ...numberConfigHelper(0.5),
+    ...floatConfigHelper(0.5),
   },
   peerPenaltyValues: {
     env: 'P2P_PEER_PENALTY_VALUES',
@@ -461,6 +461,11 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.',
     defaultValue: [2, 10, 50],
   },
+  peerBanDurationSeconds: {
+    env: 'P2P_PEER_BAN_DURATION_SECONDS',
+    description: 'How long (in seconds) a peer is banned for once its score drops below the ban threshold.',
+    ...numberConfigHelper(24 * 60 * 60),
+  },
   doubleSpendSeverePeerPenaltyWindow: {
     env: 'P2P_DOUBLE_SPEND_SEVERE_PEER_PENALTY_WINDOW',
     description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
@@ -563,11 +568,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'Alters the format of p2p messages to include things like broadcast timestamp FOR TESTING ONLY',
     ...booleanConfigHelper(false),
   },
-  l1PublishingTime: {
-    env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
-    description: 'How much time (in seconds) we allow in the slot for publishing the L1 tx (defaults to 1 L1 slot).',
-    ...optionalNumberConfigHelper(),
-  },
   fishermanMode: {
     env: 'FISHERMAN_MODE',
     description:
@@ -615,7 +615,19 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'Minimum percentage fee increase required to replace an existing tx via RPC. Even at 0%, replacement still requires paying at least 1 unit more.',
     ...bigintConfigHelper(10n),
   },
-  ...sharedSequencerConfigMappings,
+  keepFinalizedTxsForSlots: {
+    env: 'P2P_KEEP_FINALIZED_TXS_FOR_SLOTS',
+    description:
+      'Number of slots behind the finalized tip to keep finalized txs for before deleting them. 0 deletes at the finalized tip.',
+    ...numberConfigHelper(0),
+  },
+  ...pickConfigMappings(sharedSequencerConfigMappings, [
+    'expectedBlockProposalsPerSlot',
+    'maxTxsPerBlock',
+    'checkpointProposalSyncGraceSeconds',
+    'maxBlocksPerCheckpoint',
+    'blockDurationMs',
+  ]),
   ...p2pReqRespConfigMappings,
   ...batchTxRequesterConfigMappings,
   ...chainConfigMappings,
@@ -741,7 +753,7 @@ export function parseAllowList(value: string): AllowedElement[] {
 
     if (typeString === 'I') {
       entries.push({
-        address: AztecAddress.fromString(identifierString),
+        address: AztecAddress.fromStringUnsafe(identifierString),
         selector,
         ...flags,
       });