@aztec/p2p 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4d9804df

package/dest/services/tx_collection/slow_tx_collection.js

@@ -1,206 +0,0 @@
-import { EpochNumber } from '@aztec/foundation/branded-types';
-import { chunk } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { boundInclusive } from '@aztec/foundation/number';
-import { RunningPromise } from '@aztec/foundation/promise';
-import { DateProvider } from '@aztec/foundation/timer';
-import { getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { TxHash } from '@aztec/stdlib/tx';
-import { ReqRespSubProtocol } from '../reqresp/interface.js';
-import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
-export class SlowTxCollection {
-    reqResp;
-    nodes;
-    txCollectionSink;
-    fastCollection;
-    constants;
-    config;
-    dateProvider;
-    log;
-    /** Map from tx hash to missing tx info to collect via slow loop */ missingTxs;
-    /** One slow collection loop for each node tx source we have */ nodesSlowCollectionLoops;
-    /** Slow collection loop for reqresp which collects txs from peers */ reqrespSlowCollectionLoop;
-    constructor(reqResp, nodes, txCollectionSink, fastCollection, constants, config, dateProvider = new DateProvider(), log = createLogger('p2p:tx_collection_service')){
-        this.reqResp = reqResp;
-        this.nodes = nodes;
-        this.txCollectionSink = txCollectionSink;
-        this.fastCollection = fastCollection;
-        this.constants = constants;
-        this.config = config;
-        this.dateProvider = dateProvider;
-        this.log = log;
-        this.missingTxs = new Map();
-        this.nodesSlowCollectionLoops = this.nodes.map((node)=>new RunningPromise(()=>this.collectMissingTxsFromNode(node), this.log, this.config.txCollectionSlowNodesIntervalMs));
-        this.reqrespSlowCollectionLoop = new RunningPromise(()=>this.collectMissingTxsViaReqResp(), this.log, this.config.txCollectionSlowReqRespIntervalMs);
-    }
-    getMissingTxHashes() {
-        return Array.from(this.missingTxs.keys()).map(TxHash.fromString);
-    }
-    start() {
-        this.nodesSlowCollectionLoops.forEach((loop)=>loop.start());
-        this.reqrespSlowCollectionLoop.start();
-    }
-    async stop() {
-        await Promise.all([
-            this.reqrespSlowCollectionLoop.stop(),
-            ...this.nodesSlowCollectionLoops.map((loop)=>loop.stop())
-        ]);
-    }
-    async trigger() {
-        await Promise.all([
-            this.reqrespSlowCollectionLoop.trigger(),
-            ...this.nodesSlowCollectionLoops.map((loop)=>loop.trigger())
-        ]);
-    }
-    /** Starts collecting the given tx hashes for the given L2Block in the slow loop */ startCollecting(block, txHashes) {
-        const slot = block.header.getSlot();
-        const deadline = this.getDeadlineForSlot(slot);
-        if (+deadline < this.dateProvider.now()) {
-            this.log.debug(`Skipping collection of txs for block ${block.number} at slot ${slot} as it is already expired`, {
-                blockNumber: block.number,
-                slot: slot.toString(),
-                txHashes: txHashes.map((txHash)=>txHash.toString()),
-                deadline: +deadline,
-                now: this.dateProvider.now()
-            });
-        }
-        for (const txHash of txHashes){
-            this.missingTxs.set(txHash.toString(), {
-                block,
-                blockNumber: block.number,
-                deadline: this.getDeadlineForSlot(block.header.getSlot()),
-                readyForReqResp: this.nodes.length === 0
-            });
-        }
-    }
-    /** Entrypoint for the node slow collection loop */ async collectMissingTxsFromNode(node) {
-        // If we have any fast requests, we skip the slow collection for this node if configured to do so
-        const requests = this.fastCollection.getFastCollectionRequests();
-        if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
-            this.log.trace(`Skipping node slow collection due to active fast requests`);
-            return;
-        }
-        // Gather all missing txs that are not in fast collection and request them from the node
-        const missingTxs = this.getMissingTxsForSlowCollection();
-        if (missingTxs.length === 0) {
-            return;
-        }
-        // Group by block so we pass the correct mined context to the sink
-        for (const entries of this.groupByBlock(missingTxs)){
-            const block = entries[0][1].block;
-            const txHashes = entries.map(([txHash])=>TxHash.fromString(txHash));
-            for (const batch of chunk(txHashes, this.config.txCollectionNodeRpcMaxBatchSize)){
-                await this.txCollectionSink.collect((hashes)=>node.getTxsByHash(hashes), batch, {
-                    description: `node ${node.getInfo()}`,
-                    node: node.getInfo(),
-                    method: 'slow-node-rpc'
-                }, {
-                    type: 'mined',
-                    block
-                });
-            }
-        }
-        // Mark every tx that is still missing as ready for reqresp.
-        // Note that we can just mark all requested txs as ready for reqresp, without filtering out the ones
-        // we retrieved, since the ones already found will have been removed from `missingTxs`.
-        missingTxs.forEach(([_txHash, info])=>{
-            info.readyForReqResp = true;
-        });
-    }
-    /** Entrypoint for the reqresp slow collection loop */ async collectMissingTxsViaReqResp() {
-        // If we have any fast requests, we skip the slow collection if configured to do so
-        const requests = this.fastCollection.getFastCollectionRequests();
-        if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
-            this.log.trace(`Skipping reqresp slow collection due to active fast requests`);
-            return;
-        }
-        // Gather all missing txs that are not in fast collection and are ready for reqresp
-        // A tx is flagged as ready for reqresp if it has been requested from a node at least once
-        const missingTxs = this.getMissingTxsForSlowCollection({
-            onlyReqRespReady: true
-        });
-        if (missingTxs.length === 0) {
-            return;
-        }
-        const pinnedPeer = undefined;
-        const timeoutMs = this.config.txCollectionSlowReqRespTimeoutMs;
-        const maxRetryAttempts = 3;
-        // Group by block so we pass the correct mined context to the sink
-        for (const entries of this.groupByBlock(missingTxs)){
-            const block = entries[0][1].block;
-            const txHashes = entries.map(([txHash])=>TxHash.fromString(txHash));
-            const maxPeers = boundInclusive(Math.ceil(txHashes.length / 3), 4, 16);
-            await this.txCollectionSink.collect(async (hashes)=>{
-                const txs = await this.reqResp.sendBatchRequest(ReqRespSubProtocol.TX, chunkTxHashesRequest(hashes), pinnedPeer, timeoutMs, maxPeers, maxRetryAttempts);
-                return txs.flat();
-            }, txHashes, {
-                description: 'slow reqresp',
-                timeoutMs,
-                method: 'slow-req-resp'
-            }, {
-                type: 'mined',
-                block
-            });
-        }
-    }
-    /** Retrieves all missing txs for the slow collection process. This is, all missing txs that are not part of a fast request. */ getMissingTxsForSlowCollection(opts = {}) {
-        // Remove expired txs from missingTxs
-        const now = this.dateProvider.now();
-        const expiredTxs = Array.from(this.missingTxs.entries()).filter(([_, value])=>+value.deadline < now);
-        expiredTxs.forEach(([txHash])=>this.missingTxs.delete(txHash));
-        // Gather all txs that are marked for fast collection, we do not want to collect them via slow collection.
-        // There are some situations where a tx is in both slow and fast collection, for example when a prover node
-        // is fast-collecting missing txs for proving an epoch, and still has the tx in the slow collection loops
-        // from mined unproven blocks it has seen in the past.
-        const fastRequests = this.fastCollection.getFastCollectionRequests();
-        const fastCollectionTxs = new Set(...Array.from(fastRequests.values()).flatMap((r)=>r.missingTxHashes));
-        // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested
-        return Array.from(this.missingTxs.entries()).filter(([txHash, _])=>!fastCollectionTxs.has(txHash)).filter(([_, value])=>!opts.onlyReqRespReady || value.readyForReqResp);
-    }
-    /** Stop collecting the given txs since we have found them. Called whenever tx pool emits a tx-added event. */ foundTxs(txs) {
-        for (const txHash of txs.map((tx)=>tx.txHash)){
-            this.missingTxs.delete(txHash.toString());
-        }
-    }
-    /**
-   * Stop collecting all txs for blocks less than or requal to the block number specified.
-   * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
-   */ stopCollectingForBlocksUpTo(blockNumber) {
-        for (const [txHash, info] of this.missingTxs.entries()){
-            if (info.blockNumber <= blockNumber) {
-                this.missingTxs.delete(txHash);
-            }
-        }
-    }
-    /**
-   * Stop collecting all txs for blocks greater than the block number specified.
-   * To be called when there is a chain prune and previously mined txs are no longer relevant.
-   */ stopCollectingForBlocksAfter(blockNumber) {
-        for (const [txHash, info] of this.missingTxs.entries()){
-            if (info.blockNumber > blockNumber) {
-                this.missingTxs.delete(txHash);
-            }
-        }
-    }
-    /** Groups missing tx entries by block number. */ groupByBlock(entries) {
-        const groups = new Map();
-        for (const entry of entries){
-            const bn = +entry[1].blockNumber;
-            let group = groups.get(bn);
-            if (!group) {
-                group = [];
-                groups.set(bn, group);
-            }
-            group.push(entry);
-        }
-        return [
-            ...groups.values()
-        ];
-    }
-    /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */ getDeadlineForSlot(slotNumber) {
-        const epoch = getEpochAtSlot(slotNumber, this.constants);
-        const submissionEndEpoch = EpochNumber(epoch + this.constants.proofSubmissionEpochs);
-        const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, this.constants)[1];
-        return new Date(Number(submissionEndTimestamp) * 1000);
-    }
-}

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}`, true, BENCHMARK_CONSTANTS.KV_STORE_MAP_SIZE_KB);
-  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.tryAddBlockProposal(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'));