@aztec/p2p 0.55.1 → 0.57.0

package/src/service/libp2p_service.ts

@@ -47,13 +47,13 @@ import { PeerErrorSeverity } from './peer_scoring.js';
 import { pingHandler, statusHandler } from './reqresp/handlers.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
+  DEFAULT_SUB_PROTOCOL_VALIDATORS,
   PING_PROTOCOL,
   type ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
   STATUS_PROTOCOL,
   type SubProtocolMap,
   TX_REQ_PROTOCOL,
-  subProtocolMap,
 } from './reqresp/interface.js';
 import { ReqResp } from './reqresp/reqresp.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
@@ -109,7 +109,7 @@ export class LibP2PService implements P2PService {
       return this.peerManager.getPeerScore(peerId);
     };
     this.node.services.pubsub.score.params.appSpecificWeight = 10;
-    this.reqresp = new ReqResp(config, node);
+    this.reqresp = new ReqResp(config, node, this.peerManager);
 
     this.blockReceivedCallback = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
       this.logger.verbose(
@@ -162,7 +162,13 @@ export class LibP2PService implements P2PService {
       this.peerManager.heartbeat();
     }, this.config.peerCheckIntervalMS);
     this.discoveryRunningPromise.start();
-    await this.reqresp.start(this.requestResponseHandlers);
+
+    // Define the sub protocol validators - This is done within this start() method to gain a callback to the existing validateTx function
+    const reqrespSubProtocolValidators = {
+      ...DEFAULT_SUB_PROTOCOL_VALIDATORS,
+      [TX_REQ_PROTOCOL]: this.validateRequestedTx.bind(this),
+    };
+    await this.reqresp.start(this.requestResponseHandlers, reqrespSubProtocolValidators);
   }
 
   /**
@@ -176,12 +182,12 @@ export class LibP2PService implements P2PService {
     await this.discoveryRunningPromise?.stop();
     this.logger.debug('Stopping peer discovery service...');
     await this.peerDiscoveryService.stop();
+    this.logger.debug('Request response service stopped...');
+    await this.reqresp.stop();
     this.logger.debug('Stopping LibP2P...');
     await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
     this.logger.debug('Stopping request response service...');
-    await this.reqresp.stop();
-    this.logger.debug('Request response service stopped...');
   }
 
   /**
@@ -302,18 +308,11 @@ export class LibP2PService implements P2PService {
    * @param request The request type to send
    * @returns
    */
-  async sendRequest<SubProtocol extends ReqRespSubProtocol>(
+  sendRequest<SubProtocol extends ReqRespSubProtocol>(
     protocol: SubProtocol,
     request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
-    const pair = subProtocolMap[protocol];
-
-    const res = await this.reqresp.sendRequest(protocol, request.toBuffer());
-    if (!res) {
-      return undefined;
-    }
-
-    return pair.response.fromBuffer(res!);
+    return this.reqresp.sendRequest(protocol, request);
   }
 
   /**
@@ -418,19 +417,53 @@ export class LibP2PService implements P2PService {
     const txHashString = txHash.toString();
     this.logger.verbose(`Received tx ${txHashString} from external peer.`);
 
-    const isValidTx = await this.validateTx(tx, peerId);
+    const isValidTx = await this.validatePropagatedTx(tx, peerId);
 
     if (isValidTx) {
       await this.txPool.addTxs([tx]);
     }
   }
 
-  private async validateTx(tx: Tx, peerId: PeerId): Promise<boolean> {
+  /**
+   * Validate a tx that has been requested from a peer.
+   *
+   * The core component of this validator is that the tx hash MUST match the requested tx hash,
+   * In order to perform this check, the tx proof must be verified.
+   *
+   * Note: This function is called from within `ReqResp.sendRequest` as part of the
+   * TX_REQ_PROTOCOL subprotocol validation.
+   *
+   * @param requestedTxHash - The hash of the tx that was requested.
+   * @param responseTx - The tx that was received as a response to the request.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */
+  private async validateRequestedTx(requestedTxHash: TxHash, responseTx: Tx, peerId: PeerId): Promise<boolean> {
+    const proofValidator = new TxProofValidator(this.proofVerifier);
+    const validProof = await proofValidator.validateTx(responseTx);
+
+    // If the node returns the wrong data, we penalize it
+    if (!requestedTxHash.equals(responseTx.getTxHash())) {
+      // Returning the wrong data is a low tolerance error
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+      return false;
+    }
+
+    if (!validProof) {
+      // If the proof is invalid, but the txHash is correct, then this is an active attack and we severly punish
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
+      return false;
+    }
+
+    return true;
+  }
+
+  private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
     const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
     // basic data validation
     const dataValidator = new DataTxValidator();
-    const [_, dataInvalidTxs] = await dataValidator.validateTxs([tx]);
-    if (dataInvalidTxs.length > 0) {
+    const validData = await dataValidator.validateTx(tx);
+    if (!validData) {
       // penalize
       this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
       return false;
@@ -438,8 +471,8 @@ export class LibP2PService implements P2PService {
 
     // metadata validation
     const metadataValidator = new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber));
-    const [__, metaInvalidTxs] = await metadataValidator.validateTxs([tx]);
-    if (metaInvalidTxs.length > 0) {
+    const validMetadata = await metadataValidator.validateTx(tx);
+    if (!validMetadata) {
       // penalize
       this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
       return false;
@@ -453,8 +486,8 @@ export class LibP2PService implements P2PService {
         return index;
       },
     });
-    const [___, doubleSpendInvalidTxs] = await doubleSpendValidator.validateTxs([tx]);
-    if (doubleSpendInvalidTxs.length > 0) {
+    const validDoubleSpend = await doubleSpendValidator.validateTx(tx);
+    if (!validDoubleSpend) {
       // check if nullifier is older than 20 blocks
       if (blockNumber - this.config.severePeerPenaltyBlockLength > 0) {
         const snapshotValidator = new DoubleSpendTxValidator({
@@ -467,9 +500,9 @@ export class LibP2PService implements P2PService {
           },
         });
 
-        const [____, snapshotInvalidTxs] = await snapshotValidator.validateTxs([tx]);
+        const validSnapshot = await snapshotValidator.validateTx(tx);
         // High penalty if nullifier is older than 20 blocks
-        if (snapshotInvalidTxs.length > 0) {
+        if (!validSnapshot) {
           // penalize
           this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
           return false;
@@ -482,8 +515,8 @@ export class LibP2PService implements P2PService {
 
     // proof validation
     const proofValidator = new TxProofValidator(this.proofVerifier);
-    const [_____, proofInvalidTxs] = await proofValidator.validateTxs([tx]);
-    if (proofInvalidTxs.length > 0) {
+    const validProof = await proofValidator.validateTx(tx);
+    if (!validProof) {
       // penalize
       this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
       return false;

package/src/service/reqresp/interface.ts

@@ -1,5 +1,7 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 
+import { type PeerId } from '@libp2p/interface';
+
 /*
  * Request Response Sub Protocols
  */
@@ -46,11 +48,29 @@ export interface ProtocolRateLimitQuota {
   globalLimit: RateLimitQuota;
 }
 
+export const noopValidator = () => Promise.resolve(true);
+
 /**
  * A type mapping from supprotocol to it's handling funciton
  */
 export type ReqRespSubProtocolHandlers = Record<ReqRespSubProtocol, ReqRespSubProtocolHandler>;
 
+type ResponseValidator<RequestIdentifier, Response> = (
+  request: RequestIdentifier,
+  response: Response,
+  peerId: PeerId,
+) => Promise<boolean>;
+
+export type ReqRespSubProtocolValidators = {
+  [S in ReqRespSubProtocol]: ResponseValidator<any, any>;
+};
+
+export const DEFAULT_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
+  [PING_PROTOCOL]: noopValidator,
+  [STATUS_PROTOCOL]: noopValidator,
+  [TX_REQ_PROTOCOL]: noopValidator,
+};
+
 /**
  * Sub protocol map determines the request and response types for each
  * Req Resp protocol

package/src/service/reqresp/rate_limiter/rate_limiter.ts

@@ -5,6 +5,8 @@
  */
 import { type PeerId } from '@libp2p/interface';
 
+import { type PeerManager } from '../../peer_manager.js';
+import { PeerErrorSeverity } from '../../peer_scoring.js';
 import { type ReqRespSubProtocol, type ReqRespSubProtocolRateLimits } from '../interface.js';
 import { DEFAULT_RATE_LIMITS } from './rate_limits.js';
 
@@ -69,6 +71,12 @@ interface PeerRateLimiter {
   lastAccess: number;
 }
 
+enum RateLimitStatus {
+  Allowed,
+  DeniedGlobal,
+  DeniedPeer,
+}
+
 /**
  * SubProtocolRateLimiter: A rate limiter for managing request rates on a per-peer and global basis for a specific subprotocol.
  *
@@ -98,9 +106,9 @@ export class SubProtocolRateLimiter {
     this.peerQuotaTimeMs = peerQuotaTimeMs;
   }
 
-  allow(peerId: PeerId): boolean {
+  allow(peerId: PeerId): RateLimitStatus {
     if (!this.globalLimiter.allow()) {
-      return false;
+      return RateLimitStatus.DeniedGlobal;
     }
 
     const peerIdStr = peerId.toString();
@@ -115,7 +123,11 @@ export class SubProtocolRateLimiter {
     } else {
       peerLimiter.lastAccess = Date.now();
     }
-    return peerLimiter.limiter.allow();
+    const peerLimitAllowed = peerLimiter.limiter.allow();
+    if (!peerLimitAllowed) {
+      return RateLimitStatus.DeniedPeer;
+    }
+    return RateLimitStatus.Allowed;
   }
 
   cleanupInactivePeers() {
@@ -138,14 +150,16 @@ export class SubProtocolRateLimiter {
  * - Initializes with a set of rate limit configurations for different subprotocols.
  * - Creates a separate SubProtocolRateLimiter for each configured subprotocol.
  * - When a request comes in, it routes the rate limiting decision to the appropriate subprotocol limiter.
+ * - Peers who exceed their peer rate limits will be penalised by the peer manager.
  *
  * Usage:
  * ```
+ * const peerManager = new PeerManager(...);
  * const rateLimits = {
  *   subprotocol1: { peerLimit: { quotaCount: 10, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 100, quotaTimeMs: 1000 } },
  *   subprotocol2: { peerLimit: { quotaCount: 5, quotaTimeMs: 1000 }, globalLimit: { quotaCount: 50, quotaTimeMs: 1000 } }
  * };
- * const limiter = new RequestResponseRateLimiter(rateLimits);
+ * const limiter = new RequestResponseRateLimiter(peerManager, rateLimits);
  *
  * Note: Ensure to call `stop()` when shutting down to properly clean up all subprotocol limiters.
  */
@@ -154,7 +168,7 @@ export class RequestResponseRateLimiter {
 
   private cleanupInterval: NodeJS.Timeout | undefined = undefined;
 
-  constructor(rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
+  constructor(private peerManager: PeerManager, rateLimits: ReqRespSubProtocolRateLimits = DEFAULT_RATE_LIMITS) {
     this.subProtocolRateLimiters = new Map();
 
     for (const [subProtocol, protocolLimits] of Object.entries(rateLimits)) {
@@ -179,10 +193,19 @@ export class RequestResponseRateLimiter {
   allow(subProtocol: ReqRespSubProtocol, peerId: PeerId): boolean {
     const limiter = this.subProtocolRateLimiters.get(subProtocol);
     if (!limiter) {
-      // TODO: maybe throw an error here if no rate limiter is configured?
       return true;
     }
-    return limiter.allow(peerId);
+    const rateLimitStatus = limiter.allow(peerId);
+
+    switch (rateLimitStatus) {
+      case RateLimitStatus.DeniedPeer:
+        this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+        return false;
+      case RateLimitStatus.DeniedGlobal:
+        return false;
+      default:
+        return true;
+    }
   }
 
   cleanupInactivePeers() {

package/src/service/reqresp/reqresp.ts

@@ -8,11 +8,17 @@ import { type Libp2p } from 'libp2p';
 import { type Uint8ArrayList } from 'uint8arraylist';
 
 import { CollectiveReqRespTimeoutError, IndiviualReqRespTimeoutError } from '../../errors/reqresp.error.js';
+import { type PeerManager } from '../peer_manager.js';
+import { PeerErrorSeverity } from '../peer_scoring.js';
 import { type P2PReqRespConfig } from './config.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
+  DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolValidators,
+  type SubProtocolMap,
+  subProtocolMap,
 } from './interface.js';
 import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
 
@@ -30,28 +36,31 @@ import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
 export class ReqResp {
   protected readonly logger: Logger;
 
-  private abortController: AbortController = new AbortController();
-
   private overallRequestTimeoutMs: number;
   private individualRequestTimeoutMs: number;
 
+  // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
   private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
+  private subProtocolValidators: ReqRespSubProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+
   private rateLimiter: RequestResponseRateLimiter;
 
-  constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p) {
+  constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p, private peerManager: PeerManager) {
     this.logger = createDebugLogger('aztec:p2p:reqresp');
 
     this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
 
-    this.rateLimiter = new RequestResponseRateLimiter();
+    this.rateLimiter = new RequestResponseRateLimiter(peerManager);
   }
 
   /**
    * Start the reqresp service
    */
-  async start(subProtocolHandlers: ReqRespSubProtocolHandlers) {
+  async start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators) {
     this.subProtocolHandlers = subProtocolHandlers;
+    this.subProtocolValidators = subProtocolValidators;
+
     // Register all protocol handlers
     for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
       await this.libp2p.handle(subProtocol, this.streamHandler.bind(this, subProtocol as ReqRespSubProtocol));
@@ -67,38 +76,80 @@ export class ReqResp {
     for (const protocol of Object.keys(this.subProtocolHandlers)) {
       await this.libp2p.unhandle(protocol);
     }
+
+    // Close all active connections
+    const closeStreamPromises = this.libp2p.getConnections().map(connection => connection.close());
+    await Promise.all(closeStreamPromises);
+    this.logger.debug('ReqResp: All active streams closed');
+
     this.rateLimiter.stop();
-    await this.libp2p.stop();
-    this.abortController.abort();
+    this.logger.debug('ReqResp: Rate limiter stopped');
+
+    // NOTE: We assume libp2p instance is managed by the caller
   }
 
   /**
    * Send a request to peers, returns the first response
    *
    * @param subProtocol - The protocol being requested
-   * @param payload - The payload to send
+   * @param request - The request to send
    * @returns - The response from the peer, otherwise undefined
+   *
+   * @description
+   * This method attempts to send a request to all active peers using the specified sub-protocol.
+   * It opens a stream with each peer, sends the request, and awaits a response.
+   * If a valid response is received, it returns the response; otherwise, it continues to the next peer.
+   * If no response is received from any peer, it returns undefined.
+   *
+   * The method performs the following steps:
+   * - Iterates over all active peers.
+   * - Opens a stream with each peer using the specified sub-protocol.
+   *
+   * When a response is received, it is validated using the given sub protocols response validator.
+   * To see the interface for the response validator - see `interface.ts`
+   *
+   * Failing a response validation requests in a severe peer penalty, and will
+   * prompt the node to continue to search to the next peer.
+   * For example, a transaction request validator will check that the payload returned does in fact
+   * match the txHash that was requested. A peer that fails this check an only be an extremely naughty peer.
+   *
+   * This entire operation is wrapped in an overall timeout, that is independent of the
+   * peer it is requesting data from.
+   *
    */
-  async sendRequest(subProtocol: ReqRespSubProtocol, payload: Buffer): Promise<Buffer | undefined> {
+  async sendRequest<SubProtocol extends ReqRespSubProtocol>(
+    subProtocol: SubProtocol,
+    request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
     const requestFunction = async () => {
+      const responseValidator = this.subProtocolValidators[subProtocol];
+      const requestBuffer = request.toBuffer();
+
       // Get active peers
       const peers = this.libp2p.getPeers();
 
       // Attempt to ask all of our peers
       for (const peer of peers) {
-        const response = await this.sendRequestToPeer(peer, subProtocol, payload);
+        const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
         // If we get a response, return it, otherwise we iterate onto the next peer
         // We do not consider it a success if we have an empty buffer
         if (response && response.length > 0) {
-          return response;
+          const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+          // The response validator handles peer punishment within
+          const isValid = await responseValidator(request, object, peer);
+          if (!isValid) {
+            this.logger.error(`Invalid response for ${subProtocol} from ${peer.toString()}`);
+            return undefined;
+          }
+          return object;
         }
       }
       return undefined;
     };
 
     try {
-      return await executeTimeoutWithCustomError<Buffer | undefined>(
+      return await executeTimeoutWithCustomError<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined>(
         requestFunction,
         this.overallRequestTimeoutMs,
         () => new CollectiveReqRespTimeoutError(),
@@ -112,10 +163,26 @@ export class ReqResp {
   /**
    * Sends a request to a specific peer
    *
+   * We first dial a particular protocol for the peer, this ensures that the peer knows
+   * what to respond with
+   *
+   *
    * @param peerId - The peer to send the request to
    * @param subProtocol - The protocol to use to request
    * @param payload - The payload to send
    * @returns If the request is successful, the response is returned, otherwise undefined
+   *
+   * @description
+   * This method attempts to open a stream with the specified peer, send the payload,
+   * and await a response.
+   * If an error occurs, it penalizes the peer and returns undefined.
+   *
+   * The method performs the following steps:
+   * - Opens a stream with the peer using the specified sub-protocol.
+   * - Sends the payload and awaits a response with a timeout.
+   *
+   * If the stream is not closed by the dialled peer, and a timeout occurs, then
+   * the stream is closed on the requester's end and sender (us) updates its peer score
    */
   async sendRequestToPeer(
     peerId: PeerId,
@@ -125,9 +192,9 @@ export class ReqResp {
     let stream: Stream | undefined;
     try {
       stream = await this.libp2p.dialProtocol(peerId, subProtocol);
-
       this.logger.debug(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
 
+      // Open the stream with a timeout
       const result = await executeTimeoutWithCustomError<Buffer>(
         (): Promise<Buffer> => pipe([payload], stream!, this.readMessage),
         this.individualRequestTimeoutMs,
@@ -140,6 +207,7 @@ export class ReqResp {
       return result;
     } catch (e: any) {
       this.logger.error(`${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`);
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
     } finally {
       if (stream) {
         try {
@@ -172,6 +240,16 @@ export class ReqResp {
    * Reads the incoming stream, determines the protocol, then triggers the appropriate handler
    *
    * @param param0 - The incoming stream data
+   *
+   * @description
+   * An individual stream handler will be bound to each sub protocol, and handles returning data back
+   * to the requesting peer.
+   *
+   * The sub protocol handler interface is defined within `interface.ts` and will be assigned to the
+   * req resp service on start up.
+   *
+   * We check rate limits for each peer, note the peer will be penalised within the rate limiter implementation
+   * if they exceed their peer specific limits.
    */
   private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
     // Store a reference to from this for the async generator

package/src/tx_validator/aggregate_tx_validator.ts

@@ -21,4 +21,14 @@ export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValid
 
     return [txPool, invalidTxs];
   }
+
+  async validateTx(tx: T): Promise<boolean> {
+    for (const validator of this.#validators) {
+      const valid = await validator.validateTx(tx);
+      if (!valid) {
+        return false;
+      }
+    }
+    return true;
+  }
 }

package/src/tx_validator/data_validator.ts

@@ -19,6 +19,10 @@ export class DataTxValidator implements TxValidator<Tx> {
     return Promise.resolve([validTxs, invalidTxs]);
   }
 
+  validateTx(tx: Tx): Promise<boolean> {
+    return Promise.resolve(this.#hasCorrectExecutionRequests(tx));
+  }
+
   #hasCorrectExecutionRequests(tx: Tx): boolean {
     const callRequests = [
       ...tx.data.getRevertiblePublicCallRequests(),

package/src/tx_validator/double_spend_validator.ts

@@ -31,6 +31,10 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     return [validTxs, invalidTxs];
   }
 
+  validateTx(tx: T): Promise<boolean> {
+    return this.#uniqueNullifiers(tx, new Set<bigint>());
+  }
+
   async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
     const nullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
 

package/src/tx_validator/metadata_validator.ts

@@ -27,6 +27,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     return Promise.resolve([validTxs, invalidTxs]);
   }
 
+  validateTx(tx: T): Promise<boolean> {
+    return Promise.resolve(this.#hasCorrectChainId(tx) && this.#isValidForBlockNumber(tx));
+  }
+
   #hasCorrectChainId(tx: T): boolean {
     if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
       this.#log.warn(

package/dest/client/mocks.d.ts

@@ -1,65 +0,0 @@
-import { L2Block, type L2BlockSource, type TxEffect, type TxHash, TxReceipt } from '@aztec/circuit-types';
-import { EthAddress } from '@aztec/circuits.js';
-/**
- * A mocked implementation of L2BlockSource to be used in p2p tests.
- */
-export declare class MockBlockSource implements L2BlockSource {
-    private provenBlockNumber?;
-    private l2Blocks;
-    private txEffects;
-    constructor(numBlocks?: number, provenBlockNumber?: number | undefined);
-    addBlocks(numBlocks: number): void;
-    setProvenBlockNumber(provenBlockNumber: number): void;
-    /**
-     * Method to fetch the rollup contract address at the base-layer.
-     * @returns The rollup address.
-     */
-    getRollupAddress(): Promise<EthAddress>;
-    /**
-     * Method to fetch the registry contract address at the base-layer.
-     * @returns The registry address.
-     */
-    getRegistryAddress(): Promise<EthAddress>;
-    /**
-     * Gets the number of the latest L2 block processed by the block source implementation.
-     * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
-     */
-    getBlockNumber(): Promise<number>;
-    getProvenBlockNumber(): Promise<number>;
-    /**
-     * Gets an l2 block.
-     * @param number - The block number to return (inclusive).
-     * @returns The requested L2 block.
-     */
-    getBlock(number: number): Promise<L2Block>;
-    /**
-     * Gets up to `limit` amount of L2 blocks starting from `from`.
-     * @param from - Number of the first block to return (inclusive).
-     * @param limit - The maximum number of blocks to return.
-     * @returns The requested mocked L2 blocks.
-     */
-    getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
-    /**
-     * Gets a tx effect.
-     * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-     * @returns The requested tx effect.
-     */
-    getTxEffect(txHash: TxHash): Promise<TxEffect | undefined>;
-    /**
-     * Gets a receipt of a settled tx.
-     * @param txHash - The hash of a tx we try to get the receipt for.
-     * @returns The requested tx receipt (or undefined if not found).
-     */
-    getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
-    /**
-     * Starts the block source. In this mock implementation, this is a noop.
-     * @returns A promise that signals the initialization of the l2 block source on completion.
-     */
-    start(): Promise<void>;
-    /**
-     * Stops the block source. In this mock implementation, this is a noop.
-     * @returns A promise that signals the l2 block source is now stopped.
-     */
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=mocks.d.ts.map

package/dest/client/mocks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/client/mocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,SAAS,EAAY,MAAM,sBAAsB,CAAC;AACpH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;GAEG;AACH,qBAAa,eAAgB,YAAW,aAAa;IAItB,OAAO,CAAC,iBAAiB,CAAC;IAHvD,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,SAAS,CAAkB;gBAEvB,SAAS,SAAM,EAAU,iBAAiB,CAAC,oBAAQ;IAIxD,SAAS,CAAC,SAAS,EAAE,MAAM;IAS3B,oBAAoB,CAAC,iBAAiB,EAAE,MAAM;IAIrD;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;;OAGG;IACH,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC;IAIzC;;;OAGG;IACI,cAAc;IAIR,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIpD;;;;OAIG;IACI,QAAQ,CAAC,MAAM,EAAE,MAAM;IAI9B;;;;;OAKG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO;IAQ9D;;;;OAIG;IACI,WAAW,CAAC,MAAM,EAAE,MAAM;IAKjC;;;;OAIG;IACI,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAoB1E;;;OAGG;IACI,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B;;;OAGG;IACI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}