@aztec/p2p 0.23.0 → 0.24.0

package/dest/service/tx_messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tx_messages.d.ts","sourceRoot":"","sources":["../../src/service/tx_messages.ts"],"names":[],"mappings":";AAAA,OAAO,EAAwB,EAAE,EAAE,MAAM,EAAY,MAAM,sBAAsB,CAAC;AAIlF;;GAEG;AACH,oBAAY,QAAQ;IAClB,mBAAmB,IAAI;IACvB,yBAAyB,IAAI;IAC7B,gBAAgB,IAAI;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAEhE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,EAAE,EAAE,UAGlD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,QAWxD;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,EAAE,UAG9D;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,YAY7D;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,EAAE,UAGnE;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,MAAM,YAGlE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,UAEhD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,UAEhD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CA6B1C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAmDhD"}
+{"version":3,"file":"tx_messages.d.ts","sourceRoot":"","sources":["../../src/service/tx_messages.ts"],"names":[],"mappings":";AAAA,OAAO,EAAwB,EAAE,EAAE,MAAM,EAAY,MAAM,sBAAsB,CAAC;AASlF;;GAEG;AACH,oBAAY,QAAQ;IAClB,mBAAmB,IAAI;IACvB,yBAAyB,IAAI;IAC7B,gBAAgB,IAAI;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAEhE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,EAAE,EAAE,UAGlD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,QAWxD;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,EAAE,UAG9D;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,YAY7D;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,EAAE,UAGnE;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,MAAM,YAGlE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,UAEhD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,UAEhD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CA6B1C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAmDhD"}

package/dest/service/tx_messages.js

@@ -1,5 +1,5 @@
 import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/circuit-types';
-import { KernelCircuitPublicInputsFinal, Proof, PublicCallRequest } from '@aztec/circuits.js';
+import { PrivateKernelTailCircuitPublicInputs, Proof, PublicCallRequest, } from '@aztec/circuits.js';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
 /**
  * Enumeration of P2P message types.
@@ -174,7 +174,7 @@ export function fromTxMessage(buffer) {
     };
     // this is the opposite of the 'toMessage' function
     // so the first 4 bytes is the complete length, skip it
-    const publicInputs = toObject(buffer.subarray(4), KernelCircuitPublicInputsFinal);
+    const publicInputs = toObject(buffer.subarray(4), PrivateKernelTailCircuitPublicInputs);
     const proof = toObject(publicInputs.remainingData, Proof);
     const encryptedLogs = toObject(proof.remainingData, TxL2Logs);
     if (!encryptedLogs.obj) {
@@ -188,4 +188,4 @@ export function fromTxMessage(buffer) {
     const newContracts = toObjectArray(publicCalls.remainingData, ExtendedContractData);
     return new Tx(publicInputs.obj, proof.obj, encryptedLogs.obj, unencryptedLogs.obj, publicCalls.objects, newContracts.objects);
 }
-//# 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.23.0",
+  "version": "0.24.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -32,10 +32,10 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.23.0",
-    "@aztec/circuits.js": "0.23.0",
-    "@aztec/foundation": "0.23.0",
-    "@aztec/kv-store": "0.23.0",
+    "@aztec/circuit-types": "0.24.0",
+    "@aztec/circuits.js": "0.24.0",
+    "@aztec/foundation": "0.24.0",
+    "@aztec/kv-store": "0.24.0",
     "@chainsafe/libp2p-noise": "^13.0.0",
     "@chainsafe/libp2p-yamux": "^5.0.0",
     "@libp2p/bootstrap": "^9.0.4",

package/src/bootstrap/bootstrap.ts

@@ -0,0 +1,116 @@
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import { noise } from '@chainsafe/libp2p-noise';
+import { yamux } from '@chainsafe/libp2p-yamux';
+import type { ServiceMap } from '@libp2p/interface-libp2p';
+import { kadDHT } from '@libp2p/kad-dht';
+import { mplex } from '@libp2p/mplex';
+import { tcp } from '@libp2p/tcp';
+import { Libp2p, Libp2pOptions, ServiceFactoryMap, createLibp2p } from 'libp2p';
+import { identifyService } from 'libp2p/identify';
+import { format } from 'util';
+
+import { P2PConfig } from '../config.js';
+import { createLibP2PPeerId } from '../service/index.js';
+
+/**
+ * Encapsulates a 'Bootstrap' node, used for the purpose of assisting new joiners in acquiring peers.
+ */
+export class BootstrapNode {
+  private node?: Libp2p = undefined;
+
+  constructor(private logger = createDebugLogger('aztec:p2p_bootstrap')) {}
+
+  /**
+   * Starts the bootstrap node.
+   * @param config - The P2P configuration.
+   * @returns An empty promise.
+   */
+  public async start(config: P2PConfig) {
+    const { peerIdPrivateKey, tcpListenIp, tcpListenPort, announceHostname, announcePort, minPeerCount, maxPeerCount } =
+      config;
+    const peerId = await createLibP2PPeerId(peerIdPrivateKey);
+    this.logger(
+      `Starting bootstrap node ${peerId} on ${tcpListenIp}:${tcpListenPort} announced at ${announceHostname}:${
+        announcePort ?? tcpListenPort
+      }`,
+    );
+
+    const opts: Libp2pOptions<ServiceMap> = {
+      start: false,
+      peerId,
+      addresses: {
+        listen: [`/ip4/${tcpListenIp}/tcp/${tcpListenPort}`],
+        announce: announceHostname ? [`${announceHostname}/tcp/${announcePort ?? tcpListenPort}`] : [],
+      },
+      transports: [tcp()],
+      streamMuxers: [yamux(), mplex()],
+      connectionEncryption: [noise()],
+      connectionManager: {
+        minConnections: minPeerCount,
+        maxConnections: maxPeerCount,
+      },
+    };
+
+    const services: ServiceFactoryMap = {
+      identify: identifyService({
+        protocolPrefix: 'aztec',
+      }),
+      kadDHT: kadDHT({
+        protocolPrefix: 'aztec',
+        clientMode: false,
+      }),
+      // The autonat service seems quite problematic in that using it seems to cause a lot of attempts
+      // to dial ephemeral ports. I suspect that it works better if you can get the uPNPnat service to
+      // work as then you would have a permanent port to be dialled.
+      // Alas, I struggled to get this to work reliably either.
+      // autoNAT: autoNATService({
+      //   protocolPrefix: 'aztec',
+      // }),
+    };
+
+    this.node = await createLibp2p({
+      ...opts,
+      services,
+    });
+
+    await this.node.start();
+    this.logger(`lib p2p has started`);
+
+    // print out listening addresses
+    this.logger('listening on addresses:');
+    this.node.getMultiaddrs().forEach(addr => {
+      this.logger(addr.toString());
+    });
+
+    this.node.addEventListener('peer:discovery', evt => {
+      this.logger(format('Discovered %s', evt.detail.id.toString())); // Log discovered peer
+    });
+
+    this.node.addEventListener('peer:connect', evt => {
+      this.logger(format('Connected to %s', evt.detail.toString())); // Log connected peer
+    });
+
+    this.node.addEventListener('peer:disconnect', evt => {
+      this.logger(format('Disconnected from %s', evt.detail.toString())); // Log connected peer
+    });
+  }
+
+  /**
+   * Stops the bootstrap node.
+   * @returns And empty promise.
+   */
+  public async stop() {
+    // stop libp2p
+    await this.node?.stop();
+    this.logger('libp2p has stopped');
+  }
+
+  /**
+   * Returns the peerId of this node.
+   * @returns The node's peer Id
+   */
+  public getPeerId() {
+    return this.node?.peerId;
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,20 @@
+import { L2BlockSource } from '@aztec/circuit-types';
+import { AztecKVStore } from '@aztec/kv-store';
+
+import { P2PClient } from '../client/p2p_client.js';
+import { P2PConfig } from '../config.js';
+import { DummyP2PService } from '../service/dummy_service.js';
+import { LibP2PService } from '../service/index.js';
+import { TxPool } from '../tx_pool/index.js';
+
+export * from './p2p_client.js';
+
+export const createP2PClient = async (
+  store: AztecKVStore,
+  config: P2PConfig,
+  txPool: TxPool,
+  l2BlockSource: L2BlockSource,
+) => {
+  const p2pService = config.p2pEnabled ? await LibP2PService.new(config, txPool) : new DummyP2PService();
+  return new P2PClient(store, l2BlockSource, txPool, p2pService);
+};

package/src/client/mocks.ts

@@ -0,0 +1,87 @@
+import { L2Block, L2BlockSource, L2Tx, TxHash } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
+
+/**
+ * A mocked implementation of L2BlockSource to be used in p2p tests.
+ */
+export class MockBlockSource implements L2BlockSource {
+  private l2Blocks: L2Block[] = [];
+  private l2Txs: L2Tx[] = [];
+
+  constructor(private numBlocks = 100) {
+    for (let i = 0; i < this.numBlocks; i++) {
+      const block = L2Block.random(i);
+      this.l2Blocks.push(block);
+      this.l2Txs.push(...block.getTxs());
+    }
+  }
+
+  /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */
+  getRollupAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */
+  getRegistryAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * 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.
+   */
+  public getBlockNumber() {
+    return Promise.resolve(this.l2Blocks.length - 1);
+  }
+
+  /**
+   * Gets an l2 block.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  public getBlock(number: number) {
+    return Promise.resolve(this.l2Blocks[number]);
+  }
+
+  /**
+   * 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.
+   */
+  public getBlocks(from: number, limit: number) {
+    return Promise.resolve(this.l2Blocks.slice(from, from + limit));
+  }
+
+  /**
+   * Gets an l2 tx.
+   * @param txHash - The txHash of the l2 tx.
+   * @returns The requested L2 tx.
+   */
+  getL2Tx(txHash: TxHash) {
+    const l2Tx = this.l2Txs.find(tx => tx.txHash.equals(txHash));
+    return Promise.resolve(l2Tx);
+  }
+
+  /**
+   * 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.
+   */
+  public start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/client/p2p_client.ts

@@ -0,0 +1,334 @@
+import {
+  INITIAL_L2_BLOCK_NUM,
+  L2Block,
+  L2BlockContext,
+  L2BlockDownloader,
+  L2BlockSource,
+  Tx,
+  TxHash,
+} from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore, AztecSingleton } from '@aztec/kv-store';
+
+import { getP2PConfigEnvVars } from '../config.js';
+import { P2PService } from '../service/service.js';
+import { TxPool } from '../tx_pool/index.js';
+
+/**
+ * Enum defining the possible states of the p2p client.
+ */
+export enum P2PClientState {
+  IDLE,
+  SYNCHING,
+  RUNNING,
+  STOPPED,
+}
+
+/**
+ * The synchronization status of the P2P client.
+ */
+export interface P2PSyncState {
+  /**
+   * The current state of the p2p client.
+   */
+  state: P2PClientState;
+  /**
+   * The block number that the p2p client is synced to.
+   */
+  syncedToL2Block: number;
+}
+
+/**
+ * Interface of a P2P client.
+ **/
+export interface P2P {
+  /**
+   * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+   * @param tx - The transaction.
+   **/
+  sendTx(tx: Tx): Promise<void>;
+
+  /**
+   * Deletes 'txs' from the pool, given hashes.
+   * NOT used if we use sendTx as reconcileTxPool will handle this.
+   * @param txHashes - Hashes to check.
+   **/
+  deleteTxs(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Returns all transactions in the transaction pool.
+   * @returns An array of Txs.
+   */
+  getTxs(): Promise<Tx[]>;
+
+  /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash  - Hash of tx to return.
+   * @returns A single tx or undefined.
+   */
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Starts the p2p client.
+   * @returns A promise signalling the completion of the block sync.
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stops the p2p client.
+   * @returns A promise signalling the completion of the stop process.
+   */
+  stop(): Promise<void>;
+
+  /**
+   * Indicates if the p2p client is ready for transaction submission.
+   * @returns A boolean flag indicating readiness.
+   */
+  isReady(): Promise<boolean>;
+
+  /**
+   * Returns the current status of the p2p client.
+   */
+  getStatus(): Promise<P2PSyncState>;
+}
+
+/**
+ * The P2P client implementation.
+ */
+export class P2PClient implements P2P {
+  /**
+   * L2 Block download that p2p client uses to stay in sync with latest blocks.
+   */
+  private blockDownloader: L2BlockDownloader;
+
+  /**
+   * Property that indicates whether the client is running.
+   */
+  private stopping = false;
+
+  /**
+   * The JS promise that will be running to keep the client's data in sync. Can be interrupted if the client is stopped.
+   */
+  private runningPromise!: Promise<void>;
+
+  private currentState = P2PClientState.IDLE;
+  private syncPromise = Promise.resolve();
+  private latestBlockNumberAtStart = -1;
+  private syncResolve?: () => void = undefined;
+  private synchedBlockNumber: AztecSingleton<number>;
+
+  /**
+   * In-memory P2P client constructor.
+   * @param store - The client's instance of the KV store.
+   * @param l2BlockSource - P2P client's source for fetching existing blocks.
+   * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
+   * @param p2pService - The concrete instance of p2p networking to use.
+   * @param log - A logger.
+   */
+  constructor(
+    store: AztecKVStore,
+    private l2BlockSource: L2BlockSource,
+    private txPool: TxPool,
+    private p2pService: P2PService,
+    private log = createDebugLogger('aztec:p2p'),
+  ) {
+    const { p2pBlockCheckIntervalMS: checkInterval, p2pL2QueueSize } = getP2PConfigEnvVars();
+    this.blockDownloader = new L2BlockDownloader(l2BlockSource, p2pL2QueueSize, checkInterval);
+    this.synchedBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+  }
+
+  /**
+   * Starts the P2P client.
+   * @returns An empty promise signalling the synching process.
+   */
+  public async start() {
+    if (this.currentState === P2PClientState.STOPPED) {
+      throw new Error('P2P client already stopped');
+    }
+    if (this.currentState !== P2PClientState.IDLE) {
+      return this.syncPromise;
+    }
+
+    // get the current latest block number
+    this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+
+    const blockToDownloadFrom = this.getSyncedBlockNum() + 1;
+
+    // if there are blocks to be retrieved, go to a synching state
+    if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
+      this.setCurrentState(P2PClientState.SYNCHING);
+      this.syncPromise = new Promise(resolve => {
+        this.syncResolve = resolve;
+      });
+      this.log(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
+    } else {
+      // if no blocks to be retrieved, go straight to running
+      this.setCurrentState(P2PClientState.RUNNING);
+      this.syncPromise = Promise.resolve();
+      await this.p2pService.start();
+      this.log(`Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`);
+    }
+
+    // publish any txs in TxPool after its doing initial sync
+    this.syncPromise = this.syncPromise.then(() => this.publishStoredTxs());
+
+    // start looking for further blocks
+    const blockProcess = async () => {
+      while (!this.stopping) {
+        const blocks = await this.blockDownloader.getBlocks();
+        await this.handleL2Blocks(blocks);
+      }
+    };
+    this.runningPromise = blockProcess();
+    this.blockDownloader.start(blockToDownloadFrom);
+    this.log(`Started block downloader from block ${blockToDownloadFrom}`);
+
+    return this.syncPromise;
+  }
+
+  /**
+   * Allows consumers to stop the instance of the P2P client.
+   * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+   */
+  public async stop() {
+    this.log('Stopping p2p client...');
+    this.stopping = true;
+    await this.p2pService.stop();
+    this.log('Stopped p2p service');
+    await this.blockDownloader.stop();
+    this.log('Stopped block downloader');
+    await this.runningPromise;
+    this.setCurrentState(P2PClientState.STOPPED);
+    this.log('P2P client stopped...');
+  }
+
+  /**
+   * Returns all transactions in the transaction pool.
+   * @returns An array of Txs.
+   */
+  public getTxs(): Promise<Tx[]> {
+    return Promise.resolve(this.txPool.getAllTxs());
+  }
+
+  /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash - Hash of the transaction to look for in the pool.
+   * @returns A single tx or undefined.
+   */
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    return Promise.resolve(this.txPool.getTxByHash(txHash));
+  }
+
+  /**
+   * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+   * @param tx - The tx to verify.
+   * @returns Empty promise.
+   **/
+  public async sendTx(tx: Tx): Promise<void> {
+    const ready = await this.isReady();
+    if (!ready) {
+      throw new Error('P2P client not ready');
+    }
+    await this.txPool.addTxs([tx]);
+    this.p2pService.propagateTx(tx);
+  }
+
+  /**
+   * Deletes the 'txs' from the pool.
+   * NOT used if we use sendTx as reconcileTxPool will handle this.
+   * @param txHashes - Hashes of the transactions to delete.
+   * @returns Empty promise.
+   **/
+  public async deleteTxs(txHashes: TxHash[]): Promise<void> {
+    const ready = await this.isReady();
+    if (!ready) {
+      throw new Error('P2P client not ready');
+    }
+    await this.txPool.deleteTxs(txHashes);
+  }
+
+  /**
+   * Public function to check if the p2p client is fully synced and ready to receive txs.
+   * @returns True if the P2P client is ready to receive txs.
+   */
+  public isReady() {
+    return Promise.resolve(this.currentState === P2PClientState.RUNNING);
+  }
+
+  /**
+   * Public function to check the latest block number that the P2P client is synced to.
+   * @returns Block number of latest L2 Block we've synced with.
+   */
+  public getSyncedBlockNum() {
+    return this.synchedBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
+  }
+
+  /**
+   * Method to check the status the p2p client.
+   * @returns Information about p2p client status: state & syncedToBlockNum.
+   */
+  public getStatus(): Promise<P2PSyncState> {
+    return Promise.resolve({
+      state: this.currentState,
+      syncedToL2Block: this.getSyncedBlockNum(),
+    } as P2PSyncState);
+  }
+
+  /**
+   * Internal method that uses the provided blocks to check against the client's tx pool.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */
+  private async reconcileTxPool(blocks: L2Block[]): Promise<void> {
+    for (let i = 0; i < blocks.length; i++) {
+      const blockContext = new L2BlockContext(blocks[i]);
+      const txHashes = blockContext.getTxHashes();
+      await this.txPool.deleteTxs(txHashes);
+      this.p2pService.settledTxs(txHashes);
+    }
+  }
+
+  /**
+   * Method for processing new blocks.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */
+  private async handleL2Blocks(blocks: L2Block[]): Promise<void> {
+    if (!blocks.length) {
+      return Promise.resolve();
+    }
+    await this.reconcileTxPool(blocks);
+    const lastBlockNum = blocks[blocks.length - 1].number;
+    await this.synchedBlockNumber.set(lastBlockNum);
+    this.log(`Synched to block ${lastBlockNum}`);
+
+    if (this.currentState === P2PClientState.SYNCHING && lastBlockNum >= this.latestBlockNumberAtStart) {
+      this.setCurrentState(P2PClientState.RUNNING);
+      if (this.syncResolve !== undefined) {
+        this.syncResolve();
+        await this.p2pService.start();
+      }
+    }
+  }
+
+  /**
+   * Method to set the value of the current state.
+   * @param newState - New state value.
+   */
+  private setCurrentState(newState: P2PClientState) {
+    this.currentState = newState;
+    this.log(`Moved to state ${P2PClientState[this.currentState]}`);
+  }
+
+  private async publishStoredTxs() {
+    if (!this.isReady()) {
+      return;
+    }
+
+    const txs = this.txPool.getAllTxs();
+    if (txs.length > 0) {
+      this.log(`Publishing ${txs.length} previously stored txs`);
+      await Promise.all(txs.map(tx => this.p2pService.propagateTx(tx)));
+    }
+  }
+}