@aztec/p2p 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/src/client/p2p_client.ts

@@ -1,30 +1,29 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { GENESIS_BLOCK_HEADER_HASH } 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,
-  L2BlockSource,
+import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
+import { L2TipsKVStore } from '@aztec/kv-store/stores';
+import {
+  type EthAddress,
+  type L2Block,
+  type L2BlockSource,
   L2BlockStream,
-  L2BlockStreamEvent,
-  L2Tips,
-  PublishedL2Block,
+  type L2BlockStreamEvent,
+  type L2Tips,
+  type L2TipsStore,
 } 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 { BlockAttestation, type BlockProposal, type P2PClientType } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
 import {
-  Attributes,
-  type TelemetryClient,
-  TraceableL2BlockStream,
-  WithTracer,
-  getTelemetryClient,
-  trackSpan,
-} from '@aztec/telemetry-client';
+  type BlockProposal,
+  CheckpointAttestation,
+  type CheckpointProposal,
+  type P2PClientType,
+} from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import { Attributes, type TelemetryClient, WithTracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 import type { ENR } from '@nethermindeth/enr';
@@ -40,7 +39,7 @@ import {
   type ReqRespSubProtocolValidators,
 } from '../services/reqresp/interface.js';
 import { chunkTxHashesRequest } from '../services/reqresp/protocols/tx.js';
-import type { P2PBlockReceivedCallback, P2PService } from '../services/service.js';
+import type { P2PBlockReceivedCallback, P2PCheckpointReceivedCallback, P2PService } from '../services/service.js';
 import { TxCollection } from '../services/tx_collection/tx_collection.js';
 import { TxProvider } from '../services/tx_provider.js';
 import { type P2P, P2PClientState, type P2PSyncState } from './interface.js';
@@ -62,14 +61,11 @@ 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 l2Tips: L2TipsStore;
   private synchedLatestSlot: AztecAsyncSingleton<bigint>;
 
   private txPool: TxPool;
-  private attestationPool: T extends P2PClientType.Full ? AttestationPool : undefined;
+  private attestationPool: AttestationPool;
 
   private config: P2PConfig;
 
@@ -91,7 +87,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 +99,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,
@@ -114,30 +110,27 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     );
 
     // Default to collecting all txs when we see a valid proposal
-    // This can be overridden by the validator client to attest, and it will call getTxsForBlockProposal on its own
+    // This can be overridden by the validator client to validate, and it will call getTxsForBlockProposal on its own
+    // Note: Validators do NOT attest to individual blocks - attestations are only for checkpoint proposals.
     // TODO(palla/txs): We should not trigger a request for txs on a proposal before fully validating it. We need to bring
     // validator-client code into here so we can validate a proposal is reasonable.
     this.registerBlockProposalHandler(async (block, sender) => {
       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);
-      const parentBlock = await this.l2BlockSource.getBlockHeaderByArchive(block.payload.header.lastArchiveRoot);
+      const parentBlock = await this.l2BlockSource.getBlockHeaderByArchive(block.blockHeader.lastArchive.root);
       if (!parentBlock) {
         this.log.debug(`Cannot collect txs for proposal as parent block not found`);
-        return;
+        return false;
       }
-      const blockNumber = parentBlock.getBlockNumber() + 1;
+      const blockNumber = BlockNumber(parentBlock.getBlockNumber() + 1);
       await this.txProvider.getTxsForBlockProposal(block, blockNumber, { pinnedPeer: sender, deadline });
-      return undefined;
+      return true;
     });
 
-    // REFACTOR: Try replacing these with an L2TipsStore
-    this.synchedBlockHashes = store.openMap('p2p_pool_block_hashes');
-    this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
-    this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
-    this.synchedFinalizedBlockNumber = store.openSingleton('p2p_pool_last_finalized_l2_block');
+    this.l2Tips = new L2TipsKVStore(store, 'p2p_client');
     this.synchedLatestSlot = store.openSingleton('p2p_pool_last_l2_slot');
   }
 
@@ -162,8 +155,8 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return Promise.resolve(this.p2pService.getPeers(includePending));
   }
 
-  public getL2BlockHash(number: number): Promise<string | undefined> {
-    return this.synchedBlockHashes.getAsync(number);
+  public getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
+    return this.l2Tips.getL2BlockHash(number);
   }
 
   public updateP2PConfig(config: Partial<P2PConfig>): Promise<void> {
@@ -172,82 +165,45 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return Promise.resolve();
   }
 
-  public async getL2Tips(): Promise<L2Tips> {
-    const latestBlockNumber = await this.getSyncedLatestBlockNum();
-    let latestBlockHash: string | undefined;
-
-    const provenBlockNumber = await this.getSyncedProvenBlockNum();
-    let provenBlockHash: string | undefined;
-
-    const finalizedBlockNumber = await this.getSyncedFinalizedBlockNum();
-    let finalizedBlockHash: string | undefined;
-
-    if (latestBlockNumber > 0) {
-      latestBlockHash = await this.synchedBlockHashes.getAsync(latestBlockNumber);
-      if (typeof latestBlockHash === 'undefined') {
-        throw new Error(`Block hash for latest block ${latestBlockNumber} not found in p2p client`);
-      }
-    }
-
-    if (provenBlockNumber > 0) {
-      provenBlockHash = await this.synchedBlockHashes.getAsync(provenBlockNumber);
-      if (typeof provenBlockHash === 'undefined') {
-        throw new Error(`Block hash for proven block ${provenBlockNumber} not found in p2p client`);
-      }
-    }
-
-    if (finalizedBlockNumber > 0) {
-      finalizedBlockHash = await this.synchedBlockHashes.getAsync(finalizedBlockNumber);
-      if (typeof finalizedBlockHash === 'undefined') {
-        throw new Error(`Block hash for finalized block ${finalizedBlockNumber} not found in p2p client`);
-      }
-    }
-
-    return {
-      latest: { hash: latestBlockHash!, number: latestBlockNumber },
-      proven: { hash: provenBlockHash!, number: provenBlockNumber },
-      finalized: { hash: finalizedBlockHash!, number: finalizedBlockNumber },
-    };
+  public getL2Tips(): Promise<L2Tips> {
+    return this.l2Tips.getL2Tips();
   }
 
   public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
     this.log.debug(`Handling block stream event ${event.type}`);
+
     switch (event.type) {
       case 'blocks-added':
         await this.handleLatestL2Blocks(event.blocks);
         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 oldFinalizedBlockNum = await this.getSyncedFinalizedBlockNum();
+        const from = BlockNumber(oldFinalizedBlockNum + 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);
         }
         break;
       }
-      case 'chain-proven': {
-        await this.setBlockHash(event.block);
+      case 'chain-proven':
         this.txCollection.stopCollectingForBlocksUpTo(event.block.number);
-        await this.synchedProvenBlockNumber.set(event.block.number);
         break;
-      }
       case 'chain-pruned':
-        await this.setBlockHash(event.block);
         this.txCollection.stopCollectingForBlocksAfter(event.block.number);
         await this.handlePruneL2Blocks(event.block.number);
         break;
+      case 'chain-checkpointed':
+        break;
       default: {
         const _: never = event;
         break;
       }
     }
-  }
 
-  private async setBlockHash(block: L2BlockId): Promise<void> {
-    if (block.hash !== undefined) {
-      await this.synchedBlockHashes.set(block.number, block.hash.toString());
-    }
+    // Pass the event through to our l2 tips store
+    await this.l2Tips.handleBlockStreamEvent(event);
+    await this.startServiceIfSynched();
   }
 
   #assertIsReady() {
@@ -271,20 +227,17 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
     // get the current latest block numbers
     const latestBlockNumbers = await this.l2BlockSource.getL2Tips();
-    this.latestBlockNumberAtStart = latestBlockNumbers.latest.number;
-    this.provenBlockNumberAtStart = latestBlockNumbers.proven.number;
-    this.finalizedBlockNumberAtStart = latestBlockNumbers.finalized.number;
+    this.latestBlockNumberAtStart = latestBlockNumbers.proposed.number;
+    this.provenBlockNumberAtStart = latestBlockNumbers.proven.block.number;
+    this.finalizedBlockNumberAtStart = latestBlockNumbers.finalized.block.number;
 
     const syncedLatestBlock = (await this.getSyncedLatestBlockNum()) + 1;
     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();
@@ -332,15 +285,13 @@ 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(
+      this.blockStream = new L2BlockStream(
         this.l2BlockSource,
         this,
         this,
-        this.telemetry.getTracer('P2PL2BlockStream'),
-        'P2PL2BlockStream',
         createLogger(`${this.log.module}:l2-block-stream`),
         { batchSize, pollIntervalMS, startingBlock },
       );
@@ -371,29 +322,41 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   }
 
   @trackSpan('p2pClient.broadcastProposal', async proposal => ({
-    [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))) ?? []
-    );
+  @trackSpan('p2pClient.broadcastCheckpointProposal', async proposal => ({
+    [Attributes.SLOT_NUMBER]: proposal.slotNumber,
+    [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
+    [Attributes.P2P_ID]: (await proposal.p2pMessageLoggingIdentifier()).toString(),
+  }))
+  public broadcastCheckpointProposal(proposal: CheckpointProposal): Promise<void> {
+    this.log.verbose(`Broadcasting checkpoint proposal for slot ${proposal.slotNumber} to peers`);
+    return this.p2pService.propagate(proposal);
+  }
+
+  public async broadcastCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
+    this.log.verbose(`Broadcasting ${attestations.length} checkpoint attestations to peers`);
+    await Promise.all(attestations.map(att => this.p2pService.propagate(att)));
   }
 
-  public addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    return this.attestationPool?.addAttestations(attestations) ?? Promise.resolve();
+  public async getCheckpointAttestationsForSlot(
+    slot: SlotNumber,
+    proposalId?: string,
+  ): Promise<CheckpointAttestation[]> {
+    return await (proposalId
+      ? this.attestationPool.getCheckpointAttestationsForSlotAndProposal(slot, proposalId)
+      : this.attestationPool.getCheckpointAttestationsForSlot(slot));
   }
 
-  public deleteAttestation(attestation: BlockAttestation): Promise<void> {
-    return this.attestationPool?.deleteAttestations([attestation]) ?? Promise.resolve();
+  public addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
+    return this.attestationPool.addCheckpointAttestations(attestations);
   }
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -402,6 +365,10 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.p2pService.registerBlockReceivedCallback(handler);
   }
 
+  public registerCheckpointProposalHandler(handler: P2PCheckpointReceivedCallback): void {
+    this.p2pService.registerCheckpointReceivedCallback(handler);
+  }
+
   /**
    * Uses the batched Request Response protocol to request a set of transactions from the network.
    */
@@ -643,20 +610,23 @@ 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> {
+    const tips = await this.l2Tips.getL2Tips();
+    return tips.proposed.number;
   }
 
   /**
    * 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> {
+    const tips = await this.l2Tips.getL2Tips();
+    return tips.proven.block.number;
   }
 
-  public async getSyncedFinalizedBlockNum(): Promise<number> {
-    return (await this.synchedFinalizedBlockNumber.getAsync()) ?? INITIAL_L2_BLOCK_NUM - 1;
+  public async getSyncedFinalizedBlockNum(): Promise<BlockNumber> {
+    const tips = await this.l2Tips.getL2Tips();
+    return tips.finalized.block.number;
   }
 
   /** Returns latest L2 slot for which we have seen an L2 block. */
@@ -672,7 +642,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())
@@ -680,8 +650,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! },
+    };
   }
 
   /**
@@ -692,7 +662,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   private async markTxsAsMinedFromBlocks(blocks: L2Block[]): Promise<void> {
     for (const block of blocks) {
       const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
-      await this.txPool.markAsMined(txHashes, block.getBlockHeader());
+      await this.txPool.markAsMined(txHashes, block.header);
     }
   }
 
@@ -701,29 +671,18 @@ 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 handleLatestL2Blocks(blocks: PublishedL2Block[]): Promise<void> {
+  private async handleLatestL2Blocks(blocks: L2Block[]): Promise<void> {
     if (!blocks.length) {
       return Promise.resolve();
     }
 
-    await this.markTxsAsMinedFromBlocks(blocks.map(b => b.block));
-    await this.startCollectingMissingTxs(blocks.map(b => b.block));
-
-    const lastBlock = blocks.at(-1)!.block;
-
-    await Promise.all(
-      blocks.map(async block =>
-        this.setBlockHash({
-          number: block.block.number,
-          hash: await block.block.hash().then(h => h.toString()),
-        }),
-      ),
-    );
+    await this.markTxsAsMinedFromBlocks(blocks);
+    await this.txPool.clearNonEvictableTxs();
+    await this.startCollectingMissingTxs(blocks);
 
-    await this.synchedLatestBlockNumber.set(lastBlock.number);
-    await this.synchedLatestSlot.set(lastBlock.header.getSlot());
+    const lastBlock = blocks.at(-1)!;
+    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. */
@@ -774,19 +733,16 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     await this.txPool.deleteTxs(txHashes, { permanently: true });
     await this.txPool.cleanupDeletedMinedTxs(lastBlockNum);
 
-    await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlot);
+    await this.attestationPool.deleteCheckpointAttestationsOlderThan(lastBlockSlot);
 
-    await this.synchedFinalizedBlockNumber.set(lastBlockNum);
     this.log.debug(`Synched to finalized block ${lastBlockNum} at slot ${lastBlockSlot}`);
-
-    await this.startServiceIfSynched();
   }
 
   /**
    * 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();
 
@@ -825,21 +781,18 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       this.log.info(`Deleting ${minedTxsFromReorg.length} mined txs from reorg`);
       await this.txPool.deleteTxs(minedTxsFromReorg);
     } else {
-      this.log.info(`Moving ${minedTxsFromReorg.length} mined txs from reorg back to pending`);
-      await this.txPool.markMinedAsPending(minedTxsFromReorg);
+      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
   }
 
   private async startServiceIfSynched() {
     if (this.currentState !== P2PClientState.SYNCHING) {
       return;
     }
-    const syncedFinalizedBlock = await this.getSyncedFinalizedBlockNum();
-    const syncedProvenBlock = await this.getSyncedProvenBlockNum();
-    const syncedLatestBlock = await this.getSyncedLatestBlockNum();
+    const tips = await this.l2Tips.getL2Tips();
+    const syncedFinalizedBlock = tips.finalized.block.number;
+    const syncedProvenBlock = tips.proven.block.number;
+    const syncedLatestBlock = tips.proposed.number;
 
     if (
       syncedLatestBlock >= this.latestBlockNumberAtStart &&

package/src/config.ts

@@ -2,16 +2,16 @@ import {
   type ConfigMappingsType,
   SecretValue,
   booleanConfigHelper,
-  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
+  percentageConfigHelper,
   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';
 
@@ -133,11 +133,8 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionCo
   /** 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;
@@ -164,6 +161,12 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionCo
 
   /** 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;
@@ -369,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',
@@ -406,8 +406,8 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   dropTransactionsProbability: {
     env: 'P2P_DROP_TX_CHANCE',
-    description: 'The probability that a transaction is discarded. - For testing purposes only',
-    ...floatConfigHelper(0),
+    description: 'The probability that a transaction is discarded (0 - 1). - For testing purposes only',
+    ...percentageConfigHelper(0),
   },
   disableTransactions: {
     env: 'TRANSACTIONS_DISABLED',
@@ -420,6 +420,17 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     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,

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';
+  }
+}