@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,70 +1,168 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposal,
+  CheckpointProposalCore,
+} from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import type { AttestationPool } from './attestation_pool.js';
+import { ATTESTATION_CAP_BUFFER, MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
 
 export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
+  private metrics: PoolInstrumentation<CheckpointAttestation>;
 
-  private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
+  private proposals: Map<string, BlockProposal>;
 
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:attestation_pool')) {
-    this.attestations = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+  // Checkpoint attestations
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private checkpointAttestations: Map<
+    /*slot=*/ SlotNumber,
+    Map</*proposalId*/ string, Map</*address=*/ string, CheckpointAttestation>>
+  >;
+  private checkpointProposals: Map<string, CheckpointProposalCore>;
+
+  constructor(
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('p2p:attestation_pool'),
+  ) {
+    this.proposals = new Map();
+    this.checkpointAttestations = new Map();
+    this.checkpointProposals = new Map();
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
   }
 
-  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
-    const slotAttestationMap = this.attestations.get(slot);
-    if (slotAttestationMap) {
-      const proposalAttestationMap = slotAttestationMap.get(proposalId);
-      if (proposalAttestationMap) {
-        return Promise.resolve(Array.from(proposalAttestationMap.values()));
-      }
+  private poolStats: PoolStatsCallback = () => {
+    return Promise.resolve({
+      itemCount: this.checkpointAttestations.size,
+    });
+  };
+
+  public isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.checkpointAttestations.size === 0 && this.proposals.size === 0);
+  }
+
+  public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
+    // Strip signedTxs before storing to avoid holding full tx data in memory
+    this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
+    return Promise.resolve();
+  }
+
+  public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+    return Promise.resolve(this.proposals.get(id));
+  }
+
+  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
+
+  public canAddProposal(_block: BlockProposal): Promise<boolean> {
+    // TODO(palla/mbps): See when to allow
+    return Promise.resolve(true);
+  }
+
+  // Checkpoint attestation methods
+
+  public async addCheckpointProposal(proposal: CheckpointProposal): Promise<void> {
+    if (!(await this.canAddCheckpointProposal(proposal))) {
+      throw new ProposalSlotCapExceededError(
+        `Maximum checkpoint proposals per slot reached: slot=${proposal.slotNumber} cap=${MAX_PROPOSALS_PER_SLOT} proposal=${proposal.archive.toString()}`,
+      );
     }
-    return Promise.resolve([]);
+
+    // Extract and validate the block proposal if present
+    const blockProposal = proposal.getBlockProposal();
+    if (blockProposal && !(await this.canAddProposal(blockProposal))) {
+      throw new ProposalSlotCapExceededError(
+        `Maximum block proposals per slot reached when extracting from checkpoint: slot=${proposal.slotNumber} proposal=${blockProposal.archive.toString()}`,
+      );
+    }
+
+    const slotProposalMapping = getCheckpointSlotOrDefault(this.checkpointAttestations, proposal.slotNumber);
+    slotProposalMapping.set(proposal.archive.toString(), new Map<string, CheckpointAttestation>());
+
+    // Store the checkpoint proposal as core (without lastBlock) to avoid duplication
+    this.checkpointProposals.set(proposal.archive.toString(), proposal.toCore());
+
+    // Store the extracted block proposal separately
+    if (blockProposal) {
+      this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs());
+    }
+
+    return Promise.resolve();
   }
 
-  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      // Perf: order and group by slot before insertion
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+  public getCheckpointProposal(id: string): Promise<CheckpointProposalCore | undefined> {
+    return Promise.resolve(this.checkpointProposals.get(id));
+  }
+
+  public hasCheckpointProposal(idOrProposal: string | CheckpointProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+    return Promise.resolve(this.checkpointProposals.has(id));
+  }
 
+  public addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.slotNumber;
       const proposalId = attestation.archive.toString();
-      const address = await attestation.getSender();
+      const sender = attestation.getSender();
+
+      // Skip attestations with invalid signatures
+      if (!sender) {
+        this.log.warn(`Skipping checkpoint attestation with invalid signature for slot ${slotNumber}`, {
+          signature: attestation.signature.toString(),
+          slotNumber,
+          proposalId,
+        });
+        continue;
+      }
 
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
-      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(address.toString(), attestation);
+      const slotAttestationMap = getCheckpointSlotOrDefault(this.checkpointAttestations, slotNumber);
+      const proposalAttestationMap = getCheckpointProposalOrDefault(slotAttestationMap, proposalId);
+      proposalAttestationMap.set(sender.toString(), attestation);
 
-      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+      this.log.verbose(`Added checkpoint attestation for slot ${slotNumber} from ${sender}`, {
+        signature: attestation.signature.toString(),
+        slotNumber,
+        address: sender,
+        proposalId,
+      });
     }
 
-    // TODO: set these to pending or something ????
-    this.metrics.recordAddedObjects(attestations.length);
     return Promise.resolve();
   }
 
-  #getNumberOfAttestationsInSlot(slot: bigint): number {
-    let total = 0;
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
+  public getCheckpointAttestationsForSlot(slot: SlotNumber): Promise<CheckpointAttestation[]> {
+    return Promise.resolve(
+      Array.from(this.checkpointAttestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
+        Array.from(proposalAttestationMap.values()),
+      ),
+    );
+  }
 
+  public getCheckpointAttestationsForSlotAndProposal(
+    slot: SlotNumber,
+    proposalId: string,
+  ): Promise<CheckpointAttestation[]> {
+    const slotAttestationMap = this.checkpointAttestations.get(slot);
     if (slotAttestationMap) {
-      for (const proposalAttestationMap of slotAttestationMap.values() ?? []) {
-        total += proposalAttestationMap.size;
+      const proposalAttestationMap = slotAttestationMap.get(proposalId);
+      if (proposalAttestationMap) {
+        return Promise.resolve(Array.from(proposalAttestationMap.values()));
       }
     }
-    return total;
+    return Promise.resolve([]);
   }
 
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+  public deleteCheckpointAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
     const olderThan = [];
 
-    // Entries are iterated in insertion order, so we can break as soon as we find a slot that is older than the oldestSlot.
-    // Note: this will only prune correctly if attestations are added in order of rising slot, it is important that we do not allow
-    // insertion of attestations that are old. #(https://github.com/AztecProtocol/aztec-packages/issues/10322)
-    const slots = this.attestations.keys();
+    const slots = this.checkpointAttestations.keys();
     for (const slot of slots) {
       if (slot < oldestSlot) {
         olderThan.push(slot);
@@ -74,88 +172,93 @@ export class InMemoryAttestationPool implements AttestationPool {
     }
 
     for (const oldSlot of olderThan) {
-      await this.deleteAttestationsForSlot(oldSlot);
+      const proposalIds = this.checkpointAttestations.get(oldSlot)?.keys();
+      proposalIds?.forEach(proposalId => this.checkpointProposals.delete(proposalId));
+      this.checkpointAttestations.delete(oldSlot);
     }
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
-    // We count the number of attestations we are removing
-    const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
+  public hasReachedCheckpointProposalCap(slot: SlotNumber): Promise<boolean> {
+    const slotAttestationMap = this.checkpointAttestations.get(slot);
+    const proposalCount = slotAttestationMap?.size ?? 0;
+    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
+  }
 
-    this.attestations.delete(slot);
-    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+  public hasReachedCheckpointAttestationCap(
+    slot: SlotNumber,
+    proposalId: string,
+    committeeSize: number,
+  ): Promise<boolean> {
+    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
+    const count = this.checkpointAttestations.get(slot)?.get(proposalId)?.size ?? 0;
+    return Promise.resolve(limit <= 0 || count >= limit);
+  }
 
-    this.metrics.recordRemovedObjects(numberOfAttestations);
-    return Promise.resolve();
+  public async canAddCheckpointProposal(proposal: CheckpointProposal): Promise<boolean> {
+    return (
+      this.checkpointProposals.has(proposal.archive.toString()) ||
+      !(await this.hasReachedCheckpointProposalCap(proposal.slotNumber))
+    );
   }
 
-  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
-    if (slotAttestationMap) {
-      if (slotAttestationMap.has(proposalId)) {
-        const numberOfAttestations = slotAttestationMap.get(proposalId)?.size ?? 0;
+  public async canAddCheckpointAttestation(
+    attestation: CheckpointAttestation,
+    committeeSize: number,
+  ): Promise<boolean> {
+    const sender = attestation.getSender();
+    const slot = attestation.payload.header.slotNumber;
+    const pid = attestation.archive.toString();
+    return (
+      !!sender &&
+      ((this.checkpointAttestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
+        !(await this.hasReachedCheckpointAttestationCap(slot, pid, committeeSize)))
+    );
+  }
 
-        slotAttestationMap.delete(proposalId);
+  public hasCheckpointAttestation(attestation: CheckpointAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive.toString();
+    const sender = attestation.getSender();
 
-        this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-        this.metrics.recordRemovedObjects(numberOfAttestations);
-      }
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return Promise.resolve(false);
     }
-    return Promise.resolve();
-  }
 
-  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
-      if (slotAttestationMap) {
-        const proposalId = attestation.archive.toString();
-        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-        if (proposalAttestationMap) {
-          const address = await attestation.getSender();
-          proposalAttestationMap.delete(address.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
-        }
-      }
+    const slotAttestationMap = this.checkpointAttestations.get(slotNumber);
+    if (!slotAttestationMap) {
+      return Promise.resolve(false);
     }
-    this.metrics.recordRemovedObjects(attestations.length);
-    return Promise.resolve();
+
+    const proposalAttestationMap = slotAttestationMap.get(proposalId);
+    if (!proposalAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    return Promise.resolve(proposalAttestationMap.has(sender.toString()));
   }
 }
 
-/**
- * Get Slot or Default
- *
- * Fetch the slot mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param slot - The slot to fetch
- * @returns The slot mapping
- */
-function getSlotOrDefault(
-  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
-  slot: bigint,
-): Map<string, Map<string, BlockAttestation>> {
+// Checkpoint attestation helper functions
+
+function getCheckpointSlotOrDefault(
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  map: Map<SlotNumber, Map<string, Map<string, CheckpointAttestation>>>,
+  slot: SlotNumber,
+): Map<string, Map<string, CheckpointAttestation>> {
   if (!map.has(slot)) {
-    map.set(slot, new Map<string, Map<string, BlockAttestation>>());
+    map.set(slot, new Map<string, Map<string, CheckpointAttestation>>());
   }
   return map.get(slot)!;
 }
 
-/**
- * Get Proposal or Default
- *
- * Fetch the proposal mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param proposalId - The proposal id to fetch
- * @returns The proposal mapping
- */
-function getProposalOrDefault(
-  map: Map<string, Map<string, BlockAttestation>>,
+function getCheckpointProposalOrDefault(
+  map: Map<string, Map<string, CheckpointAttestation>>,
   proposalId: string,
-): Map<string, BlockAttestation> {
+): Map<string, CheckpointAttestation> {
   if (!map.has(proposalId)) {
-    map.set(proposalId, new Map<string, BlockAttestation>());
+    map.set(proposalId, new Map<string, CheckpointAttestation>());
   }
   return map.get(proposalId)!;
 }

package/src/mem_pools/attestation_pool/mocks.ts

@@ -1,13 +1,13 @@
-import type { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
-  BlockAttestation,
+  CheckpointAttestation,
   ConsensusPayload,
   SignatureDomainSeparator,
   getHashedSignaturePayloadEthSignedMessage,
 } from '@aztec/stdlib/p2p';
-import { makeHeader } from '@aztec/stdlib/testing';
-import { TxHash } from '@aztec/stdlib/tx';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 
 import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
@@ -21,24 +21,31 @@ export const generateAccount = (): LocalAccount => {
   return privateKeyToAccount(privateKey);
 };
 
-/** Mock Attestation
+/** Mock Checkpoint Attestation
  *
- * @param signer A viem signer to create a signature
+ * @param signer A Secp256k1Signer to create a signature
  * @param slot The slot number the attestation is for
- * @returns A Block Attestation
+ * @param archive The archive root (defaults to random)
+ * @param header The checkpoint header (defaults to random with given slot)
+ * @returns A Checkpoint Attestation
  */
-export const mockAttestation = async (
+export const mockCheckpointAttestation = (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
-  txs: TxHash[] = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
-): Promise<BlockAttestation> => {
-  // Use arbitrary numbers for all other than slot
-  const header = makeHeader(1, 2, slot);
-  const payload = new ConsensusPayload(header, archive, txs);
+  header?: CheckpointHeader,
+): CheckpointAttestation => {
+  header = header ?? CheckpointHeader.random({ slotNumber: SlotNumber(slot) });
+  const payload = new ConsensusPayload(header, archive);
 
-  const hash = await getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-  const signature = signer.sign(hash);
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
+  const attestationSignature = signer.sign(attestationHash);
 
-  return new BlockAttestation(payload, signature);
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointProposal);
+  const proposerSignature = signer.sign(proposalHash);
+
+  return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
 };

package/src/mem_pools/instrumentation.ts

@@ -1,13 +1,18 @@
 import type { Gossipable } from '@aztec/stdlib/p2p';
+import type { Tx } from '@aztec/stdlib/tx';
 import {
   Attributes,
+  type BatchObservableResult,
   type Histogram,
   LmdbMetrics,
   type LmdbStatsCallback,
+  type Meter,
+  type MetricDefinition,
   Metrics,
-  type MetricsType,
+  type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 export enum PoolName {
@@ -16,8 +21,10 @@ export enum PoolName {
 }
 
 type MetricsLabels = {
-  objectInMempool: MetricsType;
-  objectSize: MetricsType;
+  objectInMempool: MetricDefinition;
+  objectSize: MetricDefinition;
+  itemsAdded: MetricDefinition;
+  itemMinedDelay: MetricDefinition;
 };
 
 /**
@@ -30,97 +37,114 @@ function getMetricsLabels(name: PoolName): MetricsLabels {
     return {
       objectInMempool: Metrics.MEMPOOL_TX_COUNT,
       objectSize: Metrics.MEMPOOL_TX_SIZE,
+      itemsAdded: Metrics.MEMPOOL_TX_ADDED_COUNT,
+      itemMinedDelay: Metrics.MEMPOOL_TX_MINED_DELAY,
     };
   } else if (name === PoolName.ATTESTATION_POOL) {
     return {
       objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
       objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
+      itemsAdded: Metrics.MEMPOOL_ATTESTATIONS_ADDED_COUNT,
+      itemMinedDelay: Metrics.MEMPOOL_ATTESTATIONS_MINED_DELAY,
     };
   }
 
   throw new Error('Invalid pool type');
 }
 
+export type PoolStatsCallback = () => Promise<{
+  itemCount: number | Record<string, number>;
+}>;
+
 /**
  * Instrumentation class for the Pools (TxPool, AttestationPool, etc).
  */
 export class PoolInstrumentation<PoolObject extends Gossipable> {
   /** The number of txs in the mempool */
-  private objectsInMempool: UpDownCounter;
+  private objectsInMempool: ObservableGauge;
+  private addObjectCounter: UpDownCounter;
   /** Tracks tx size */
   private objectSize: Histogram;
+  /** Track delay between transaction added and evicted */
+  private minedDelay: Histogram;
 
   private dbMetrics: LmdbMetrics;
 
   private defaultAttributes;
+  private meter: Meter;
+
+  private txAddedTimestamp: Map<bigint, number> = new Map<bigint, number>();
 
-  constructor(telemetry: TelemetryClient, name: PoolName, dbStats?: LmdbStatsCallback) {
-    const meter = telemetry.getMeter(name);
+  constructor(
+    telemetry: TelemetryClient,
+    name: PoolName,
+    private poolStats: PoolStatsCallback,
+    dbStats?: LmdbStatsCallback,
+  ) {
+    this.meter = telemetry.getMeter(name);
     this.defaultAttributes = { [Attributes.POOL_NAME]: name };
 
     const metricsLabels = getMetricsLabels(name);
 
-    this.objectsInMempool = meter.createUpDownCounter(metricsLabels.objectInMempool, {
-      description: 'The current number of transactions in the mempool',
-    });
+    this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool);
 
-    this.objectSize = meter.createHistogram(metricsLabels.objectSize, {
-      unit: 'By',
-      description: 'The size of transactions in the mempool',
-    });
+    this.objectSize = this.meter.createHistogram(metricsLabels.objectSize);
 
     this.dbMetrics = new LmdbMetrics(
-      meter,
+      this.meter,
       {
         [Attributes.DB_DATA_TYPE]: 'tx-pool',
       },
       dbStats,
     );
+
+    this.addObjectCounter = createUpDownCounterWithDefault(this.meter, metricsLabels.itemsAdded);
+
+    this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay);
+
+    this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }
 
   public recordSize(poolObject: PoolObject) {
     this.objectSize.record(poolObject.getSize());
   }
 
-  /**
-   * Updates the metrics with the new objects.
-   * @param txs - The objects to record
-   */
-  public recordAddedObjects(count = 1, status?: string) {
-    if (count < 0) {
-      throw new Error('Count must be positive');
-    }
-    if (count === 0) {
-      return;
-    }
-    const attributes = status
-      ? {
-          ...this.defaultAttributes,
-          [Attributes.STATUS]: status,
-        }
-      : this.defaultAttributes;
-
-    this.objectsInMempool.add(count, attributes);
+  public incrementAddedObjects(count: number) {
+    this.addObjectCounter.add(count);
   }
 
-  /**
-   * Updates the metrics by removing objects from the mempool.
-   * @param count - The number of objects to remove from the mempool
-   */
-  public recordRemovedObjects(count = 1, status?: string) {
-    if (count < 0) {
-      throw new Error('Count must be positive');
+  public transactionsAdded(transactions: Tx[]) {
+    const timestamp = Date.now();
+    for (const transaction of transactions) {
+      this.txAddedTimestamp.set(transaction.txHash.toBigInt(), timestamp);
     }
-    if (count === 0) {
-      return;
+  }
+
+  public transactionsRemoved(hashes: Iterable<bigint> | Iterable<string>) {
+    const timestamp = Date.now();
+    for (const hash of hashes) {
+      const key = BigInt(hash);
+      const addedAt = this.txAddedTimestamp.get(key);
+      if (addedAt !== undefined) {
+        this.txAddedTimestamp.delete(key);
+        if (addedAt < timestamp) {
+          this.minedDelay.record(timestamp - addedAt);
+        }
+      }
     }
+  }
 
-    const attributes = status
-      ? {
+  private observeStats = async (observer: BatchObservableResult) => {
+    const { itemCount } = await this.poolStats();
+    if (typeof itemCount === 'number') {
+      observer.observe(this.objectsInMempool, itemCount, this.defaultAttributes);
+    } else {
+      for (const [status, count] of Object.entries(itemCount)) {
+        observer.observe(this.objectsInMempool, count, {
           ...this.defaultAttributes,
           [Attributes.STATUS]: status,
-        }
-      : this.defaultAttributes;
-    this.objectsInMempool.add(-1 * count, attributes);
-  }
+        });
+      }
+    }
+  };
 }

package/src/mem_pools/interface.ts

@@ -1,12 +1,10 @@
-import type { P2PClientType } from '@aztec/stdlib/p2p';
-
 import type { AttestationPool } from './attestation_pool/attestation_pool.js';
 import type { TxPool } from './tx_pool/tx_pool.js';
 
 /**
  * A interface the combines all mempools
  */
-export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
+export type MemPools = {
   txPool: TxPool;
-  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+  attestationPool: AttestationPool;
 };