@aztec/p2p 0.0.1-commit.1a99e26c → 0.0.1-commit.1bb068fb5

package/dest/test-helpers/testbench-utils.js

@@ -5,6 +5,7 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
 /**
  * In-memory TxPool implementation for testing.
  * Provides basic tx storage without persistence.
+ * Implements TxPoolV2 interface with stub implementations for testing.
  */ export class InMemoryTxPool extends EventEmitter {
     txsByHash = new Map();
     logger = null;
@@ -33,14 +34,15 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
         this.txsByHash.clear();
         this.removeAllListeners();
     }
-    addTxs(txs, opts) {
+    // === Core Operations (TxPoolV2) ===
+    addPendingTxs(txs, opts) {
+        const accepted = [];
         const newTxs = [];
-        let added = 0;
         for (const tx of txs){
             const key = tx.getTxHash().toString();
             if (!this.txsByHash.has(key)) {
                 newTxs.push(tx);
-                added += 1;
+                accepted.push(tx.getTxHash());
             }
             this.txsByHash.set(key, tx);
         }
@@ -50,8 +52,68 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
                 source: opts?.source
             });
         }
-        return Promise.resolve(added);
+        return Promise.resolve({
+            accepted,
+            ignored: [],
+            rejected: []
+        });
+    }
+    canAddPendingTx(tx) {
+        const key = tx.getTxHash().toString();
+        if (this.txsByHash.has(key)) {
+            return Promise.resolve('ignored');
+        }
+        return Promise.resolve('accepted');
+    }
+    addProtectedTxs(txs, _block, opts) {
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            this.txsByHash.set(key, tx);
+        }
+        if (txs.length > 0) {
+            this.emit('txs-added', {
+                txs,
+                source: opts?.source
+            });
+        }
+        return Promise.resolve();
+    }
+    protectTxs(txHashes, _block) {
+        const notFound = [];
+        for (const txHash of txHashes){
+            if (!this.txsByHash.has(txHash.toString())) {
+                notFound.push(txHash);
+            }
+        }
+        return Promise.resolve(notFound);
+    }
+    addMinedTxs(txs, _block, _opts) {
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            this.txsByHash.set(key, tx);
+        }
+        return Promise.resolve();
+    }
+    // === State Transition Handlers (TxPoolV2) ===
+    handleMinedBlock(_block) {
+        return Promise.resolve();
+    }
+    prepareForSlot(_slotNumber) {
+        return Promise.resolve();
+    }
+    handlePrunedBlocks(_latestBlock) {
+        return Promise.resolve();
+    }
+    handleFailedExecution(txHashes) {
+        for (const txHash of txHashes){
+            this.txsByHash.delete(txHash.toString());
+        }
+        return Promise.resolve();
+    }
+    handleFinalizedBlock(_block) {
+        return Promise.resolve();
     }
+    // === Query Operations (TxPoolV2) ===
     getTxByHash(hash) {
         return Promise.resolve(this.txsByHash.get(hash.toString()));
     }
@@ -64,100 +126,98 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
     hasTxs(hashes) {
         return Promise.resolve(hashes.map((h)=>this.txsByHash.has(h.toString())));
     }
-    hasTx(hash) {
-        return Promise.resolve(this.txsByHash.has(hash.toString()));
-    }
     getArchivedTxByHash(_hash) {
         return Promise.resolve(undefined);
     }
-    async markAsMined(_txHashes, _blockHeader) {}
-    async markMinedAsPending(_txHashes, _latestBlock) {}
-    deleteTxs(txHashes, _opts) {
-        for (const txHash of txHashes){
-            this.txsByHash.delete(txHash.toString());
-        }
-        return Promise.resolve();
-    }
-    getAllTxs() {
-        return Promise.resolve([
-            ...this.txsByHash.values()
-        ]);
-    }
-    getAllTxHashes() {
-        return Promise.resolve([
-            ...this.txsByHash.keys()
-        ].map((key)=>TxHash.fromString(key)));
-    }
     getPendingTxHashes() {
         return Promise.resolve([
             ...this.txsByHash.keys()
         ].map((key)=>TxHash.fromString(key)));
     }
+    getEligiblePendingTxHashes() {
+        return this.getPendingTxHashes();
+    }
     getPendingTxCount() {
         return Promise.resolve(this.txsByHash.size);
     }
     getMinedTxHashes() {
         return Promise.resolve([]);
     }
+    getMinedTxCount() {
+        return Promise.resolve(0);
+    }
     getTxStatus(hash) {
         return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
     }
-    updateConfig(_config) {}
     isEmpty() {
         return Promise.resolve(this.txsByHash.size === 0);
     }
-    async markTxsAsNonEvictable(_txHashes) {}
-    async clearNonEvictableTxs() {}
-    cleanupDeletedMinedTxs(_blockNumber) {
-        return Promise.resolve(0);
+    getLowestPriorityPending(_limit) {
+        return Promise.resolve([]);
+    }
+    // === Configuration (TxPoolV2) ===
+    updateConfig(_config) {
+        return Promise.resolve();
+    }
+    // === Lifecycle (TxPoolV2) ===
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
     }
 }
 /**
- * In-memory AttestationPool implementation for testing.
+ * In-memory AttestationPool mock for testing/benchmarking.
+ * Provides minimal implementation without persistence.
  */ export class InMemoryAttestationPool {
     proposals = new Map();
-    addBlockProposal(blockProposal) {
-        this.proposals.set(blockProposal.archive.toString(), blockProposal);
-        return Promise.resolve();
+    tryAddBlockProposal(blockProposal) {
+        const id = blockProposal.archive.toString();
+        const alreadyExists = this.proposals.has(id);
+        if (alreadyExists) {
+            return Promise.resolve({
+                added: false,
+                alreadyExists: true,
+                count: 1
+            });
+        }
+        this.proposals.set(id, blockProposal);
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
     }
     getBlockProposal(id) {
         return Promise.resolve(this.proposals.get(id));
     }
-    hasBlockProposal(idOrProposal) {
-        const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
-        return Promise.resolve(this.proposals.has(id));
-    }
-    canAddProposal(_block) {
-        return Promise.resolve(true);
+    tryAddCheckpointProposal(_proposal) {
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
     }
-    async addCheckpointProposal(_proposal) {}
     getCheckpointProposal(_id) {
         return Promise.resolve(undefined);
     }
-    hasCheckpointProposal(_idOrProposal) {
-        return Promise.resolve(false);
-    }
-    async addCheckpointAttestations(_attestations) {}
-    async deleteCheckpointAttestationsOlderThan(_slot) {}
+    async addOwnCheckpointAttestations(_attestations) {}
+    async deleteOlderThan(_slot) {}
     getCheckpointAttestationsForSlot(_slot) {
         return Promise.resolve([]);
     }
     getCheckpointAttestationsForSlotAndProposal(_slot, _proposalId) {
         return Promise.resolve([]);
     }
-    hasCheckpointAttestation(_attestation) {
-        return Promise.resolve(false);
-    }
-    canAddCheckpointProposal(_proposal) {
-        return Promise.resolve(true);
+    tryAddCheckpointAttestation(_attestation) {
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
     }
-    canAddCheckpointAttestation(_attestation, _committeeSize) {
-        return Promise.resolve(true);
-    }
-    hasReachedCheckpointProposalCap(_slot) {
-        return Promise.resolve(false);
-    }
-    hasReachedCheckpointAttestationCap(_slot, _proposalId, _committeeSize) {
+    hasBlockProposalsForSlot(_slot) {
         return Promise.resolve(false);
     }
     isEmpty() {
@@ -198,7 +258,16 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
             }),
         isInCommittee: ()=>Promise.resolve(false),
         getRegisteredValidators: ()=>Promise.resolve([]),
-        filterInCommittee: ()=>Promise.resolve([])
+        filterInCommittee: ()=>Promise.resolve([]),
+        getL1Constants: ()=>({
+                l1StartBlock: 0n,
+                l1GenesisTime: 0n,
+                epochDuration: 1,
+                slotDuration: 1,
+                ethereumSlotDuration: 1,
+                proofSubmissionEpochs: 1,
+                targetCommitteeSize: 48
+            })
     };
 }
 /**
@@ -257,7 +326,8 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
     /** Buffer time for internal timeout to ensure we return before outer timeout */ TIMEOUT_BUFFER_MS: 5_000,
     /** Minimum internal timeout regardless of buffer */ MIN_INTERNAL_TIMEOUT_MS: 1_000,
     /** Fixed max peers for fair benchmarking */ FIXED_MAX_PEERS: 10,
-    /** Fixed max retry attempts for fair benchmarking */ FIXED_MAX_RETRY_ATTEMPTS: 3
+    /** Fixed max retry attempts for fair benchmarking */ FIXED_MAX_RETRY_ATTEMPTS: 3,
+    /** LMDB map size for temp stores used in benchmarks (in KB). */ KV_STORE_MAP_SIZE_KB: 256 * 1024
 };
 /**
  * Filters transactions based on distribution pattern for benchmark responders.

package/dest/testbench/p2p_client_testbench_worker.js

@@ -49,7 +49,7 @@ class TestLibP2PService extends LibP2PService {
             const txHash = tx.getTxHash();
             const txHashString = txHash.toString();
             this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
-            await this.mempools.txPool.addTxs([
+            await this.mempools.txPool.addPendingTxs([
                 tx
             ]);
         } else {
@@ -204,7 +204,7 @@ process.on('message', async (msg)=>{
             const worldState = createMockWorldStateSynchronizer();
             const l2BlockSource = new MockL2BlockSource();
             const proofVerifier = new AlwaysTrueCircuitVerifier();
-            kvStore = await openTmpStore(`test-${clientIndex}`);
+            kvStore = await openTmpStore(`test-${clientIndex}`, true, BENCHMARK_CONSTANTS.KV_STORE_MAP_SIZE_KB);
             workerLogger = createLogger(`p2p:${clientIndex}`);
             workerTxPool.setLogger(workerLogger);
             const telemetry = getTelemetryClient();
@@ -273,7 +273,7 @@ process.on('message', async (msg)=>{
                     const allTxs = await generateDeterministicTxs(benchCmd.txCount, benchCmd.seed, workerConfig);
                     const txHashes = allTxs.map((tx)=>tx.getTxHash());
                     const blockProposal = await createBlockProposal(benchCmd.blockNumber, txHashes, benchCmd.seed);
-                    await workerAttestationPool.addBlockProposal(blockProposal);
+                    await workerAttestationPool.tryAddBlockProposal(blockProposal);
                     workerLogger.debug(`[BENCH] Added block proposal with archive ${blockProposal.archive.toString().slice(0, 10)}...`);
                     if (benchCmd.isAggregator) {
                         workerTxPool.clearTxs();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.0.1-commit.1a99e26c",
+  "version": "0.0.1-commit.1bb068fb5",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -67,17 +67,17 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.1a99e26c",
-    "@aztec/epoch-cache": "0.0.1-commit.1a99e26c",
-    "@aztec/ethereum": "0.0.1-commit.1a99e26c",
-    "@aztec/foundation": "0.0.1-commit.1a99e26c",
-    "@aztec/kv-store": "0.0.1-commit.1a99e26c",
-    "@aztec/noir-contracts.js": "0.0.1-commit.1a99e26c",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1a99e26c",
-    "@aztec/protocol-contracts": "0.0.1-commit.1a99e26c",
-    "@aztec/simulator": "0.0.1-commit.1a99e26c",
-    "@aztec/stdlib": "0.0.1-commit.1a99e26c",
-    "@aztec/telemetry-client": "0.0.1-commit.1a99e26c",
+    "@aztec/constants": "0.0.1-commit.1bb068fb5",
+    "@aztec/epoch-cache": "0.0.1-commit.1bb068fb5",
+    "@aztec/ethereum": "0.0.1-commit.1bb068fb5",
+    "@aztec/foundation": "0.0.1-commit.1bb068fb5",
+    "@aztec/kv-store": "0.0.1-commit.1bb068fb5",
+    "@aztec/noir-contracts.js": "0.0.1-commit.1bb068fb5",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1bb068fb5",
+    "@aztec/protocol-contracts": "0.0.1-commit.1bb068fb5",
+    "@aztec/simulator": "0.0.1-commit.1bb068fb5",
+    "@aztec/stdlib": "0.0.1-commit.1bb068fb5",
+    "@aztec/telemetry-client": "0.0.1-commit.1bb068fb5",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/libp2p-yamux": "^6.0.2",
@@ -104,8 +104,8 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.1a99e26c",
-    "@aztec/world-state": "0.0.1-commit.1a99e26c",
+    "@aztec/archiver": "0.0.1-commit.1bb068fb5",
+    "@aztec/world-state": "0.0.1-commit.1bb068fb5",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/client/factory.ts

@@ -4,29 +4,36 @@ import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
-import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { BlockHash, L2BlockSource } from '@aztec/stdlib/block';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
-import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
+import { AttestationPool, type AttestationPoolApi } from '../mem_pools/attestation_pool/attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
-import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
+import type { TxPoolV2 } from '../mem_pools/tx_pool_v2/interfaces.js';
+import type { TxMetaData } from '../mem_pools/tx_pool_v2/tx_metadata.js';
+import { AztecKVTxPoolV2 } from '../mem_pools/tx_pool_v2/tx_pool_v2.js';
+import { AggregateTxValidator } from '../msg_validators/tx_validator/aggregate_tx_validator.js';
+import { BlockHeaderTxValidator } from '../msg_validators/tx_validator/block_header_validator.js';
+import { DoubleSpendTxValidator } from '../msg_validators/tx_validator/double_spend_validator.js';
 import { DummyP2PService } from '../services/dummy_service.js';
 import { LibP2PService } from '../services/index.js';
+import { createFileStoreTxSources } from '../services/tx_collection/file_store_tx_source.js';
 import { TxCollection } from '../services/tx_collection/tx_collection.js';
 import { type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
+import { TxFileStore } from '../services/tx_file_store/tx_file_store.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
 export type P2PClientDeps<T extends P2PClientType> = {
-  txPool?: TxPool;
+  txPool?: TxPoolV2;
   store?: AztecAsyncKVStore;
-  attestationPool?: AttestationPool;
+  attestationPool?: AttestationPoolApi;
   logger?: Logger;
   txCollectionNodeSources?: TxSource[];
   p2pServiceFactory?: (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService<T>>;
@@ -69,14 +76,57 @@ export async function createP2PClient<T extends P2PClientType>(
   const attestationStore = await createStore(P2P_ATTESTATION_STORE_NAME, 1, config, bindings);
   const l1Constants = await archiver.getL1Constants();
 
-  const mempools: MemPools = {
-    txPool:
-      deps.txPool ??
-      new AztecKVTxPool(store, archive, worldStateSynchronizer, telemetry, {
+  const rollupAddress = inputConfig.l1Contracts.rollupAddress.toString().toLowerCase().replace(/^0x/, '');
+  const txFileStoreBasePath = `aztec-${inputConfig.l1ChainId}-${inputConfig.rollupVersion}-0x${rollupAddress}`;
+
+  /** Validator factory for pool re-validation (double-spend + block header only). */
+  const createPoolTxValidator = async () => {
+    await worldStateSynchronizer.syncImmediate();
+    return new AggregateTxValidator<TxMetaData>(
+      new DoubleSpendTxValidator<TxMetaData>(
+        {
+          nullifiersExist: async (nullifiers: Buffer[]) => {
+            const merkleTree = worldStateSynchronizer.getCommitted();
+            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            return indices.map(index => index !== undefined);
+          },
+        },
+        bindings,
+      ),
+      new BlockHeaderTxValidator<TxMetaData>(
+        {
+          getArchiveIndices: (archives: BlockHash[]) => {
+            const merkleTree = worldStateSynchronizer.getCommitted();
+            return merkleTree.findLeafIndices(MerkleTreeId.ARCHIVE, archives);
+          },
+        },
+        bindings,
+      ),
+    );
+  };
+
+  const txPool =
+    deps.txPool ??
+    new AztecKVTxPoolV2(
+      store,
+      archive,
+      {
+        l2BlockSource: archiver,
+        worldStateSynchronizer,
+        createTxValidator: createPoolTxValidator,
+      },
+      telemetry,
+      {
         maxPendingTxCount: config.maxPendingTxCount,
         archivedTxLimit: config.archivedTxLimit,
-      }),
-    attestationPool: deps.attestationPool ?? new KvAttestationPool(attestationStore, telemetry),
+        minTxPoolAgeMs: config.minTxPoolAgeMs,
+      },
+      dateProvider,
+    );
+
+  const mempools: MemPools = {
+    txPool,
+    attestationPool: deps.attestationPool ?? new AttestationPool(attestationStore, telemetry),
   };
 
   const p2pService = await createP2PService<T>(
@@ -105,17 +155,37 @@ export async function createP2PClient<T extends P2PClientType>(
     });
   }
 
+  const fileStoreSources = await createFileStoreTxSources(
+    config.txCollectionFileStoreUrls,
+    txFileStoreBasePath,
+    logger.createChild('file-store-tx-source'),
+  );
+  if (fileStoreSources.length > 0) {
+    logger.info(`Using ${fileStoreSources.length} file store sources for tx collection.`, {
+      stores: fileStoreSources.map(s => s.getInfo()),
+    });
+  }
+
   const txCollection = new TxCollection(
     p2pService.getBatchTxRequesterService(),
     nodeSources,
     l1Constants,
     mempools.txPool,
     config,
+    fileStoreSources,
     dateProvider,
     telemetry,
     logger.createChild('tx-collection'),
   );
 
+  const txFileStore = await TxFileStore.create(
+    mempools.txPool,
+    config,
+    txFileStoreBasePath,
+    logger.createChild('tx-file-store'),
+    telemetry,
+  );
+
   return new P2PClient(
     clientType,
     store,
@@ -123,6 +193,8 @@ export async function createP2PClient<T extends P2PClientType>(
     mempools,
     p2pService,
     txCollection,
+    txFileStore,
+    epochCache,
     config,
     dateProvider,
     telemetry,

package/src/client/interface.ts

@@ -1,7 +1,8 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress, L2BlockId } from '@aztec/stdlib/block';
 import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal, CheckpointAttestation, CheckpointProposal, P2PClientType } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import type { ENR } from '@nethermindeth/enr';
@@ -13,7 +14,12 @@ import type {
   ReqRespSubProtocolHandler,
   ReqRespSubProtocolValidators,
 } from '../services/reqresp/interface.js';
-import type { P2PBlockReceivedCallback, P2PCheckpointReceivedCallback } from '../services/service.js';
+import type {
+  DuplicateAttestationInfo,
+  DuplicateProposalInfo,
+  P2PBlockReceivedCallback,
+  P2PCheckpointReceivedCallback,
+} from '../services/service.js';
 
 /**
  * Enum defining the possible states of the p2p client.
@@ -79,12 +85,21 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   registerCheckpointProposalHandler(callback: P2PCheckpointReceivedCallback): void;
 
   /**
-   * Request a list of transactions from another peer by their tx hashes.
-   * @param txHashes - Hashes of the txs to query.
-   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
-   * @returns A list of transactions or undefined if the transactions are not found.
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   *
+   * @param callback - Function called with info about the duplicate proposal
+   */
+  registerDuplicateProposalCallback(callback: (info: DuplicateProposalInfo) => void): void;
+
+  /**
+   * Registers a callback invoked when a duplicate attestation is detected (equivocation).
+   * A validator signing attestations for different proposals at the same slot.
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   *
+   * @param callback - Function called with info about the duplicate attestation
    */
-  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<Tx[]>;
+  registerDuplicateAttestationCallback(callback: (info: DuplicateAttestationInfo) => void): void;
 
   /**
    * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
@@ -100,11 +115,10 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   addTxsToPool(txs: Tx[]): Promise<number>;
 
   /**
-   * Deletes 'txs' from the pool, given hashes.
-   * NOT used if we use sendTx as reconcileTxPool will handle this.
-   * @param txHashes - Hashes to check.
+   * Handles failed transaction execution by removing txs from the pool.
+   * @param txHashes - Hashes of the transactions that failed execution.
    **/
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
+  handleFailedExecution(txHashes: TxHash[]): Promise<void>;
 
   /**
    * Returns a transaction in the transaction pool by its hash.
@@ -152,14 +166,28 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   /** Returns an iterator over pending txs on the mempool. */
   iteratePendingTxs(): 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 the number of pending txs in the mempool. */
   getPendingTxCount(): Promise<number>;
 
   /**
-   * Marks transactions as non-evictable in the pool.
-   * @param txHashes - Hashes of the transactions to mark as non-evictable.
+   * Protects existing transactions by hash for a given slot.
+   * Returns hashes of transactions that weren't found in the pool.
+   * @param txHashes - Hashes of the transactions to protect.
+   * @param blockHeader - The block header providing slot context.
+   * @returns Hashes of transactions not found in the pool.
+   */
+  protectTxs(txHashes: TxHash[], blockHeader: BlockHeader): Promise<TxHash[]>;
+
+  /**
+   * Prepares the pool for a new slot.
+   * Unprotects transactions from earlier slots and validates them before
+   * returning to pending state.
+   * @param slotNumber - The slot number to prepare for
    */
-  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+  prepareForSlot(slotNumber: SlotNumber): Promise<void>;
 
   /**
    * Starts the p2p client.
@@ -208,6 +236,9 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
 
   handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
 
+  /** Checks if any block proposals exist for the given slot. */
+  hasBlockProposalsForSlot(slot: SlotNumber): Promise<boolean>;
+
   /** If node running this P2P stack is validator, passes in validator address to P2P layer */
   registerThisValidatorAddresses(address: EthAddress[]): void;
 };