@aztec/p2p 0.55.1 → 0.57.0

package/dest/tx_validator/metadata_validator.js

@@ -25,6 +25,9 @@ export class MetadataTxValidator {
         }
         return Promise.resolve([validTxs, invalidTxs]);
     }
+    validateTx(tx) {
+        return Promise.resolve(__classPrivateFieldGet(this, _MetadataTxValidator_instances, "m", _MetadataTxValidator_hasCorrectChainId).call(this, tx) && __classPrivateFieldGet(this, _MetadataTxValidator_instances, "m", _MetadataTxValidator_isValidForBlockNumber).call(this, tx));
+    }
 }
 _MetadataTxValidator_log = new WeakMap(), _MetadataTxValidator_instances = new WeakSet(), _MetadataTxValidator_hasCorrectChainId = function _MetadataTxValidator_hasCorrectChainId(tx) {
     if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
@@ -47,4 +50,4 @@ _MetadataTxValidator_log = new WeakMap(), _MetadataTxValidator_instances = new W
         return true;
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.55.1",
+  "version": "0.57.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -37,6 +37,9 @@
             "parser": {
               "syntax": "typescript",
               "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
             }
           }
         }
@@ -56,11 +59,11 @@
     "testTimeout": 15000
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.55.1",
-    "@aztec/circuits.js": "0.55.1",
-    "@aztec/foundation": "0.55.1",
-    "@aztec/kv-store": "0.55.1",
-    "@aztec/telemetry-client": "0.55.1",
+    "@aztec/circuit-types": "0.57.0",
+    "@aztec/circuits.js": "0.57.0",
+    "@aztec/foundation": "0.57.0",
+    "@aztec/kv-store": "0.57.0",
+    "@aztec/telemetry-client": "0.57.0",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
@@ -86,6 +89,7 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
+    "@aztec/archiver": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.14.6",

package/src/attestation_pool/attestation_pool.ts

@@ -36,7 +36,8 @@ export interface AttestationPool {
    * Retrieve all of the attestations observed pertaining to a given slot
    *
    * @param slot - The slot to query
+   * @param proposalId - The proposal to query
    * @return BlockAttestations
    */
-  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+  getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
 }

package/src/attestation_pool/memory_attestation_pool.ts

@@ -4,33 +4,38 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { type AttestationPool } from './attestation_pool.js';
 
 export class InMemoryAttestationPool implements AttestationPool {
-  private attestations: Map</*slot=*/ bigint, Map</*address=*/ string, BlockAttestation>>;
+  private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
 
   constructor(private log = createDebugLogger('aztec:attestation_pool')) {
     this.attestations = new Map();
   }
 
-  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
+  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
     const slotAttestationMap = this.attestations.get(slot);
     if (slotAttestationMap) {
-      return Promise.resolve(Array.from(slotAttestationMap.values()));
-    } else {
-      return Promise.resolve([]);
+      const proposalAttestationMap = slotAttestationMap.get(proposalId);
+      if (proposalAttestationMap) {
+        return Promise.resolve(Array.from(proposalAttestationMap.values()));
+      }
     }
+    return Promise.resolve([]);
   }
 
-  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public addAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       // Perf: order and group by slot before insertion
-      const slotNumber = attestation.header.globalVariables.slotNumber;
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
 
-      const address = await attestation.getSender();
+      const proposalId = attestation.p2pMessageIdentifier().toString();
+      const address = attestation.getSender();
 
       const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
-      slotAttestationMap.set(address.toString(), attestation);
+      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
+      proposalAttestationMap.set(address.toString(), attestation);
 
       this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
     }
+    return Promise.resolve();
   }
 
   public deleteAttestationsForSlot(slot: bigint): Promise<void> {
@@ -40,14 +45,27 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+    const slotAttestationMap = this.attestations.get(slot);
+    if (slotAttestationMap) {
+      slotAttestationMap.delete(proposalId);
+      this.log.verbose(`Removed attestation for slot ${slot}`);
+    }
+    return Promise.resolve();
+  }
+
+  public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
-      const slotNumber = attestation.header.globalVariables.slotNumber;
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
       const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
       if (slotAttestationMap) {
-        const address = await attestation.getSender();
-        slotAttestationMap.delete(address.toString());
-        this.log.verbose(`Deleted attestation for slot ${slotNumber} from ${address}`);
+        const proposalId = attestation.p2pMessageIdentifier().toString();
+        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
+        if (proposalAttestationMap) {
+          const address = attestation.getSender();
+          proposalAttestationMap.delete(address.toString());
+          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+        }
       }
     }
     return Promise.resolve();
@@ -58,13 +76,34 @@ export class InMemoryAttestationPool implements AttestationPool {
  * 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, BlockAttestation>>,
+  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
   slot: bigint,
-): Map<string, BlockAttestation> {
+): Map<string, Map<string, BlockAttestation>> {
   if (!map.has(slot)) {
-    map.set(slot, new Map<string, BlockAttestation>());
+    map.set(slot, new Map<string, Map<string, BlockAttestation>>());
   }
   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>>,
+  proposalId: string,
+): Map<string, BlockAttestation> {
+  if (!map.has(proposalId)) {
+    map.set(proposalId, new Map<string, BlockAttestation>());
+  }
+  return map.get(proposalId)!;
+}

package/src/attestation_pool/mocks.ts

@@ -1,7 +1,7 @@
-import { BlockAttestation, Signature, TxHash } from '@aztec/circuit-types';
+import { BlockAttestation, ConsensusPayload, TxHash } from '@aztec/circuit-types';
 import { makeHeader } from '@aztec/circuits.js/testing';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
-import { serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { type PrivateKeyAccount } from 'viem';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
@@ -22,15 +22,20 @@ export const generateAccount = () => {
  * @param slot The slot number the attestation is for
  * @returns A Block Attestation
  */
-export const mockAttestation = async (signer: PrivateKeyAccount, slot: number = 0): Promise<BlockAttestation> => {
+export const mockAttestation = async (
+  signer: PrivateKeyAccount,
+  slot: number = 0,
+  archive: Fr = Fr.random(),
+): Promise<BlockAttestation> => {
   // Use arbitrary numbers for all other than slot
   const header = makeHeader(1, 2, slot);
-  const archive = Fr.random();
   const txs = [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
 
-  const message: `0x${string}` = `0x${serializeToBuffer([archive, txs]).toString('hex')}`;
+  const payload = new ConsensusPayload(header, archive, txs);
+
+  const message: `0x${string}` = `0x${payload.getPayloadToSign().toString('hex')}`;
   const sigString = await signer.signMessage({ message });
 
   const signature = Signature.from0xString(sigString);
-  return new BlockAttestation(header, archive, txs, signature);
+  return new BlockAttestation(payload, signature);
 };

package/src/client/index.ts

@@ -6,8 +6,11 @@ import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { type AttestationPool } from '../attestation_pool/attestation_pool.js';
+import { InMemoryAttestationPool } from '../attestation_pool/memory_attestation_pool.js';
 import { P2PClient } from '../client/p2p_client.js';
 import { type P2PConfig } from '../config.js';
+import { type EpochProofQuotePool } from '../epoch_proof_quote_pool/epoch_proof_quote_pool.js';
+import { MemoryEpochProofQuotePool } from '../epoch_proof_quote_pool/memory_epoch_proof_quote_pool.js';
 import { DiscV5Service } from '../service/discV5_service.js';
 import { DummyP2PService } from '../service/dummy_service.js';
 import { LibP2PService, createLibP2PPeerId } from '../service/index.js';
@@ -18,16 +21,22 @@ export * from './p2p_client.js';
 
 export const createP2PClient = async (
   _config: P2PConfig & DataStoreConfig,
-  attestationsPool: AttestationPool,
   l2BlockSource: L2BlockSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
-  deps: { txPool?: TxPool; store?: AztecKVStore } = {},
+  deps: {
+    txPool?: TxPool;
+    store?: AztecKVStore;
+    attestationsPool?: AttestationPool;
+    epochProofQuotePool?: EpochProofQuotePool;
+  } = {},
 ) => {
   let config = { ..._config };
   const store = deps.store ?? (await createStore('p2p', config, createDebugLogger('aztec:p2p:lmdb')));
   const txPool = deps.txPool ?? new AztecKVTxPool(store, telemetry);
+  const attestationsPool = deps.attestationsPool ?? new InMemoryAttestationPool();
+  const epochProofQuotePool = deps.epochProofQuotePool ?? new MemoryEpochProofQuotePool();
 
   let p2pService;
 
@@ -52,7 +61,15 @@ export const createP2PClient = async (
   } else {
     p2pService = new DummyP2PService();
   }
-  return new P2PClient(store, l2BlockSource, txPool, attestationsPool, p2pService, config.keepProvenTxsInPoolFor);
+  return new P2PClient(
+    store,
+    l2BlockSource,
+    txPool,
+    attestationsPool,
+    epochProofQuotePool,
+    p2pService,
+    config.keepProvenTxsInPoolFor,
+  );
 };
 
 async function configureP2PClientAddresses(_config: P2PConfig & DataStoreConfig): Promise<P2PConfig & DataStoreConfig> {

package/src/client/p2p_client.ts

@@ -1,6 +1,7 @@
 import {
   type BlockAttestation,
   type BlockProposal,
+  type EpochProofQuote,
   type L2Block,
   L2BlockDownloader,
   type L2BlockSource,
@@ -15,6 +16,7 @@ import { type ENR } from '@chainsafe/enr';
 
 import { type AttestationPool } from '../attestation_pool/attestation_pool.js';
 import { getP2PConfigEnvVars } from '../config.js';
+import { type EpochProofQuotePool } from '../epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { TX_REQ_PROTOCOL } from '../service/reqresp/interface.js';
 import type { P2PService } from '../service/service.js';
 import { type TxPool } from '../tx_pool/index.js';
@@ -58,9 +60,25 @@ export interface P2P {
    * Queries the Attestation pool for attestations for the given slot
    *
    * @param slot - the slot to query
+   * @param proposalId - the proposal id to query
    * @returns BlockAttestations
    */
-  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+  getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+
+  /**
+   * Queries the EpochProofQuote pool for quotes for the given epoch
+   *
+   * @param epoch  - the epoch to query
+   * @returns EpochProofQuotes
+   */
+  getEpochProofQuotes(epoch: bigint): Promise<EpochProofQuote[]>;
+
+  /**
+   * Broadcasts an EpochProofQuote to other peers.
+   *
+   * @param quote - the quote to broadcast
+   */
+  broadcastEpochProofQuote(quote: EpochProofQuote): void;
 
   /**
    * Registers a callback from the validator client that determines how to behave when
@@ -134,7 +152,7 @@ export interface P2P {
    * Indicates if the p2p client is ready for transaction submission.
    * @returns A boolean flag indicating readiness.
    */
-  isReady(): Promise<boolean>;
+  isReady(): boolean;
 
   /**
    * Returns the current status of the p2p client.
@@ -186,6 +204,7 @@ export class P2PClient implements P2P {
     private l2BlockSource: L2BlockSource,
     private txPool: TxPool,
     private attestationPool: AttestationPool,
+    private epochProofQuotePool: EpochProofQuotePool,
     private p2pService: P2PService,
     private keepProvenTxsFor: number,
     private log = createDebugLogger('aztec:p2p'),
@@ -202,6 +221,22 @@ export class P2PClient implements P2P {
     this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
   }
 
+  #assertIsReady() {
+    if (!this.isReady()) {
+      throw new Error('P2P client not ready');
+    }
+  }
+
+  getEpochProofQuotes(epoch: bigint): Promise<EpochProofQuote[]> {
+    return Promise.resolve(this.epochProofQuotePool.getQuotes(epoch));
+  }
+
+  broadcastEpochProofQuote(quote: EpochProofQuote): void {
+    this.#assertIsReady();
+    this.epochProofQuotePool.addQuote(quote);
+    return this.p2pService.propagate(quote);
+  }
+
   /**
    * Starts the P2P client.
    * @returns An empty promise signalling the synching process.
@@ -281,8 +316,8 @@ export class P2PClient implements P2P {
     return this.p2pService.propagate(proposal);
   }
 
-  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
-    return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot));
+  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot, proposalId));
   }
 
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
@@ -319,8 +354,6 @@ export class P2PClient implements P2P {
 
     this.log.debug(`Requested ${txHash.toString()} from peer | success = ${!!tx}`);
     if (tx) {
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8485): This check is not sufficient to validate the transaction. We need to validate the entire proof.
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8483): alter peer scoring system for a validator that returns an invalid transcation
       await this.txPool.addTxs([tx]);
     }
 
@@ -365,10 +398,7 @@ export class P2PClient implements P2P {
    * @returns Empty promise.
    **/
   public async sendTx(tx: Tx): Promise<void> {
-    const ready = await this.isReady();
-    if (!ready) {
-      throw new Error('P2P client not ready');
-    }
+    this.#assertIsReady();
     await this.txPool.addTxs([tx]);
     this.p2pService.propagate(tx);
   }
@@ -393,10 +423,7 @@ export class P2PClient implements P2P {
    * @returns Empty promise.
    **/
   public async deleteTxs(txHashes: TxHash[]): Promise<void> {
-    const ready = await this.isReady();
-    if (!ready) {
-      throw new Error('P2P client not ready');
-    }
+    this.#assertIsReady();
     await this.txPool.deleteTxs(txHashes);
   }
 
@@ -405,7 +432,7 @@ export class P2PClient implements P2P {
    * @returns True if the P2P client is ready to receive txs.
    */
   public isReady() {
-    return Promise.resolve(this.currentState === P2PClientState.RUNNING);
+    return this.currentState === P2PClientState.RUNNING;
   }
 
   /**
@@ -501,6 +528,10 @@ export class P2PClient implements P2P {
 
     await this.synchedProvenBlockNumber.set(lastBlockNum);
     this.log.debug(`Synched to proven block ${lastBlockNum}`);
+    const provenEpochNumber = await this.l2BlockSource.getProvenL2EpochNumber();
+    if (provenEpochNumber !== undefined) {
+      this.epochProofQuotePool.deleteQuotesToEpoch(BigInt(provenEpochNumber));
+    }
     await this.startServiceIfSynched();
   }
 

package/src/epoch_proof_quote_pool/epoch_proof_quote_pool.ts

@@ -0,0 +1,7 @@
+import { type EpochProofQuote } from '@aztec/circuit-types';
+
+export interface EpochProofQuotePool {
+  addQuote(quote: EpochProofQuote): void;
+  getQuotes(epoch: bigint): EpochProofQuote[];
+  deleteQuotesToEpoch(epoch: bigint): void;
+}

package/src/epoch_proof_quote_pool/index.ts

@@ -0,0 +1,3 @@
+export * from './epoch_proof_quote_pool.js';
+export * from './memory_epoch_proof_quote_pool.js';
+export * from './test_utils.js';

package/src/epoch_proof_quote_pool/memory_epoch_proof_quote_pool.ts

@@ -0,0 +1,26 @@
+import { type EpochProofQuote } from '@aztec/circuit-types';
+
+import { type EpochProofQuotePool } from './epoch_proof_quote_pool.js';
+
+export class MemoryEpochProofQuotePool implements EpochProofQuotePool {
+  private quotes: Map<bigint, EpochProofQuote[]>;
+  constructor() {
+    this.quotes = new Map();
+  }
+  addQuote(quote: EpochProofQuote) {
+    const epoch = quote.payload.epochToProve;
+    if (!this.quotes.has(epoch)) {
+      this.quotes.set(epoch, []);
+    }
+    this.quotes.get(epoch)!.push(quote);
+  }
+  getQuotes(epoch: bigint): EpochProofQuote[] {
+    return this.quotes.get(epoch) || [];
+  }
+  deleteQuotesToEpoch(epoch: bigint): void {
+    const expiredEpochs = Array.from(this.quotes.keys()).filter(k => k <= epoch);
+    for (const expiredEpoch of expiredEpochs) {
+      this.quotes.delete(expiredEpoch);
+    }
+  }
+}

package/src/epoch_proof_quote_pool/test_utils.ts

@@ -0,0 +1,26 @@
+import { EpochProofQuote, EpochProofQuotePayload } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Secp256k1Signer, randomBigInt, randomInt } from '@aztec/foundation/crypto';
+
+export function makeRandomEpochProofQuotePayload(): EpochProofQuotePayload {
+  return EpochProofQuotePayload.from({
+    basisPointFee: randomInt(10000),
+    bondAmount: 1000000000000000000n,
+    epochToProve: randomBigInt(1000000n),
+    prover: EthAddress.random(),
+    validUntilSlot: randomBigInt(1000000n),
+  });
+}
+
+export function makeRandomEpochProofQuote(payload?: EpochProofQuotePayload): {
+  quote: EpochProofQuote;
+  signer: Secp256k1Signer;
+} {
+  const signer = Secp256k1Signer.random();
+
+  return {
+    quote: EpochProofQuote.new(Buffer32.random(), payload ?? makeRandomEpochProofQuotePayload(), signer),
+    signer,
+  };
+}

package/src/index.ts

@@ -1,7 +1,8 @@
+export * from './attestation_pool/index.js';
+export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
 export * from './config.js';
-export * from './tx_pool/index.js';
-export * from './attestation_pool/index.js';
+export * from './epoch_proof_quote_pool/index.js';
 export * from './service/index.js';
-export * from './bootstrap/bootstrap.js';
+export * from './tx_pool/index.js';
 export * from './tx_validator/index.js';

package/src/mocks/index.ts

@@ -1,16 +1,21 @@
+import { type ClientProtocolCircuitVerifier, type Tx } from '@aztec/circuit-types';
+
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { tcp } from '@libp2p/tcp';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
+import { type PeerManager } from '../service/peer_manager.js';
 import { type P2PReqRespConfig } from '../service/reqresp/config.js';
 import { pingHandler, statusHandler } from '../service/reqresp/handlers.js';
 import {
   PING_PROTOCOL,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolValidators,
   STATUS_PROTOCOL,
   TX_REQ_PROTOCOL,
+  noopValidator,
 } from '../service/reqresp/interface.js';
 import { ReqResp } from '../service/reqresp/reqresp.js';
 
@@ -56,18 +61,29 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [TX_REQ_PROTOCOL]: (_msg: any) => Promise.resolve(Uint8Array.from(Buffer.from('tx'))),
 };
 
+// By default, all requests are valid
+// If you want to test an invalid response, you can override the validator
+export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
+  [PING_PROTOCOL]: noopValidator,
+  [STATUS_PROTOCOL]: noopValidator,
+  [TX_REQ_PROTOCOL]: noopValidator,
+};
+
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export const createNodes = async (numberOfNodes: number): Promise<ReqRespNode[]> => {
-  return await Promise.all(Array.from({ length: numberOfNodes }, () => createReqResp()));
+export const createNodes = async (peerManager: PeerManager, numberOfNodes: number): Promise<ReqRespNode[]> => {
+  return await Promise.all(Array.from({ length: numberOfNodes }, () => createReqResp(peerManager)));
 };
 
-// TODO: think about where else this can go
-export const startNodes = async (nodes: ReqRespNode[], subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS) => {
+export const startNodes = async (
+  nodes: ReqRespNode[],
+  subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS,
+  subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS,
+) => {
   for (const node of nodes) {
-    await node.req.start(subProtocolHandlers);
+    await node.req.start(subProtocolHandlers, subProtocolValidators);
   }
 };
 
@@ -79,13 +95,13 @@ export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
 };
 
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (): Promise<ReqRespNode> => {
+export const createReqResp = async (peerManager: PeerManager): Promise<ReqRespNode> => {
   const p2p = await createLibp2pNode();
   const config: P2PReqRespConfig = {
     overallRequestTimeoutMs: 4000,
     individualRequestTimeoutMs: 2000,
   };
-  const req = new ReqResp(config, p2p);
+  const req = new ReqResp(config, p2p, peerManager);
   return {
     p2p,
     req,
@@ -104,3 +120,15 @@ export const connectToPeers = async (nodes: ReqRespNode[]): Promise<void> => {
     }
   }
 };
+
+// Mock circuit verifier for testing - reimplementation from bb to avoid dependency
+export class AlwaysTrueCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+}
+export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+}