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

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';
@@ -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,14 +121,14 @@ 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);
       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 = parentBlock.getBlockNumber() + 1;
+      const blockNumber = BlockNumber(parentBlock.getBlockNumber() + 1);
       await this.txProvider.getTxsForBlockProposal(block, blockNumber, { pinnedPeer: sender, deadline });
       return undefined;
     });
@@ -162,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);
   }
 
@@ -203,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 },
     };
   }
 
@@ -214,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;
       }
@@ -279,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();
@@ -332,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(
@@ -371,29 +371,32 @@ 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))) ?? []
-    );
+  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]) ?? Promise.resolve();
+    return this.attestationPool.deleteAttestations([attestation]);
   }
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -643,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. */
@@ -672,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())
@@ -680,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! },
+    };
   }
 
   /**
@@ -689,10 +692,10 @@ 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.getBlockHeader());
+      await this.txPool.markAsMined(txHashes, block.header);
     }
   }
 
@@ -701,33 +704,34 @@ 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: 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
@@ -760,7 +764,7 @@ 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> {
+  private async handleFinalizedL2Blocks(blocks: L2BlockNew[]): Promise<void> {
     if (!blocks.length) {
       return Promise.resolve();
     }
@@ -774,7 +778,7 @@ 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.deleteAttestationsOlderThan(lastBlockSlot);
 
     await this.synchedFinalizedBlockNumber.set(lastBlockNum);
     this.log.debug(`Synched to finalized block ${lastBlockNum} at slot ${lastBlockSlot}`);
@@ -786,7 +790,7 @@ 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();
 
@@ -825,8 +829,7 @@ 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);

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';
 
@@ -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,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: {
@@ -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';
+  }
+}

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 
 /**
@@ -51,7 +52,7 @@ export interface AttestationPool {
    *
    * @param slot - The oldest slot to keep.
    */
-  deleteAttestationsOlderThan(slot: bigint): Promise<void>;
+  deleteAttestationsOlderThan(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot
@@ -60,7 +61,7 @@ export interface AttestationPool {
    *
    * @param slot - The slot to delete.
    */
-  deleteAttestationsForSlot(slot: bigint): Promise<void>;
+  deleteAttestationsForSlot(slot: SlotNumber): Promise<void>;
 
   /**
    * Delete Attestations for slot and proposal
@@ -70,7 +71,7 @@ export interface AttestationPool {
    * @param slot - The slot to delete.
    * @param proposalId - The proposal to delete.
    */
-  deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void>;
+  deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void>;
 
   /**
    * Get all Attestations for all proposals for a given slot
@@ -80,7 +81,7 @@ export interface AttestationPool {
    * @param slot - The slot to query
    * @return BlockAttestations
    */
-  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+  getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]>;
 
   /**
    * Get Attestations for slot and given proposal
@@ -91,7 +92,7 @@ export interface AttestationPool {
    * @param proposalId - The proposal to query
    * @return BlockAttestations
    */
-  getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+  getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]>;
 
   /**
    * Check if a specific attestation exists in the pool
@@ -101,6 +102,29 @@ export interface AttestationPool {
    */
   hasAttestation(attestation: BlockAttestation): Promise<boolean>;
 
+  /**
+   * Returns whether adding this proposal is permitted at current capacity:
+   * - True if the proposal already exists, allow overwrite to keep parity with tests.
+   * - True if the slot is below the proposal cap.
+   * - False if the slot is at/above cap and this would be a new unique proposal.
+   *
+   * @param block - The block proposal to check
+   * @returns True if the proposal can be added (or already exists), false otherwise.
+   */
+  canAddProposal(block: BlockProposal): Promise<boolean>;
+
+  /**
+   * Returns whether an attestation would be accepted for (slot, proposalId):
+   * - True if the attestation already exists for this sender.
+   * - True if the attestation cap for (slot, proposalId) has not been reached.
+   * - False if the cap is reached and this attestation would be a new unique entry.
+   *
+   * @param attestation - The attestation to check
+   * @param committeeSize - Committee size for the attestation's slot, implementation may add a small buffer
+   * @returns True if the attestation can be added, false otherwise.
+   */
+  canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean>;
+
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;
 }