@aztec/p2p 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/src/client/test/tx_proposal_collector/README.md

@@ -0,0 +1,227 @@
+# ProposalTxCollector Benchmarks
+
+This benchmark suite measures **how quickly a proposer node can fetch missing transactions from P2P peers** when building a block proposal. It compares two alternative transaction-collection implementations under several controlled "who-has-which-txs" distributions.
+
+## Purpose
+
+When proposing a block, the node may have a block proposal containing a list of `txHashes`, but may be **missing the full `Tx` objects** locally. The node must fetch those missing txs from peers via the P2P req/resp layer.
+
+This benchmark answers:
+
+- How long does it take to fetch **N missing txs** (N ∈ **{10, 50, 100, 500}**)?
+- How do different **peer availability patterns** affect performance?
+- Which collector strategy performs better under each pattern?
+
+The suite compares two collectors:
+
+- **`BatchTxRequesterCollector`** (collector type: `batch-requester`)
+- **`SendBatchRequestCollector`** (collector type: `send-batch-request`)
+
+## Architecture
+
+The benchmark runs a small simulated network on localhost:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        Test Process (Driver)                        │
+│   p2p_client.proposal_tx_collector.bench.test.ts                    │
+│   ┌─────────────────────────────────────────────────────────────┐   │
+│   │            WorkerClientManager                              │   │
+│   │         (src/testbench/worker_client_manager.ts)            │   │
+│   └─────────────────────────────────────────────────────────────┘   │
+│                              │ IPC                                  │
+│         ┌────────────────────┼────────────────────┐                 │
+│         ▼                    ▼                    ▼                 │
+│   ┌───────────┐        ┌───────────┐        ┌───────────┐           │
+│   │ Worker 0  │◄──────►│ Worker 1  │◄──────►│ Worker N-1│           │
+│   │ (Collector│  P2P   │(Responder)│  P2P   │(Responder)│           │
+│   │  Node)    │        │           │        │           │           │
+│   │ TxPool:[] │        │ TxPool:   │        │ TxPool:   │           │
+│   │           │        │ [txs...]  │        │ [txs...]  │           │
+│   └───────────┘        └───────────┘        └───────────┘           │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+- **N worker processes** are spawned using Node's **`child_process.fork()`**
+- Each worker runs a "light" **`P2PClient.Full`** node (enough to exercise the real P2P req/resp machinery)
+- Workers communicate with the test process via **IPC messages** defined in `p2p_client_testbench_worker.ts`
+
+### Why multiple processes?
+
+Using separate OS processes makes the setup closer to real networking behavior (independent event loops, scheduling, IPC boundaries), and avoids many artifacts you'd get by running everything in one process.
+
+### Worker roles
+
+The network is intentionally asymmetric:
+
+- **Worker 0 is the collector/proposer node**
+  - Starts with an **empty tx pool** (`[]`)
+  - Is the only worker instructed to run the collector for each `BENCH_REQRESP` command
+- **Workers 1..N-1 are responder peers**
+  - Locally generate and filter txs according to the distribution pattern
+  - Respond to req/resp queries made by Worker 0's collector
+
+This models a proposer that has only `txHashes` in a proposal and must fetch the full tx bodies from the network.
+
+## Transaction Distribution Patterns
+
+Each benchmark case generates `missingTxCount` mock txs and assigns them to peers using one of these patterns:
+
+### `uniform`
+
+**Every responder peer has every transaction.**
+
+- Simulates the best-case: high replication / high gossip success
+- Expectation: collector should quickly succeed; differences mostly reflect collector overhead and batching strategy
+
+### `sparse`
+
+**Each transaction exists on only a small subset of peers.**
+
+Each responder is bucketed and holds txs whose index falls into its bucket or the "next" bucket (striped by tx index).
+
+- Simulates partial propagation, churn, or uneven mempool convergence
+- Expectation: collector must query multiple peers and cope with "misses"
+
+### `pinned-only`
+
+**Only a single "pinned" peer has the transactions; all other peers have none.**
+
+- Simulates "I know exactly who has the txs" (or a topology where one peer is the source of truth)
+- Useful to test whether "pinned peer" fast-paths work as intended
+
+> **Guardrail:** the pinned peer index must be within `(0, numberOfPeers)` (Worker 0 cannot be pinned).
+
+## Collectors Under Test
+
+### `BatchTxRequesterCollector` (`batch-requester`)
+
+```typescript
+new BatchTxRequesterCollector(p2pService, logger, new DateProvider())
+```
+
+Uses the P2P service plus internal logic to fetch missing txs, coordinating requests in a batched or staged way.
+
+### `SendBatchRequestCollector` (`send-batch-request`)
+
+```typescript
+const maxPeers = 10;
+const maxRetryAttempts = Math.max(peerIds.length, 3);
+new SendBatchRequestCollector(p2pService, maxPeers, maxRetryAttempts)
+```
+
+Explicitly caps the number of peers it will involve (`maxPeers`) and uses a retry budget derived from peer count.
+
+## Test Parameters
+
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| `PEERS_PER_RUN` | 30 | Number of worker processes spawned |
+| `MISSING_TX_COUNTS` | 10, 50, 100, 500 | Number of missing transactions to fetch |
+| `TIMEOUT_MS` | 30,000 ms | Collector timeout per case |
+| `TEST_TIMEOUT_MS` | 600,000 ms | Overall Jest timeout (10 minutes) |
+
+## Running
+
+From the p2p package:
+
+```bash
+cd yarn-project/p2p
+yarn test src/client/test/tx_proposal_collector/p2p_client.proposal_tx_collector.bench.test.ts
+```
+
+Or from repo root:
+
+```bash
+yarn test p2p_client.proposal_tx_collector.bench.test.ts
+```
+
+The benchmark is intentionally long due to spawning many processes and running multiple cases.
+
+## Output Formats
+
+### Default: Markdown table to stdout
+
+If no env vars are set, the suite prints a table:
+
+```
+| Collector           | Distribution | Missing | Duration (ms) | Fetched | Success |
+|---------------------|--------------|---------|---------------|---------|---------|
+| batch-requester     | pinned-only  |      10 |           123 |      10 |   Yes   |
+| send-batch-request  | pinned-only  |      10 |           145 |      10 |   Yes   |
+```
+
+Plus a comparison summary stating which collector was faster per `(distribution, missing)` pair.
+
+### JSON metrics (for CI/dashboards)
+
+```bash
+BENCH_OUTPUT=/path/results.json yarn test ...
+```
+
+Writes JSON metrics like:
+- `ProposalTxCollector/<collector>/<distribution>/missing_<N>/duration` (ms)
+- `ProposalTxCollector/<collector>/<distribution>/missing_<N>/fetched` (txs)
+
+### Markdown file output
+
+```bash
+BENCH_OUTPUT_MD=/path/results.md yarn test ...
+```
+
+Writes the pretty table + summary to disk.
+
+## Interpreting Results
+
+For each case the benchmark records:
+
+- `durationMs`: wall-clock time spent inside the collector call
+- `fetchedCount`: how many txs were returned by the collector
+- `success`: `fetchedCount === missingTxCount`
+
+**Guidelines:**
+
+- **Always check `Success` first.** A faster run that fetched fewer txs is not a win.
+- Compare collectors **within the same distribution + missing count** only.
+- Expect `pinned-only` to highlight pinned-peer behavior (fast if pinned peer is used effectively; slow if the algorithm wastes time sampling other peers).
+- Expect `sparse` to be the most "network-like" stress case, since many peers won't have each requested tx.
+
+## Determinism / Noise Reduction
+
+Inside each worker, the benchmark intentionally reduces variability:
+
+- **Unlimited rate limits** are installed so the req/resp rate limiter doesn't dominate results
+- **Deterministic tx generation** ensures all workers see the same tx set without large IPC payloads
+
+This makes the benchmark better for *comparing collectors* (A vs B), but it is **not** a perfect model of production networking conditions.
+
+## Limitations
+
+This benchmark does **not** measure:
+
+- Real internet latency, NAT traversal, or adversarial peers (everything runs on localhost)
+- End-to-end proposer behavior beyond tx fetching (block construction, proving, etc.)
+- Gossip-based mempool convergence—tx availability is injected directly into each worker's in-memory tx pool
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `p2p_client.proposal_tx_collector.bench.test.ts` | Test suite (cases, distributions, output formatting) |
+| `proposal_tx_collector_worker.ts` | Collector-specific worker implementation |
+| `proposal_tx_collector_worker_protocol.ts` | IPC message types and serialization |
+| `src/testbench/worker_client_manager.ts` | Worker process manager (forking, IPC, orchestration) |
+| `src/testbench/p2p_client_testbench_worker.ts` | General testbench worker implementation |
+| `src/test-helpers/testbench-utils.ts` | Shared mocks and utilities (InMemoryTxPool, InMemoryAttestationPool, etc.) |
+
+## Implementation Notes
+
+- Workers run TypeScript via `ts-node/esm` unless a compiled JS worker exists at `dest/testbench/p2p_client_testbench_worker.js`
+- Request/response rate limits are overridden so the benchmark is not throttled
+- Workers generate txs locally from a shared seed to avoid sending large tx payloads over IPC
+
+## Practical Tips
+
+- Run on an otherwise idle machine; CPU scheduling noise matters when spawning 30 node processes
+- If you see intermittent failures, increase `TIMEOUT_MS` or reduce `PEERS_PER_RUN` for local iteration
+- Use `BENCH_OUTPUT` in CI to track performance regressions over time

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

@@ -0,0 +1,346 @@
+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 { BatchTxRequesterCollector, SendBatchRequestCollector } from '../../../services/index.js';
+import type { IBatchRequestTxValidator } from '../../../services/reqresp/batch-tx-requester/tx_validator.js';
+import { RateLimitStatus } from '../../../services/reqresp/rate-limiter/rate_limiter.js';
+import { MissingTxsTracker } from '../../../services/tx_collection/missing_txs_tracker.js';
+import {
+  AlwaysTrueCircuitVerifier,
+  BENCHMARK_CONSTANTS,
+  InMemoryAttestationPool,
+  InMemoryTxPool,
+  UNLIMITED_RATE_LIMIT_QUOTA,
+  calculateInternalTimeout,
+  createMockEpochCache,
+  createMockWorldStateSynchronizer,
+} from '../../../test-helpers/index.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(
+            MissingTxsTracker.fromArray(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(
+            MissingTxsTracker.fromArray(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

@@ -0,0 +1,43 @@
+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'));