@aztec/p2p 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/client/interface.ts

@@ -1,10 +1,10 @@
 import type { EthAddress, L2BlockId } from '@aztec/stdlib/block';
 import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
+import type { BlockAttestation, BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 
 import type { P2PConfig } from '../config.js';
 import type { AuthRequest, StatusMessage } from '../services/index.js';
@@ -50,6 +50,9 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
    */
   broadcastProposal(proposal: BlockProposal): Promise<void>;
 
+  /** Broadcasts block attestations to other peers. */
+  broadcastAttestations(attestations: BlockAttestation[]): Promise<void>;
+
   /**
    * Registers a callback from the validator client that determines how to behave when
    * foreign block proposals are received
@@ -125,11 +128,11 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
   /**
-   * Returns whether the given tx hash is flagged as pending or mined.
+   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
    * @param txHash - Hash of the tx to query.
-   * @returns Pending or mined depending on its status, or undefined if not found.
+   * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
    */
-  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
 
   /** Returns an iterator over pending txs on the mempool. */
   iteratePendingTxs(): AsyncIterableIterator<Tx>;

package/src/client/p2p_client.ts

@@ -1,16 +1,16 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
 import type {
   EthAddress,
-  L2Block,
   L2BlockId,
+  L2BlockNew,
   L2BlockSource,
   L2BlockStream,
   L2BlockStreamEvent,
   L2Tips,
-  PublishedL2Block,
 } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
@@ -26,8 +26,8 @@ import {
   trackSpan,
 } from '@aztec/telemetry-client';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 
 import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
@@ -62,14 +62,14 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   private provenBlockNumberAtStart = -1;
   private finalizedBlockNumberAtStart = -1;
 
-  private synchedBlockHashes: AztecAsyncMap<number, string>;
-  private synchedLatestBlockNumber: AztecAsyncSingleton<number>;
-  private synchedProvenBlockNumber: AztecAsyncSingleton<number>;
-  private synchedFinalizedBlockNumber: AztecAsyncSingleton<number>;
+  private synchedBlockHashes: AztecAsyncMap<BlockNumber, string>;
+  private synchedLatestBlockNumber: AztecAsyncSingleton<BlockNumber>;
+  private synchedProvenBlockNumber: AztecAsyncSingleton<BlockNumber>;
+  private synchedFinalizedBlockNumber: AztecAsyncSingleton<BlockNumber>;
   private synchedLatestSlot: AztecAsyncSingleton<bigint>;
 
   private txPool: TxPool;
-  private attestationPool: T extends P2PClientType.Full ? AttestationPool : undefined;
+  private attestationPool: AttestationPool;
 
   private config: P2PConfig;
 
@@ -91,7 +91,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     _clientType: T,
     private store: AztecAsyncKVStore,
     private l2BlockSource: L2BlockSource & ContractDataSource,
-    mempools: MemPools<T>,
+    mempools: MemPools,
     private p2pService: P2PService,
     private txCollection: TxCollection,
     config: Partial<P2PConfig> = {},
@@ -103,7 +103,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
     this.config = { ...getP2PDefaultConfig(), ...config };
     this.txPool = mempools.txPool;
-    this.attestationPool = mempools.attestationPool!;
+    this.attestationPool = mempools.attestationPool;
 
     this.txProvider = new TxProvider(
       this.txCollection,
@@ -121,9 +121,15 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       this.log.debug(`Received block proposal from ${sender.toString()}`);
       // TODO(palla/txs): Need to subtract validatorReexecuteDeadlineMs from this deadline (see ValidatorClient.getReexecutionDeadline)
       const constants = this.txCollection.getConstants();
-      const nextSlotTimestampSeconds = Number(getTimestampForSlot(block.slotNumber.toBigInt() + 1n, constants));
+      const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(block.slotNumber + 1), constants));
       const deadline = new Date(nextSlotTimestampSeconds * 1000);
-      await this.txProvider.getTxsForBlockProposal(block, { pinnedPeer: sender, deadline });
+      const parentBlock = await this.l2BlockSource.getBlockHeaderByArchive(block.payload.header.lastArchiveRoot);
+      if (!parentBlock) {
+        this.log.debug(`Cannot collect txs for proposal as parent block not found`);
+        return;
+      }
+      const blockNumber = BlockNumber(parentBlock.getBlockNumber() + 1);
+      await this.txProvider.getTxsForBlockProposal(block, blockNumber, { pinnedPeer: sender, deadline });
       return undefined;
     });
 
@@ -156,7 +162,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return Promise.resolve(this.p2pService.getPeers(includePending));
   }
 
-  public getL2BlockHash(number: number): Promise<string | undefined> {
+  public getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
     return this.synchedBlockHashes.getAsync(number);
   }
 
@@ -197,10 +203,12 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       }
     }
 
+    const genesisHash = GENESIS_BLOCK_HEADER_HASH.toString();
+
     return {
-      latest: { hash: latestBlockHash!, number: latestBlockNumber },
-      proven: { hash: provenBlockHash!, number: provenBlockNumber },
-      finalized: { hash: finalizedBlockHash!, number: finalizedBlockNumber },
+      latest: { hash: latestBlockHash ?? genesisHash, number: latestBlockNumber },
+      proven: { hash: provenBlockHash ?? genesisHash, number: provenBlockNumber },
+      finalized: { hash: finalizedBlockHash ?? genesisHash, number: finalizedBlockNumber },
     };
   }
 
@@ -208,15 +216,16 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.log.debug(`Handling block stream event ${event.type}`);
     switch (event.type) {
       case 'blocks-added':
-        await this.handleLatestL2Blocks(event.blocks);
+        await this.handleLatestL2Blocks(event.blocks.map(b => b.block.toL2Block()));
         break;
       case 'chain-finalized': {
         // TODO (alexg): I think we can prune the block hashes map here
         await this.setBlockHash(event.block);
-        const from = (await this.getSyncedFinalizedBlockNum()) + 1;
+        const from = BlockNumber((await this.getSyncedFinalizedBlockNum()) + 1);
         const limit = event.block.number - from + 1;
         if (limit > 0) {
-          await this.handleFinalizedL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+          const oldBlocks = await this.l2BlockSource.getBlocks(from, limit);
+          await this.handleFinalizedL2Blocks(oldBlocks.map(b => b.toL2Block()));
         }
         break;
       }
@@ -273,12 +282,9 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     const syncedProvenBlock = (await this.getSyncedProvenBlockNum()) + 1;
     const syncedFinalizedBlock = (await this.getSyncedFinalizedBlockNum()) + 1;
 
-    if (
-      (await this.txPool.isEmpty()) &&
-      (this.attestationPool === undefined || (await this.attestationPool?.isEmpty()))
-    ) {
+    if ((await this.txPool.isEmpty()) && (await this.attestationPool.isEmpty())) {
       // if mempools are empty, we don't care about syncing prior blocks
-      this.initBlockStream(this.latestBlockNumberAtStart);
+      this.initBlockStream(BlockNumber(this.latestBlockNumberAtStart));
       this.setCurrentState(P2PClientState.RUNNING);
       this.syncPromise = Promise.resolve();
       await this.p2pService.start();
@@ -326,7 +332,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return this.p2pService.addReqRespSubProtocol(subProtocol, handler, validator);
   }
 
-  private initBlockStream(startingBlock?: number) {
+  private initBlockStream(startingBlock?: BlockNumber) {
     if (!this.blockStream) {
       const { blockRequestBatchSize: batchSize, blockCheckIntervalMS: pollIntervalMS } = this.config;
       this.blockStream = new TraceableL2BlockStream(
@@ -365,26 +371,32 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   }
 
   @trackSpan('p2pClient.broadcastProposal', async proposal => ({
-    [Attributes.BLOCK_NUMBER]: proposal.blockNumber,
-    [Attributes.SLOT_NUMBER]: proposal.slotNumber.toNumber(),
+    [Attributes.SLOT_NUMBER]: proposal.slotNumber,
     [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
-    [Attributes.P2P_ID]: (await proposal.p2pMessageIdentifier()).toString(),
+    [Attributes.P2P_ID]: (await proposal.p2pMessageLoggingIdentifier()).toString(),
   }))
   public broadcastProposal(proposal: BlockProposal): Promise<void> {
-    this.log.verbose(`Broadcasting proposal for slot ${proposal.slotNumber.toNumber()} to peers`);
+    this.log.verbose(`Broadcasting proposal for slot ${proposal.slotNumber} to peers`);
     return this.p2pService.propagate(proposal);
   }
 
-  public async getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]> {
-    return (
-      (await (proposalId
-        ? this.attestationPool?.getAttestationsForSlotAndProposal(slot, proposalId)
-        : this.attestationPool?.getAttestationsForSlot(slot))) ?? []
-    );
+  public async broadcastAttestations(attestations: BlockAttestation[]): Promise<void> {
+    this.log.verbose(`Broadcasting ${attestations.length} attestations to peers`);
+    await Promise.all(attestations.map(att => this.p2pService.propagate(att)));
+  }
+
+  public async getAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<BlockAttestation[]> {
+    return await (proposalId
+      ? this.attestationPool.getAttestationsForSlotAndProposal(slot, proposalId)
+      : this.attestationPool.getAttestationsForSlot(slot));
   }
 
   public addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    return this.attestationPool?.addAttestations(attestations) ?? Promise.resolve();
+    return this.attestationPool.addAttestations(attestations);
+  }
+
+  public deleteAttestation(attestation: BlockAttestation): Promise<void> {
+    return this.attestationPool.deleteAttestations([attestation]);
   }
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -599,7 +611,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * @param txHash - Hash of the tx to query.
    * @returns Pending or mined depending on its status, or undefined if not found.
    */
-  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
     return this.txPool.getTxStatus(txHash);
   }
 
@@ -634,20 +646,20 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * Public function to check the latest block number that the P2P client is synced to.
    * @returns Block number of latest L2 Block we've synced with.
    */
-  public async getSyncedLatestBlockNum(): Promise<number> {
-    return (await this.synchedLatestBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
+  public async getSyncedLatestBlockNum(): Promise<BlockNumber> {
+    return (await this.synchedLatestBlockNumber.getAsync()) ?? BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
   }
 
   /**
    * Public function to check the latest proven block number that the P2P client is synced to.
    * @returns Block number of latest proven L2 Block we've synced with.
    */
-  public async getSyncedProvenBlockNum(): Promise<number> {
-    return (await this.synchedProvenBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
+  public async getSyncedProvenBlockNum(): Promise<BlockNumber> {
+    return (await this.synchedProvenBlockNumber.getAsync()) ?? BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
   }
 
-  public async getSyncedFinalizedBlockNum(): Promise<number> {
-    return (await this.synchedFinalizedBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
+  public async getSyncedFinalizedBlockNum(): Promise<BlockNumber> {
+    return (await this.synchedFinalizedBlockNumber.getAsync()) ?? BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
   }
 
   /** Returns latest L2 slot for which we have seen an L2 block. */
@@ -663,7 +675,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     const blockNumber = await this.getSyncedLatestBlockNum();
     const blockHash =
       blockNumber === 0
-        ? ''
+        ? GENESIS_BLOCK_HEADER_HASH.toString()
         : await this.l2BlockSource
             .getBlockHeader(blockNumber)
             .then(header => header?.hash())
@@ -671,8 +683,8 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
     return {
       state: this.currentState,
-      syncedToL2Block: { number: blockNumber, hash: blockHash },
-    } as P2PSyncState;
+      syncedToL2Block: { number: blockNumber, hash: blockHash! },
+    };
   }
 
   /**
@@ -680,58 +692,46 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
    * @returns Empty promise.
    */
-  private async markTxsAsMinedFromBlocks(blocks: L2Block[]): Promise<void> {
+  private async markTxsAsMinedFromBlocks(blocks: L2BlockNew[]): Promise<void> {
     for (const block of blocks) {
       const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
       await this.txPool.markAsMined(txHashes, block.header);
     }
   }
 
-  /**
-   * Deletes txs from these blocks.
-   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
-   * @returns Empty promise.
-   */
-  private async deleteTxsFromBlocks(blocks: L2Block[]): Promise<void> {
-    this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
-    for (const block of blocks) {
-      const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
-      await this.txPool.deleteTxs(txHashes);
-    }
-  }
-
   /**
    * Handles new mined blocks by marking the txs in them as mined.
    * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
    * @returns Empty promise.
    */
-  private async handleLatestL2Blocks(blocks: PublishedL2Block[]): Promise<void> {
+  private async handleLatestL2Blocks(blocks: L2BlockNew[]): Promise<void> {
     if (!blocks.length) {
       return Promise.resolve();
     }
 
-    await this.markTxsAsMinedFromBlocks(blocks.map(b => b.block));
-    await this.startCollectingMissingTxs(blocks.map(b => b.block));
+    await this.markTxsAsMinedFromBlocks(blocks);
+    await this.txPool.clearNonEvictableTxs();
+    await this.startCollectingMissingTxs(blocks);
 
-    const lastBlock = blocks.at(-1)!.block;
+    const lastBlock = blocks.at(-1)!;
 
     await Promise.all(
       blocks.map(async block =>
         this.setBlockHash({
-          number: block.block.number,
-          hash: await block.block.hash().then(h => h.toString()),
+          number: block.number,
+          hash: await block.hash().then(h => h.toString()),
         }),
       ),
     );
 
     await this.synchedLatestBlockNumber.set(lastBlock.number);
-    await this.synchedLatestSlot.set(lastBlock.header.getSlot());
+    await this.synchedLatestSlot.set(BigInt(lastBlock.header.getSlot()));
     this.log.verbose(`Synched to latest block ${lastBlock.number}`);
     await this.startServiceIfSynched();
   }
 
   /** Request txs for unproven blocks so the prover node has more chances to get them. */
-  private async startCollectingMissingTxs(blocks: L2Block[]): Promise<void> {
+  private async startCollectingMissingTxs(blocks: L2BlockNew[]): Promise<void> {
     try {
       // TODO(#15435): If the archiver has lagged behind L1, the reported proven block number may
       // be much lower than the actual one, and it does not update until the pending chain is
@@ -764,20 +764,24 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * @param blocks - A list of finalized L2 blocks.
    * @returns Empty promise.
    */
-  private async handleFinalizedL2Blocks(blocks: L2Block[]): Promise<void> {
-    this.log.trace(`Handling finalized blocks ${blocks.length} up to ${blocks.at(-1)?.number}`);
+  private async handleFinalizedL2Blocks(blocks: L2BlockNew[]): Promise<void> {
     if (!blocks.length) {
       return Promise.resolve();
     }
+    this.log.debug(`Handling finalized blocks ${blocks.length} up to ${blocks.at(-1)?.number}`);
 
     const lastBlockNum = blocks[blocks.length - 1].number;
     const lastBlockSlot = blocks[blocks.length - 1].header.getSlot();
 
-    await this.deleteTxsFromBlocks(blocks);
-    await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlot);
+    const txHashes = blocks.flatMap(block => block.body.txEffects.map(txEffect => txEffect.txHash));
+    this.log.debug(`Deleting ${txHashes.length} txs from pool from finalized blocks up to ${lastBlockNum}`);
+    await this.txPool.deleteTxs(txHashes, { permanently: true });
+    await this.txPool.cleanupDeletedMinedTxs(lastBlockNum);
+
+    await this.attestationPool.deleteAttestationsOlderThan(lastBlockSlot);
 
     await this.synchedFinalizedBlockNumber.set(lastBlockNum);
-    this.log.debug(`Synched to finalized block ${lastBlockNum}`);
+    this.log.debug(`Synched to finalized block ${lastBlockNum} at slot ${lastBlockSlot}`);
 
     await this.startServiceIfSynched();
   }
@@ -786,42 +790,47 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * Updates the tx pool after a chain prune.
    * @param latestBlock - The block number the chain was pruned to.
    */
-  private async handlePruneL2Blocks(latestBlock: number): Promise<void> {
+  private async handlePruneL2Blocks(latestBlock: BlockNumber): Promise<void> {
     const txsToDelete = new Map<string, TxHash>();
     const minedTxs = await this.txPool.getMinedTxHashes();
 
     // Find transactions that reference pruned blocks in their historical header
     for (const tx of await this.txPool.getAllTxs()) {
       // every tx that's been generated against a block that has now been pruned is no longer valid
-      if (tx.data.constants.historicalHeader.globalVariables.blockNumber > latestBlock) {
+      if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber > latestBlock) {
         const txHash = tx.getTxHash();
         txsToDelete.set(txHash.toString(), txHash);
       }
     }
 
-    this.log.info(
-      `Detected chain prune. Removing invalid txs count=${
-        txsToDelete.size
-      } newLatestBlock=${latestBlock} previousLatestBlock=${await this.getSyncedLatestBlockNum()}`,
-    );
+    this.log.info(`Detected chain prune. Removing ${txsToDelete.size} txs built against pruned blocks.`, {
+      newLatestBlock: latestBlock,
+      previousLatestBlock: await this.getSyncedLatestBlockNum(),
+      txsToDelete: Array.from(txsToDelete.keys()),
+    });
 
     // delete invalid txs (both pending and mined)
     await this.txPool.deleteTxs(Array.from(txsToDelete.values()));
 
     // everything left in the mined set was built against a block on the proven chain so its still valid
-    // move back to pending the txs that were reorged out of the chain
+    // move back to pending the txs that were reorged out of the chain, unless txPoolDeleteTxsAfterReorg is set,
+    // in which case we clean them up to avoid potential reorg loops
     // NOTE: we can't move _all_ txs back to pending because the tx pool could keep hold of mined txs for longer
     // (see this.keepProvenTxsFor)
-
-    const txsToMoveToPending: TxHash[] = [];
+    const minedTxsFromReorg: TxHash[] = [];
     for (const [txHash, blockNumber] of minedTxs) {
-      if (blockNumber > latestBlock) {
-        txsToMoveToPending.push(txHash);
+      // We keep the txsToDelete out of this list as they have already been deleted above
+      if (blockNumber > latestBlock && !txsToDelete.has(txHash.toString())) {
+        minedTxsFromReorg.push(txHash);
       }
     }
 
-    this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
-    await this.txPool.markMinedAsPending(txsToMoveToPending);
+    if (this.config.txPoolDeleteTxsAfterReorg) {
+      this.log.info(`Deleting ${minedTxsFromReorg.length} mined txs from reorg`);
+      await this.txPool.deleteTxs(minedTxsFromReorg);
+    } else {
+      await this.txPool.markMinedAsPending(minedTxsFromReorg, latestBlock);
+    }
 
     await this.synchedLatestBlockNumber.set(latestBlock);
     // no need to update block hashes, as they will be updated as new blocks are added

package/src/config.ts

@@ -9,9 +9,9 @@ import {
   pickConfigMappings,
   secretStringConfigHelper,
 } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
-import { FunctionSelector } from '@aztec/stdlib/abi';
+import { FunctionSelector } from '@aztec/stdlib/abi/function-selector';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type AllowedElement, type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 
@@ -127,17 +127,14 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionCo
   /** A list of preferred peers. */
   preferredPeers: string[];
 
-  /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB. */
+  /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb. */
   p2pStoreMapSizeKb?: number;
 
   /** Which calls are allowed in the public setup phase of a tx. */
   txPublicSetupAllowList: AllowedElement[];
 
-  /** The maximum cumulative tx size (in bytes) of pending txs before evicting lower priority txs. */
-  maxTxPoolSize: number;
-
-  /** If the pool is full, it will still accept a few more txs until it reached maxTxPoolOverspillFactor * maxTxPoolSize. Then it will evict */
-  txPoolOverflowFactor: number;
+  /** The maximum number of pending txs before evicting lower priority txs. */
+  maxPendingTxCount: number;
 
   /** The node's seen message ID cache size */
   seenMessageCacheSize: number;
@@ -161,6 +158,15 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionCo
 
   /** The probability that a transaction is discarded. - For testing purposes only */
   dropTransactionsProbability: number;
+
+  /** Whether to delete transactions from the pool after a reorg instead of moving them back to pending. */
+  txPoolDeleteTxsAfterReorg: boolean;
+
+  /** Alters the format of p2p messages to include things like broadcast timestamp FOR TESTING ONLY */
+  debugP2PInstrumentMessages: boolean;
+
+  /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
+  fishermanMode: boolean;
 }
 
 export const DEFAULT_P2P_PORT = 40400;
@@ -357,7 +363,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   p2pStoreMapSizeKb: {
     env: 'P2P_STORE_MAP_SIZE_KB',
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
-    description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB.',
+    description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
   txPublicSetupAllowList: {
     env: 'TX_PUBLIC_SETUP_ALLOWLIST',
@@ -366,15 +372,12 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     printDefault: () =>
       'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
   },
-  maxTxPoolSize: {
-    env: 'P2P_MAX_TX_POOL_SIZE',
-    description: 'The maximum cumulative tx size of pending txs (in bytes) before evicting lower priority txs.',
-    ...numberConfigHelper(100_000_000), // 100MB
-  },
-  txPoolOverflowFactor: {
-    env: 'P2P_TX_POOL_OVERFLOW_FACTOR',
-    description: 'How much the tx pool can overflow before it starts evicting txs. Must be greater than 1',
-    ...floatConfigHelper(1.1), // 10% overflow
+  maxPendingTxCount: {
+    env: 'P2P_MAX_PENDING_TX_COUNT',
+    description: 'The maximum number of pending txs before evicting lower priority txs.',
+    // Worst case scenario: Uncompressed public/private tx is ~ 156kb
+    // This implies we are using ~156MB of memory for pending pool
+    ...numberConfigHelper(1_000),
   },
   seenMessageCacheSize: {
     env: 'P2P_SEEN_MSG_CACHE_SIZE',
@@ -403,7 +406,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   dropTransactionsProbability: {
     env: 'P2P_DROP_TX_CHANCE',
-    description: 'The probability that a transaction is discarded. - For testing purposes only',
+    description: 'The probability that a transaction is discarded (0 - 1). - For testing purposes only',
     ...floatConfigHelper(0),
   },
   disableTransactions: {
@@ -412,6 +415,22 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'Whether transactions are disabled for this node. This means transactions will be rejected at the RPC and P2P layers.',
     ...booleanConfigHelper(false),
   },
+  txPoolDeleteTxsAfterReorg: {
+    env: 'P2P_TX_POOL_DELETE_TXS_AFTER_REORG',
+    description: 'Whether to delete transactions from the pool after a reorg instead of moving them back to pending.',
+    ...booleanConfigHelper(false),
+  },
+  debugP2PInstrumentMessages: {
+    env: 'DEBUG_P2P_INSTRUMENT_MESSAGES',
+    description: 'Alters the format of p2p messages to include things like broadcast timestamp FOR TESTING ONLY',
+    ...booleanConfigHelper(false),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
+    ...booleanConfigHelper(false),
+  },
   ...p2pReqRespConfigMappings,
   ...chainConfigMappings,
   ...txCollectionConfigMappings,
@@ -441,9 +460,10 @@ export type BootnodeConfig = Pick<
   | 'peerIdPrivateKeyPath'
   | 'bootstrapNodes'
   | 'listenAddress'
+  | 'queryForIp'
 > &
   Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
-  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'> &
   Pick<ChainConfig, 'l1ChainId'>;
 
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
@@ -454,9 +474,10 @@ const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'peerIdPrivateKey',
   'peerIdPrivateKeyPath',
   'dataDirectory',
-  'dataStoreMapSizeKB',
+  'dataStoreMapSizeKb',
   'bootstrapNodes',
   'l1ChainId',
+  'queryForIp',
 ];
 
 export const bootnodeConfigMappings = pickConfigMappings(

package/src/enr/generate-enr.ts

@@ -2,9 +2,9 @@ import type { LogFn } from '@aztec/foundation/log';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
-import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { ENR, SignableENR } from '@nethermindeth/enr';
 
 import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from '../types/index.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';

package/src/errors/attestation-pool.error.ts

@@ -0,0 +1,13 @@
+export class AttestationPoolError extends Error {
+  constructor(message?: string) {
+    super(message);
+    this.name = 'AttestationPoolError';
+  }
+}
+
+export class ProposalSlotCapExceededError extends AttestationPoolError {
+  constructor(message?: string) {
+    super(message);
+    this.name = 'ProposalSlotCapExceededError';
+  }
+}