@aztec/p2p 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/src/client/test/{tx_proposal_collector/README.md → p2p_client.batch_tx_requester.bench.README.md}

@@ -1,6 +1,6 @@
-# ProposalTxCollector Benchmarks
+# BatchTxRequester Benchmarks
 
-This benchmark suite measures **how quickly a proposer node can fetch missing transactions from P2P peers** when building a block proposal. It compares two alternative transaction-collection implementations under several controlled "who-has-which-txs" distributions.
+This benchmark suite measures **how quickly a proposer node can fetch missing transactions from P2P peers** when building a block proposal under several controlled "who-has-which-txs" distributions.
 
 ## Purpose
 
@@ -10,12 +10,6 @@ This benchmark answers:
 
 - How long does it take to fetch **N missing txs** (N ∈ **{10, 50, 100, 500}**)?
 - How do different **peer availability patterns** affect performance?
-- Which collector strategy performs better under each pattern?
-
-The suite compares two collectors:
-
-- **`BatchTxRequesterCollector`** (collector type: `batch-requester`)
-- **`SendBatchRequestCollector`** (collector type: `send-batch-request`)
 
 ## Architecture
 
@@ -24,7 +18,7 @@ The benchmark runs a small simulated network on localhost:
 ```
 ┌─────────────────────────────────────────────────────────────────────┐
 │                        Test Process (Driver)                        │
-│   p2p_client.proposal_tx_collector.bench.test.ts                    │
+│   p2p_client.batch_tx_requester.bench.test.ts                       │
 │   ┌─────────────────────────────────────────────────────────────┐   │
 │   │            WorkerClientManager                              │   │
 │   │         (src/testbench/worker_client_manager.ts)            │   │
@@ -34,7 +28,7 @@ The benchmark runs a small simulated network on localhost:
 │         ▼                    ▼                    ▼                 │
 │   ┌───────────┐        ┌───────────┐        ┌───────────┐           │
 │   │ Worker 0  │◄──────►│ Worker 1  │◄──────►│ Worker N-1│           │
-│   │ (Collector│  P2P   │(Responder)│  P2P   │(Responder)│           │
+│   │(Aggregator│  P2P   │(Responder)│  P2P   │(Responder)│           │
 │   │  Node)    │        │           │        │           │           │
 │   │ TxPool:[] │        │ TxPool:   │        │ TxPool:   │           │
 │   │           │        │ [txs...]  │        │ [txs...]  │           │
@@ -54,12 +48,12 @@ Using separate OS processes makes the setup closer to real networking behavior (
 
 The network is intentionally asymmetric:
 
-- **Worker 0 is the collector/proposer node**
+- **Worker 0 is the aggregator/proposer node**
   - Starts with an **empty tx pool** (`[]`)
-  - Is the only worker instructed to run the collector for each `BENCH_REQRESP` command
+  - Is the only worker instructed to run `BatchTxRequester` for each `BENCH_REQRESP` command
 - **Workers 1..N-1 are responder peers**
   - Locally generate and filter txs according to the distribution pattern
-  - Respond to req/resp queries made by Worker 0's collector
+  - Respond to req/resp queries made by Worker 0's `BatchTxRequester`
 
 This models a proposer that has only `txHashes` in a proposal and must fetch the full tx bodies from the network.
 
@@ -72,7 +66,7 @@ Each benchmark case generates `missingTxCount` mock txs and assigns them to peer
 **Every responder peer has every transaction.**
 
 - Simulates the best-case: high replication / high gossip success
-- Expectation: collector should quickly succeed; differences mostly reflect collector overhead and batching strategy
+- Expectation: the requester should quickly succeed; differences mostly reflect requester overhead and batching strategy
 
 ### `sparse`
 
@@ -81,7 +75,7 @@ Each benchmark case generates `missingTxCount` mock txs and assigns them to peer
 Each responder is bucketed and holds txs whose index falls into its bucket or the "next" bucket (striped by tx index).
 
 - Simulates partial propagation, churn, or uneven mempool convergence
-- Expectation: collector must query multiple peers and cope with "misses"
+- Expectation: the requester must query multiple peers and cope with "misses"
 
 ### `pinned-only`
 
@@ -92,33 +86,13 @@ Each responder is bucketed and holds txs whose index falls into its bucket or th
 
 > **Guardrail:** the pinned peer index must be within `(0, numberOfPeers)` (Worker 0 cannot be pinned).
 
-## Collectors Under Test
-
-### `BatchTxRequesterCollector` (`batch-requester`)
-
-```typescript
-new BatchTxRequesterCollector(p2pService, logger, new DateProvider())
-```
-
-Uses the P2P service plus internal logic to fetch missing txs, coordinating requests in a batched or staged way.
-
-### `SendBatchRequestCollector` (`send-batch-request`)
-
-```typescript
-const maxPeers = 10;
-const maxRetryAttempts = Math.max(peerIds.length, 3);
-new SendBatchRequestCollector(p2pService, maxPeers, maxRetryAttempts)
-```
-
-Explicitly caps the number of peers it will involve (`maxPeers`) and uses a retry budget derived from peer count.
-
 ## Test Parameters
 
 | Parameter | Value | Description |
 |-----------|-------|-------------|
 | `PEERS_PER_RUN` | 30 | Number of worker processes spawned |
 | `MISSING_TX_COUNTS` | 10, 50, 100, 500 | Number of missing transactions to fetch |
-| `TIMEOUT_MS` | 30,000 ms | Collector timeout per case |
+| `TIMEOUT_MS` | 30,000 ms | Per-case timeout for the requester |
 | `TEST_TIMEOUT_MS` | 600,000 ms | Overall Jest timeout (10 minutes) |
 
 ## Running
@@ -127,13 +101,13 @@ From the p2p package:
 
 ```bash
 cd yarn-project/p2p
-yarn test src/client/test/tx_proposal_collector/p2p_client.proposal_tx_collector.bench.test.ts
+yarn test src/client/test/p2p_client.batch_tx_requester.bench.test.ts
 ```
 
 Or from repo root:
 
 ```bash
-yarn test p2p_client.proposal_tx_collector.bench.test.ts
+yarn test p2p_client.batch_tx_requester.bench.test.ts
 ```
 
 The benchmark is intentionally long due to spawning many processes and running multiple cases.
@@ -145,14 +119,12 @@ The benchmark is intentionally long due to spawning many processes and running m
 If no env vars are set, the suite prints a table:
 
 ```
-| Collector           | Distribution | Missing | Duration (ms) | Fetched | Success |
-|---------------------|--------------|---------|---------------|---------|---------|
-| batch-requester     | pinned-only  |      10 |           123 |      10 |   Yes   |
-| send-batch-request  | pinned-only  |      10 |           145 |      10 |   Yes   |
+| Distribution | Missing | Duration (ms) | Fetched | Success |
+|--------------|---------|---------------|---------|---------|
+| pinned-only  |      10 |           123 |      10 |   Yes   |
+| pinned-only  |      50 |           145 |      50 |   Yes   |
 ```
 
-Plus a comparison summary stating which collector was faster per `(distribution, missing)` pair.
-
 ### JSON metrics (for CI/dashboards)
 
 ```bash
@@ -160,8 +132,8 @@ BENCH_OUTPUT=/path/results.json yarn test ...
 ```
 
 Writes JSON metrics like:
-- `ProposalTxCollector/<collector>/<distribution>/missing_<N>/duration` (ms)
-- `ProposalTxCollector/<collector>/<distribution>/missing_<N>/fetched` (txs)
+- `BatchTxRequester/<distribution>/missing_<N>/duration` (ms)
+- `BatchTxRequester/<distribution>/missing_<N>/fetched` (txs)
 
 ### Markdown file output
 
@@ -175,14 +147,14 @@ Writes the pretty table + summary to disk.
 
 For each case the benchmark records:
 
-- `durationMs`: wall-clock time spent inside the collector call
-- `fetchedCount`: how many txs were returned by the collector
+- `durationMs`: wall-clock time spent inside the requester call
+- `fetchedCount`: how many txs were returned by the requester
 - `success`: `fetchedCount === missingTxCount`
 
 **Guidelines:**
 
 - **Always check `Success` first.** A faster run that fetched fewer txs is not a win.
-- Compare collectors **within the same distribution + missing count** only.
+- Compare runs **within the same distribution + missing count** only.
 - Expect `pinned-only` to highlight pinned-peer behavior (fast if pinned peer is used effectively; slow if the algorithm wastes time sampling other peers).
 - Expect `sparse` to be the most "network-like" stress case, since many peers won't have each requested tx.
 
@@ -193,7 +165,7 @@ Inside each worker, the benchmark intentionally reduces variability:
 - **Unlimited rate limits** are installed so the req/resp rate limiter doesn't dominate results
 - **Deterministic tx generation** ensures all workers see the same tx set without large IPC payloads
 
-This makes the benchmark better for *comparing collectors* (A vs B), but it is **not** a perfect model of production networking conditions.
+This makes the benchmark better for tracking regressions, but it is **not** a perfect model of production networking conditions.
 
 ## Limitations
 
@@ -207,9 +179,7 @@ This benchmark does **not** measure:
 
 | File | Purpose |
 |------|---------|
-| `p2p_client.proposal_tx_collector.bench.test.ts` | Test suite (cases, distributions, output formatting) |
-| `proposal_tx_collector_worker.ts` | Collector-specific worker implementation |
-| `proposal_tx_collector_worker_protocol.ts` | IPC message types and serialization |
+| `p2p_client.batch_tx_requester.bench.test.ts` | Test suite (cases, distributions, output formatting) |
 | `src/testbench/worker_client_manager.ts` | Worker process manager (forking, IPC, orchestration) |
 | `src/testbench/p2p_client_testbench_worker.ts` | General testbench worker implementation |
 | `src/test-helpers/testbench-utils.ts` | Shared mocks and utilities (InMemoryTxPool, InMemoryAttestationPool, etc.) |

package/src/config.ts

@@ -3,9 +3,11 @@ import {
   SecretValue,
   bigintConfigHelper,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
+  optionalNumberConfigHelper,
   percentageConfigHelper,
   pickConfigMappings,
   secretStringConfigHelper,
@@ -39,28 +41,28 @@ export interface P2PConfig
     ChainConfig,
     TxCollectionConfig,
     TxFileStoreConfig,
-    Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot' | 'maxTxsPerBlock'> {
+    Pick<
+      SequencerConfig,
+      | 'expectedBlockProposalsPerSlot'
+      | 'maxTxsPerBlock'
+      | '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;
 
@@ -106,9 +108,21 @@ export interface P2PConfig
   /** The maximum number of peers (a peer count above this will cause the node to refuse connection attempts) */
   maxPeerCount: number;
 
+  /**
+   * Minimum number of connected peers for the p2p component to report itself as healthy on the node status endpoint.
+   * Defaults to zero, so p2p health is reported but never fails the check: the first node of a fresh network
+   * legitimately runs with no peers, and failing readiness by default would prevent bootstrapping the network.
+   */
+  p2pHealthMinPeers: number;
+
   /** If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false. */
   queryForIp: boolean;
 
+  /**
+   * HTTPS URLs that return plain-text public IPv4, tried in order when resolving the announce IP (e.g. when `queryForIp` is true and `p2pIp` is unset).
+   */
+  publicIpServices: string[];
+
   /** The interval of the gossipsub heartbeat to perform maintenance tasks. */
   gossipsubInterval: number;
 
@@ -136,6 +150,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;
 
@@ -151,6 +172,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;
 
@@ -175,6 +199,9 @@ export interface P2PConfig
   /** The node's seen message ID cache size */
   seenMessageCacheSize: number;
 
+  /** Maximum number of (validator, tx) pairs to keep in the tx validation LRU cache. */
+  txValidationCacheSize: number;
+
   /** True to disable the status handshake on peer connected. */
   p2pDisableStatusHandshake?: boolean;
 
@@ -207,34 +234,65 @@ export interface P2PConfig
   /** Minimum age (ms) a transaction must have been in the pool before it's eligible for block building. */
   minTxPoolAgeMs: number;
 
+  /**
+   * Number of full L2 slots to wait after a checkpoint's slot before declaring its txs missing
+   * for data-withholding slashing.
+   */
+  slashDataWithholdingToleranceSlots: number;
+
+  /**
+   * Number of L2 slots after a mined block's slot to keep collecting its missing txs. Clamped
+   * up so that collection always runs at least until the data-withholding slash verdict is
+   * rendered (`block.slot + slashDataWithholdingToleranceSlots + 1`). Defaults to undefined,
+   * in which case the tolerance window is used directly.
+   */
+  p2pMissingTxCollectionDeadlineSlots?: number;
+
   /** 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;
+
+  /** Accept proposal gossip regardless of slot timing (for testing only). */
+  skipProposalSlotValidation?: boolean;
+
+  /**
+   * Whether this node skips checkpoint proposal validation and always attests. When set, the checkpoint
+   * attestation is created and broadcast before the embedded last block is processed, so it is not delayed
+   * past the slot's attestation window by that block's re-execution. Mirrors the validator config flag.
+   */
+  skipCheckpointProposalValidation?: boolean;
 }
 
 export const DEFAULT_P2P_PORT = 40400;
 
+/** Default endpoints used to discover this machine's public IPv4 when `queryForIp` is enabled. */
+export const DEFAULT_PUBLIC_IP_SERVICES: string[] = [
+  'https://api.ipify.org/',
+  'https://checkip.amazonaws.com/',
+  'https://ifconfig.me/ip',
+  'https://icanhazip.com/',
+];
+
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   validateMaxTxsPerBlock: {
     env: 'VALIDATOR_MAX_TX_PER_BLOCK',
     description:
       'Maximum transactions per block for validation. Overrides maxTxsPerBlock for gossip validation when set.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    ...optionalNumberConfigHelper(),
   },
   validateMaxTxsPerCheckpoint: {
     env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
     description:
       'Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
-  },
-  validateMaxL2BlockGas: {
-    env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
-    description: 'Maximum L2 gas per block for validation. When set, txs exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
-  },
-  validateMaxDABlockGas: {
-    env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
-    description: 'Maximum DA gas per block for validation. When set, txs exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    ...optionalNumberConfigHelper(),
   },
   p2pEnabled: {
     env: 'P2P_ENABLED',
@@ -251,11 +309,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',
@@ -325,12 +378,29 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The maximum number of peers to connect to.',
     ...numberConfigHelper(100),
   },
+  p2pHealthMinPeers: {
+    env: 'P2P_HEALTH_MIN_PEERS',
+    description:
+      'Minimum number of connected peers for p2p to be reported as healthy on the status endpoint. Zero never fails the check.',
+    ...numberConfigHelper(0),
+  },
   queryForIp: {
     env: 'P2P_QUERY_FOR_IP',
     description:
       'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
     ...booleanConfigHelper(),
   },
+  publicIpServices: {
+    env: 'P2P_PUBLIC_IP_SERVICES',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean),
+    description:
+      'Comma-separated HTTPS URLs that return plain-text public IPv4. Used when P2P_QUERY_FOR_IP is true and P2P_IP is unset. Tried in order until one succeeds.',
+    defaultValue: DEFAULT_PUBLIC_IP_SERVICES,
+  },
   gossipsubInterval: {
     env: 'P2P_GOSSIPSUB_INTERVAL_MS',
     description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
@@ -364,7 +434,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   gossipsubMcacheLength: {
     env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
     description: 'The number of gossipsub interval message cache windows to keep.',
-    ...numberConfigHelper(6),
+    ...numberConfigHelper(12),
   },
   gossipsubMcacheGossip: {
     env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
@@ -376,20 +446,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',
@@ -398,6 +474,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.',
@@ -436,7 +517,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   p2pStoreMapSizeKb: {
     env: 'P2P_STORE_MAP_SIZE_KB',
-    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
   txPublicSetupAllowListExtend: {
@@ -459,6 +540,11 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The number of messages to keep in the seen message cache',
     ...numberConfigHelper(100_000), // 100K
   },
+  txValidationCacheSize: {
+    env: 'P2P_TX_VALIDATION_CACHE_SIZE',
+    description: 'Maximum number of items to keep in the tx validation LRU cache.',
+    ...numberConfigHelper(5_000),
+  },
   p2pDisableStatusHandshake: {
     env: 'P2P_DISABLE_STATUS_HANDSHAKE',
     description: 'True to disable the status handshake on peer connected.',
@@ -506,18 +592,55 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'Broadcast block proposals even when a conflicting proposal for the same slot already exists in the pool (for testing purposes only).',
     ...booleanConfigHelper(false),
   },
+  skipIncomingProposals: {
+    description: 'Drop incoming block and checkpoint proposals at the libp2p dispatch layer (for testing only)',
+    ...booleanConfigHelper(false),
+  },
+  skipProposalSlotValidation: {
+    description: 'Accept proposal gossip regardless of slot timing (for testing only)',
+    ...booleanConfigHelper(false),
+  },
+  skipCheckpointProposalValidation: {
+    description:
+      'Skip checkpoint proposal validation and always attest, broadcasting the attestation before processing the embedded last block',
+    ...booleanConfigHelper(false),
+  },
   minTxPoolAgeMs: {
     env: 'P2P_MIN_TX_POOL_AGE_MS',
     description: 'Minimum age (ms) a transaction must have been in the pool before it is eligible for block building.',
     ...numberConfigHelper(2_000),
   },
+  slashDataWithholdingToleranceSlots: {
+    env: 'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+    description:
+      'L2 slots to wait after a checkpoint slot before declaring its txs missing. Drives both the data-withholding slasher check and the missing-tx collection deadline.',
+    ...numberConfigHelper(3),
+  },
+  p2pMissingTxCollectionDeadlineSlots: {
+    env: 'P2P_MISSING_TX_COLLECTION_DEADLINE_SLOTS',
+    description:
+      'Optional deadline (in L2 slots after the block slot) for collecting missing txs for unproven mined blocks. Clamped up to the data-withholding tolerance window so collection never gives up before the slash verdict.',
+    ...optionalNumberConfigHelper(),
+  },
   priceBumpPercentage: {
     env: 'P2P_RPC_PRICE_BUMP_PERCENTAGE',
     description:
       '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,
@@ -550,6 +673,7 @@ export type BootnodeConfig = Pick<
   | 'bootstrapNodes'
   | 'listenAddress'
   | 'queryForIp'
+  | 'publicIpServices'
 > &
   Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
   Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'> &
@@ -567,6 +691,7 @@ const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'bootstrapNodes',
   'l1ChainId',
   'queryForIp',
+  'publicIpServices',
 ];
 
 export const bootnodeConfigMappings = pickConfigMappings(
@@ -641,7 +766,7 @@ export function parseAllowList(value: string): AllowedElement[] {
 
     if (typeString === 'I') {
       entries.push({
-        address: AztecAddress.fromString(identifierString),
+        address: AztecAddress.fromStringUnsafe(identifierString),
         selector,
         ...flags,
       });

package/src/errors/p2p-service.error.ts

@@ -0,0 +1,11 @@
+/** Checkpoint Proposal Received Callback Not Registered Error
+ *
+ * Error triggered if the allNodesCheckpointReceivedCallback is not registered
+ * @category Errors
+ */
+export class CheckpointProposalReceivedCallbackNotRegisteredError extends Error {
+  constructor() {
+    super('FATAL (allNodesCheckpointReceivedCallback): All nodes should register a checkpoint proposal handler');
+    this.name = 'CheckpointProposalReceivedCallbackNotRegisteredError';
+  }
+}

package/src/errors/reqresp.error.ts

@@ -9,27 +9,21 @@ export class IndividualReqRespTimeoutError extends Error {
   }
 }
 
-/** Collective request timeout error
+/** Oversized reqresp request error
  *
- * This error will be thrown when a req resp request times out regardless of the peer.
+ * Thrown locally (before dialing) when a request payload does not fit in a single muxer frame. Such a request would
+ * reach the responder split across multiple chunks, which are never reassembled into one request.
  * @category Errors
  */
-export class CollectiveReqRespTimeoutError extends Error {
-  constructor() {
-    super(`Request to all peers timed out`);
-  }
-}
-
-/** Invalid response error
- *
- * This error will be thrown when a response is received that is not valid.
- *
- * This error does not need to be punished as message validators will handle punishing invalid
- * requests
- * @category Errors
- */
-export class InvalidResponseError extends Error {
-  constructor() {
-    super(`Invalid response received`);
+export class OversizedReqRespRequestError extends Error {
+  constructor(
+    public readonly subProtocol: string,
+    public readonly payloadSizeBytes: number,
+    public readonly maxSizeBytes: number,
+  ) {
+    super(
+      `Request payload of ${payloadSizeBytes} bytes for ${subProtocol} exceeds the ${maxSizeBytes} byte limit of a single muxer frame`,
+    );
+    this.name = 'OversizedReqRespRequestError';
   }
 }

package/src/index.ts

@@ -6,7 +6,6 @@ export * from './client/index.js';
 export * from './enr/index.js';
 export * from './config.js';
 export * from './mem_pools/attestation_pool/index.js';
-export * from './mem_pools/tx_pool/index.js';
 export * from './mem_pools/tx_pool_v2/index.js';
 export * from './msg_validators/index.js';
 export * from './services/index.js';