@aztec/p2p 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/src/client/test/tx_proposal_collector/proposal_tx_collector_worker.ts

@@ -1,336 +0,0 @@
-import { MockL2BlockSource } from '@aztec/archiver/test';
-import { SecretValue } from '@aztec/foundation/config';
-import { createLogger } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
-import { DateProvider, Timer, executeTimeout } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
-import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import type { PeerId } from '@libp2p/interface';
-import { peerIdFromString } from '@libp2p/peer-id';
-
-import type { P2PConfig } from '../../../config.js';
-import type { IBatchRequestTxValidator } from '../../../services/reqresp/batch-tx-requester/tx_validator.js';
-import { RateLimitStatus } from '../../../services/reqresp/rate-limiter/rate_limiter.js';
-import {
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from '../../../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../../../test-helpers/reqresp-nodes.js';
-import {
-  BENCHMARK_CONSTANTS,
-  InMemoryAttestationPool,
-  InMemoryTxPool,
-  UNLIMITED_RATE_LIMIT_QUOTA,
-  calculateInternalTimeout,
-  createMockEpochCache,
-  createMockWorldStateSynchronizer,
-} from '../../../test-helpers/testbench-utils.js';
-import { createP2PClient } from '../../index.js';
-import type { P2PClient } from '../../p2p_client.js';
-import {
-  type WorkerCommand,
-  type WorkerResponse,
-  deserializeBlockProposal,
-  deserializeTx,
-  deserializeTxHash,
-} from './proposal_tx_collector_worker_protocol.js';
-
-let client: P2PClient | undefined;
-let txPool: InMemoryTxPool | undefined;
-let attestationPool: InMemoryAttestationPool | undefined;
-let logger = createLogger('p2p:proposal-bench');
-let kvStore: Awaited<ReturnType<typeof openTmpStore>> | undefined;
-let ipcDisconnected = false;
-
-function ensureClient(): P2PClient {
-  if (!client || !txPool) {
-    throw new Error('Worker client not started');
-  }
-  return client;
-}
-
-function isIpcDisconnectError(err: unknown): boolean {
-  const code = (err as NodeJS.ErrnoException | undefined)?.code;
-  return code === 'EPIPE' || code === 'ERR_IPC_CHANNEL_CLOSED';
-}
-
-function sendMessage(message: WorkerResponse): Promise<void> {
-  const send = process.send;
-  if (!send || !process.connected || ipcDisconnected) {
-    return Promise.resolve();
-  }
-
-  return new Promise(resolve => {
-    const fallbackTimeout = setTimeout(() => resolve(), 2000);
-    try {
-      send.call(process, message, undefined, undefined, err => {
-        clearTimeout(fallbackTimeout);
-        if (!err) {
-          resolve();
-          return;
-        }
-        if (isIpcDisconnectError(err)) {
-          ipcDisconnected = true;
-          resolve();
-          return;
-        }
-        logger.warn('Failed to send IPC message', { error: err?.message ?? String(err) });
-        resolve();
-      });
-    } catch (err: any) {
-      clearTimeout(fallbackTimeout);
-      if (isIpcDisconnectError(err)) {
-        ipcDisconnected = true;
-        resolve();
-        return;
-      }
-      logger.warn('Failed to send IPC message', { error: err?.message ?? String(err) });
-      resolve();
-    }
-  });
-}
-
-async function startClient(config: P2PConfig, clientIndex: number) {
-  txPool = new InMemoryTxPool();
-  attestationPool = new InMemoryAttestationPool();
-  const epochCache = createMockEpochCache();
-  const worldState = createMockWorldStateSynchronizer();
-  const l2BlockSource = new MockL2BlockSource();
-  const proofVerifier = new AlwaysTrueCircuitVerifier();
-  kvStore = await openTmpStore(`proposal-bench-${clientIndex}`);
-  logger = createLogger(`p2p:proposal-bench:${clientIndex}`);
-
-  const telemetry = getTelemetryClient();
-  const deps = {
-    txPool,
-    attestationPool,
-    store: kvStore,
-    logger,
-  };
-
-  client = await createP2PClient(
-    P2PClientType.Full,
-    config as P2PConfig & DataStoreConfig,
-    l2BlockSource as L2BlockSource & ContractDataSource,
-    proofVerifier as ClientProtocolCircuitVerifier,
-    worldState,
-    epochCache,
-    'proposal-tx-collector-bench-worker',
-    new DateProvider(),
-    telemetry as TelemetryClient,
-    deps,
-  );
-
-  await client.start();
-  installUnlimitedRateLimits();
-
-  for (let i = 0; i < 120; i++) {
-    if (client.isReady()) {
-      return;
-    }
-    await sleep(500);
-  }
-
-  throw new Error('Timed out waiting for P2P client readiness');
-}
-
-function installSamplerOverrides(peerList: ReturnType<typeof peerIdFromString>[]) {
-  const reqResp = (ensureClient() as any).p2pService.reqresp as any;
-  const sampler = reqResp.connectionSampler as any;
-
-  sampler.getPeerListSortedByConnectionCountAsc = (excluding?: Set<string>) => {
-    if (!excluding || excluding.size === 0) {
-      return peerList;
-    }
-    return peerList.filter(peerId => !excluding.has(peerId.toString()));
-  };
-  sampler.samplePeersBatch = (numberToSample: number, excluding?: Map<string, boolean>) => {
-    const filtered = peerList.filter(peerId => !excluding?.has(peerId.toString()));
-    return filtered.slice(0, Math.min(numberToSample, filtered.length));
-  };
-  sampler.getPeer = (excluding?: Map<string, boolean>) => {
-    const filtered = peerList.filter(peerId => !excluding?.has(peerId.toString()));
-    return filtered[0];
-  };
-}
-
-function installUnlimitedRateLimits() {
-  const reqResp = (ensureClient() as any).p2pService.reqresp as any;
-  const rateLimiter = reqResp.rateLimiter as any;
-
-  rateLimiter.getRateLimits = () => UNLIMITED_RATE_LIMIT_QUOTA;
-  rateLimiter.allow = () => RateLimitStatus.Allowed;
-}
-
-async function runCollector(cmd: Extract<WorkerCommand, { type: 'RUN_COLLECTOR' }>) {
-  const { collectorType, txHashes, blockProposal, pinnedPeerId, peerIds, timeoutMs } = cmd;
-  const reqResp = (ensureClient() as any).p2pService.reqresp as any;
-  const peerList = peerIds.map(peerId => peerIdFromString(peerId));
-
-  installSamplerOverrides(peerList);
-  installUnlimitedRateLimits();
-
-  const p2pService = {
-    reqResp,
-    connectionSampler: {
-      getPeerListSortedByConnectionCountAsc: () => peerList,
-    },
-    txValidatorConfig: {
-      l1ChainId: 1,
-      rollupVersion: 1,
-      proofVerifier: {
-        verifyProof: () => Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 }),
-        stop: () => Promise.resolve(),
-      },
-    },
-    peerScoring: {
-      penalizePeer: (_peerId: PeerId, _penalty: PeerErrorSeverity) => {},
-    },
-  };
-
-  const parsedTxHashes = txHashes.map(deserializeTxHash);
-  const parsedProposal = deserializeBlockProposal(blockProposal);
-  const pinnedPeer = pinnedPeerId ? peerIdFromString(pinnedPeerId) : undefined;
-
-  const timer = new Timer();
-  let fetchedCount = 0;
-
-  const internalTimeoutMs = calculateInternalTimeout(timeoutMs);
-
-  const noopTxValidator: IBatchRequestTxValidator = {
-    validateRequestedTx: (_tx: Tx): Promise<TxValidationResult> => Promise.resolve({ result: 'valid' }),
-    validateRequestedTxs: (txs: Tx[]): Promise<TxValidationResult[]> =>
-      Promise.resolve(txs.map(() => ({ result: 'valid' }))),
-  };
-
-  try {
-    if (collectorType === 'batch-requester') {
-      const collector = new BatchTxRequesterCollector(p2pService, logger, new DateProvider(), noopTxValidator);
-      const fetched = await executeTimeout(
-        (_signal: AbortSignal) => collector.collectTxs(parsedTxHashes, parsedProposal, pinnedPeer, internalTimeoutMs),
-        timeoutMs,
-        () => new Error(`Collector timed out after ${timeoutMs}ms`),
-      );
-      fetchedCount = fetched.length;
-    } else {
-      const collector = new SendBatchRequestCollector(
-        p2pService,
-        BENCHMARK_CONSTANTS.FIXED_MAX_PEERS,
-        BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
-      );
-      const fetched = await executeTimeout(
-        (_signal: AbortSignal) => collector.collectTxs(parsedTxHashes, parsedProposal, pinnedPeer, internalTimeoutMs),
-        timeoutMs,
-        () => new Error(`Collector timed out after ${timeoutMs}ms`),
-      );
-      fetchedCount = fetched.length;
-    }
-  } catch (err: any) {
-    logger.warn(`Collector error: ${err?.message ?? String(err)}`);
-  }
-
-  return { durationMs: timer.ms(), fetchedCount };
-}
-
-async function stopClient() {
-  if (!client) {
-    return;
-  }
-  await client.stop();
-  if (kvStore?.close) {
-    await kvStore.close();
-  }
-  client = undefined;
-  txPool = undefined;
-  attestationPool = undefined;
-}
-
-process.on('disconnect', () => {
-  ipcDisconnected = true;
-  void stopClient().finally(() => process.exit(0));
-});
-
-process.on('error', err => {
-  if (isIpcDisconnectError(err)) {
-    ipcDisconnected = true;
-    return;
-  }
-  logger.warn('Worker process error', { error: err?.message ?? String(err) });
-});
-
-process.on('message', (msg: WorkerCommand) => {
-  void (async () => {
-    if (!msg || typeof msg !== 'object') {
-      return;
-    }
-
-    const requestId = msg.requestId;
-
-    try {
-      switch (msg.type) {
-        case 'START': {
-          const rawConfig = msg.config;
-          const config: P2PConfig = {
-            ...rawConfig,
-            peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
-          } as P2PConfig;
-
-          await startClient(config, msg.clientIndex);
-          const peerId = (ensureClient() as any).p2pService.node.peerId.toString();
-          await sendMessage({ type: 'READY', requestId, peerId });
-          break;
-        }
-        case 'SET_TXS': {
-          if (!txPool) {
-            throw new Error('Tx pool not initialized');
-          }
-          const txs = msg.txs.map(deserializeTx);
-          const count = msg.mode === 'append' ? txPool.appendTxs(txs) : txPool.setTxs(txs);
-          await sendMessage({ type: 'TXS_SET', requestId, count });
-          break;
-        }
-        case 'SET_BLOCK_PROPOSAL': {
-          if (!attestationPool) {
-            throw new Error('Attestation pool not initialized');
-          }
-          const proposal = deserializeBlockProposal(msg.blockProposal);
-          await attestationPool.addBlockProposal(proposal);
-          await sendMessage({ type: 'BLOCK_PROPOSAL_SET', requestId, archiveRoot: proposal.archive.toString() });
-          break;
-        }
-        case 'RUN_COLLECTOR': {
-          const { durationMs, fetchedCount } = await runCollector(msg);
-          await sendMessage({ type: 'COLLECTOR_RESULT', requestId, durationMs, fetchedCount });
-          break;
-        }
-        case 'GET_PEER_COUNT': {
-          const peers = await ensureClient().getPeers();
-          await sendMessage({ type: 'PEER_COUNT', requestId, count: peers.length });
-          break;
-        }
-        case 'STOP': {
-          await stopClient();
-          await sendMessage({ type: 'STOPPED', requestId });
-          process.exit(0);
-          break;
-        }
-        default: {
-          const _exhaustive: never = msg;
-          throw new Error(`Unknown command: ${(msg as { type?: string }).type}`);
-        }
-      }
-    } catch (err: any) {
-      await sendMessage({ type: 'ERROR', requestId, error: err?.message ?? String(err) });
-      if (msg.type === 'START') {
-        process.exit(1);
-      }
-    }
-  })();
-});

package/src/client/test/tx_proposal_collector/proposal_tx_collector_worker_protocol.ts

@@ -1,43 +0,0 @@
-import { BlockProposal } from '@aztec/stdlib/p2p';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
-
-import type { P2PConfig } from '../../../config.js';
-
-export type SerializedP2PConfig = Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey?: string };
-
-export type CollectorType = 'batch-requester' | 'send-batch-request';
-
-export type WorkerCommand =
-  | { type: 'START'; requestId: string; clientIndex: number; config: SerializedP2PConfig }
-  | { type: 'SET_TXS'; requestId: string; txs: string[]; mode?: 'replace' | 'append' }
-  | { type: 'SET_BLOCK_PROPOSAL'; requestId: string; blockProposal: string }
-  | {
-      type: 'RUN_COLLECTOR';
-      requestId: string;
-      collectorType: CollectorType;
-      txHashes: string[];
-      blockProposal: string;
-      pinnedPeerId?: string;
-      peerIds: string[];
-      timeoutMs: number;
-    }
-  | { type: 'GET_PEER_COUNT'; requestId: string }
-  | { type: 'STOP'; requestId: string };
-
-export type WorkerResponse =
-  | { type: 'READY'; requestId: string; peerId: string }
-  | { type: 'TXS_SET'; requestId: string; count: number }
-  | { type: 'BLOCK_PROPOSAL_SET'; requestId: string; archiveRoot: string }
-  | { type: 'COLLECTOR_RESULT'; requestId: string; durationMs: number; fetchedCount: number }
-  | { type: 'PEER_COUNT'; requestId: string; count: number }
-  | { type: 'STOPPED'; requestId: string }
-  | { type: 'ERROR'; requestId: string; error: string };
-
-export const serializeTx = (tx: Tx) => tx.toBuffer().toString('hex');
-export const deserializeTx = (hex: string) => Tx.fromBuffer(Buffer.from(hex, 'hex'));
-
-export const serializeTxHash = (txHash: TxHash) => txHash.toString();
-export const deserializeTxHash = (hex: string) => TxHash.fromString(hex);
-
-export const serializeBlockProposal = (proposal: BlockProposal) => proposal.toBuffer().toString('hex');
-export const deserializeBlockProposal = (hex: string) => BlockProposal.fromBuffer(Buffer.from(hex, 'hex'));

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -1,320 +0,0 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
-import {
-  BlockProposal,
-  CheckpointAttestation,
-  CheckpointProposal,
-  type CheckpointProposalCore,
-} from '@aztec/stdlib/p2p';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
-import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
-import type { AttestationPool } from './attestation_pool.js';
-
-export const MAX_PROPOSALS_PER_SLOT = 5;
-export const ATTESTATION_CAP_BUFFER = 10;
-
-export class KvAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<CheckpointAttestation>;
-
-  private proposals: AztecAsyncMap<
-    /*  proposal.payload.archive  */ string,
-    /* buffer representation of proposal */ Buffer
-  >;
-
-  // Checkpoint attestation storage
-  private checkpointAttestations: AztecAsyncMap<string, Buffer>;
-  private checkpointProposals: AztecAsyncMap<string, Buffer>;
-  private checkpointProposalsForSlot: AztecAsyncMultiMap<number, string>;
-  private checkpointAttestationsForProposal: AztecAsyncMultiMap<string, string>;
-
-  constructor(
-    private store: AztecAsyncKVStore,
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('aztec:attestation_pool'),
-  ) {
-    this.proposals = store.openMap('proposals');
-
-    // Initialize checkpoint attestation storage
-    this.checkpointAttestations = store.openMap('checkpoint_attestations');
-    this.checkpointProposals = store.openMap('checkpoint_proposals');
-    this.checkpointProposalsForSlot = store.openMultiMap('checkpoint_proposals_for_slot');
-    this.checkpointAttestationsForProposal = store.openMultiMap('checkpoint_attestations_for_proposal');
-
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
-  }
-
-  private poolStats: PoolStatsCallback = async () => {
-    return {
-      itemCount: await this.checkpointAttestations.sizeAsync(),
-    };
-  };
-
-  public async isEmpty(): Promise<boolean> {
-    for await (const _ of this.checkpointAttestations.entriesAsync()) {
-      return false;
-    }
-    for await (const _ of this.proposals.entriesAsync()) {
-      return false;
-    }
-    return true;
-  }
-
-  private getProposalKey(slot: number | bigint | Fr | string, proposalId: Fr | string | Buffer): string {
-    const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
-    const proposalIdStr =
-      typeof proposalId === 'string'
-        ? proposalId
-        : Buffer.isBuffer(proposalId)
-          ? Fr.fromBuffer(proposalId).toString()
-          : proposalId.toString();
-
-    return `${slotStr}-${proposalIdStr}`;
-  }
-
-  private getAttestationKey(slot: number | bigint | Fr | string, proposalId: Fr | string, address: string): string {
-    return `${this.getProposalKey(slot, proposalId)}-${address}`;
-  }
-
-  public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      const proposalId = blockProposal.archive.toString();
-      // Strip signedTxs before storing to avoid persisting full tx data
-      await this.proposals.set(proposalId, blockProposal.withoutSignedTxs().toBuffer());
-    });
-  }
-
-  public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
-    const buffer = await this.proposals.getAsync(id);
-    try {
-      if (buffer && buffer.length > 0) {
-        return BlockProposal.fromBuffer(buffer);
-      }
-    } catch {
-      return Promise.resolve(undefined);
-    }
-
-    return Promise.resolve(undefined);
-  }
-
-  public async hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
-    return await this.proposals.hasAsync(id);
-  }
-
-  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()}`,
-      );
-    }
-
-    // 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()}`,
-      );
-    }
-
-    await this.store.transactionAsync(async () => {
-      const slotKey = proposal.slotNumber;
-      const proposalId = proposal.archive.toString();
-
-      await this.checkpointProposalsForSlot.set(slotKey, proposalId);
-      // Store the checkpoint proposal as core (without lastBlock) to avoid duplication
-      await this.checkpointProposals.set(proposalId, proposal.toCore().toBuffer());
-
-      // Store the extracted block proposal separately
-      if (blockProposal) {
-        await this.proposals.set(blockProposal.archive.toString(), blockProposal.withoutSignedTxs().toBuffer());
-      }
-    });
-  }
-
-  public async getCheckpointProposal(id: string): Promise<CheckpointProposalCore | undefined> {
-    const buffer = await this.checkpointProposals.getAsync(id);
-    try {
-      if (buffer && buffer.length > 0) {
-        return CheckpointProposal.fromBuffer(buffer);
-      }
-    } catch {
-      return Promise.resolve(undefined);
-    }
-
-    return Promise.resolve(undefined);
-  }
-
-  public async hasCheckpointProposal(idOrProposal: string | CheckpointProposal): Promise<boolean> {
-    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
-    return await this.checkpointProposals.hasAsync(id);
-  }
-
-  public async addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      for (const attestation of attestations) {
-        const slotNumber = attestation.payload.header.slotNumber;
-        const proposalId = attestation.archive;
-        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 address = sender.toString();
-
-        await this.checkpointAttestations.set(
-          this.getAttestationKey(slotNumber, proposalId, address),
-          attestation.toBuffer(),
-        );
-
-        await this.checkpointProposalsForSlot.set(slotNumber, proposalId.toString());
-        await this.checkpointAttestationsForProposal.set(
-          this.getProposalKey(slotNumber, proposalId),
-          this.getAttestationKey(slotNumber, proposalId, address),
-        );
-
-        this.log.verbose(`Added checkpoint attestation for slot ${slotNumber} from ${address}`, {
-          signature: attestation.signature.toString(),
-          slotNumber,
-          address,
-          proposalId,
-        });
-      }
-    });
-  }
-
-  public async getCheckpointAttestationsForSlot(slot: SlotNumber): Promise<CheckpointAttestation[]> {
-    const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
-    const attestations: CheckpointAttestation[] = [];
-
-    for (const proposalId of proposalIds) {
-      attestations.push(...(await this.getCheckpointAttestationsForSlotAndProposal(slot, proposalId)));
-    }
-
-    return attestations;
-  }
-
-  public async getCheckpointAttestationsForSlotAndProposal(
-    slot: SlotNumber,
-    proposalId: string,
-  ): Promise<CheckpointAttestation[]> {
-    const attestationIds = await toArray(
-      this.checkpointAttestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
-    );
-    const attestations: CheckpointAttestation[] = [];
-
-    for (const id of attestationIds) {
-      const buf = await this.checkpointAttestations.getAsync(id);
-
-      if (!buf) {
-        throw new Error('Checkpoint attestation not found ' + id);
-      }
-
-      const attestation = CheckpointAttestation.fromBuffer(buf);
-      attestations.push(attestation);
-    }
-
-    return attestations;
-  }
-
-  public async deleteCheckpointAttestationsOlderThan(oldestSlot: SlotNumber): Promise<void> {
-    const olderThan = await toArray(this.checkpointProposalsForSlot.keysAsync({ end: oldestSlot }));
-    for (const oldSlot of olderThan) {
-      await this.deleteCheckpointAttestationsForSlot(SlotNumber(oldSlot));
-    }
-  }
-
-  private async deleteCheckpointAttestationsForSlot(slot: SlotNumber): Promise<void> {
-    let numberOfAttestations = 0;
-    await this.store.transactionAsync(async () => {
-      const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
-      for (const proposalId of proposalIds) {
-        const attestations = await toArray(
-          this.checkpointAttestationsForProposal.getValuesAsync(this.getProposalKey(slot, proposalId)),
-        );
-
-        numberOfAttestations += attestations.length;
-        for (const attestation of attestations) {
-          await this.checkpointAttestations.delete(attestation);
-        }
-
-        await this.checkpointProposals.delete(proposalId);
-        await this.checkpointAttestationsForProposal.delete(this.getProposalKey(slot, proposalId));
-      }
-
-      await this.checkpointProposalsForSlot.delete(slot);
-
-      this.log.verbose(`Removed ${numberOfAttestations} checkpoint attestations for slot ${slot}`);
-    });
-  }
-
-  public async hasCheckpointAttestation(attestation: CheckpointAttestation): Promise<boolean> {
-    const slotNumber = attestation.payload.header.slotNumber;
-    const proposalId = attestation.archive;
-    const sender = attestation.getSender();
-
-    // Attestations with invalid signatures are never in the pool
-    if (!sender) {
-      return false;
-    }
-
-    const address = sender.toString();
-    const key = this.getAttestationKey(slotNumber, proposalId, address);
-
-    return await this.checkpointAttestations.hasAsync(key);
-  }
-
-  public canAddProposal(_block: BlockProposal): Promise<boolean> {
-    // TODO(palla/mbps): implement proposal cap logic
-    return Promise.resolve(true);
-  }
-
-  public async canAddCheckpointProposal(proposal: CheckpointProposal): Promise<boolean> {
-    // TODO(palla/mbps): Adjust checkpoint proposal limit to 1. Also connect to slashing condition in the caller.
-    return (
-      (await this.checkpointProposals.hasAsync(proposal.archive.toString())) ||
-      !(await this.hasReachedCheckpointProposalCap(proposal.slotNumber))
-    );
-  }
-
-  public async canAddCheckpointAttestation(
-    attestation: CheckpointAttestation,
-    committeeSize: number,
-  ): Promise<boolean> {
-    return (
-      (await this.hasCheckpointAttestation(attestation)) ||
-      !(await this.hasReachedCheckpointAttestationCap(
-        attestation.payload.header.slotNumber,
-        attestation.archive.toString(),
-        committeeSize,
-      ))
-    );
-  }
-
-  public async hasReachedCheckpointProposalCap(slot: SlotNumber): Promise<boolean> {
-    const uniqueProposalCount = await this.checkpointProposalsForSlot.getValueCountAsync(slot);
-    return uniqueProposalCount >= MAX_PROPOSALS_PER_SLOT;
-  }
-
-  public async hasReachedCheckpointAttestationCap(
-    slot: SlotNumber,
-    proposalId: string,
-    committeeSize: number,
-  ): Promise<boolean> {
-    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
-    return (
-      (await this.checkpointAttestationsForProposal.getValueCountAsync(this.getProposalKey(slot, proposalId))) >= limit
-    );
-  }
-}