@aztec/p2p 0.61.0 → 0.63.0

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -19,7 +19,7 @@ export class AztecKVTxPool implements TxPool {
   /** Index for pending txs. */
   #pendingTxs: AztecSet<string>;
   /** Index for mined txs. */
-  #minedTxs: AztecSet<string>;
+  #minedTxs: AztecMap<string, number>;
 
   #log: Logger;
 
@@ -32,7 +32,7 @@ export class AztecKVTxPool implements TxPool {
    */
   constructor(store: AztecKVStore, telemetry: TelemetryClient, log = createDebugLogger('aztec:tx_pool')) {
     this.#txs = store.openMap('txs');
-    this.#minedTxs = store.openSet('minedTxs');
+    this.#minedTxs = store.openMap('minedTxs');
     this.#pendingTxs = store.openSet('pendingTxs');
 
     this.#store = store;
@@ -40,12 +40,12 @@ export class AztecKVTxPool implements TxPool {
     this.#metrics = new PoolInstrumentation(telemetry, 'AztecKVTxPool');
   }
 
-  public markAsMined(txHashes: TxHash[]): Promise<void> {
+  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     return this.#store.transaction(() => {
       let deleted = 0;
       for (const hash of txHashes) {
         const key = hash.toString();
-        void this.#minedTxs.add(key);
+        void this.#minedTxs.set(key, blockNumber);
         if (this.#pendingTxs.has(key)) {
           deleted++;
           void this.#pendingTxs.delete(key);
@@ -56,12 +56,41 @@ export class AztecKVTxPool implements TxPool {
     });
   }
 
+  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    return this.#store.transaction(() => {
+      let deleted = 0;
+      let added = 0;
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        if (this.#minedTxs.has(key)) {
+          deleted++;
+          void this.#minedTxs.delete(key);
+        }
+
+        if (this.#txs.has(key)) {
+          added++;
+          void this.#pendingTxs.add(key);
+        }
+      }
+
+      this.#metrics.recordRemovedObjects(deleted, 'mined');
+      this.#metrics.recordAddedObjects(added, 'pending');
+    });
+  }
+
   public getPendingTxHashes(): TxHash[] {
     return Array.from(this.#pendingTxs.entries()).map(x => TxHash.fromString(x));
   }
 
-  public getMinedTxHashes(): TxHash[] {
-    return Array.from(this.#minedTxs.entries()).map(x => TxHash.fromString(x));
+  public getMinedTxHashes(): [TxHash, number][] {
+    return Array.from(this.#minedTxs.entries()).map(([txHash, blockNumber]) => [
+      TxHash.fromString(txHash),
+      blockNumber,
+    ]);
   }
 
   public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -14,7 +14,7 @@ export class InMemoryTxPool implements TxPool {
    * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
    */
   private txs: Map<bigint, Tx>;
-  private minedTxs: Set<bigint>;
+  private minedTxs: Map<bigint, number>;
   private pendingTxs: Set<bigint>;
 
   private metrics: PoolInstrumentation<Tx>;
@@ -25,15 +25,15 @@ export class InMemoryTxPool implements TxPool {
    */
   constructor(telemetry: TelemetryClient, private log = createDebugLogger('aztec:tx_pool')) {
     this.txs = new Map<bigint, Tx>();
-    this.minedTxs = new Set();
+    this.minedTxs = new Map();
     this.pendingTxs = new Set();
     this.metrics = new PoolInstrumentation(telemetry, 'InMemoryTxPool');
   }
 
-  public markAsMined(txHashes: TxHash[]): Promise<void> {
+  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     const keys = txHashes.map(x => x.toBigInt());
     for (const key of keys) {
-      this.minedTxs.add(key);
+      this.minedTxs.set(key, blockNumber);
       this.pendingTxs.delete(key);
     }
     this.metrics.recordRemovedObjects(txHashes.length, 'pending');
@@ -41,12 +41,38 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve();
   }
 
+  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    const keys = txHashes.map(x => x.toBigInt());
+    let deleted = 0;
+    let added = 0;
+    for (const key of keys) {
+      if (this.minedTxs.delete(key)) {
+        deleted++;
+      }
+
+      // only add back to the pending set if we have the tx object
+      if (this.txs.has(key)) {
+        added++;
+        this.pendingTxs.add(key);
+      }
+    }
+
+    this.metrics.recordRemovedObjects(deleted, 'mined');
+    this.metrics.recordAddedObjects(added, 'pending');
+
+    return Promise.resolve();
+  }
+
   public getPendingTxHashes(): TxHash[] {
     return Array.from(this.pendingTxs).map(x => TxHash.fromBigInt(x));
   }
 
-  public getMinedTxHashes(): TxHash[] {
-    return Array.from(this.minedTxs).map(x => TxHash.fromBigInt(x));
+  public getMinedTxHashes(): [TxHash, number][] {
+    return Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]);
   }
 
   public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -21,7 +21,14 @@ export interface TxPool {
    * Marks the set of txs as mined, as opposed to pending.
    * @param txHashes - Hashes of the txs to flag as mined.
    */
-  markAsMined(txHashes: TxHash[]): Promise<void>;
+  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+
+  /**
+   * Moves mined txs back to the pending set in the case of a reorg.
+   * Note: txs not known by this peer will be ignored.
+   * @param txHashes - Hashes of the txs to flag as pending.
+   */
+  markMinedAsPending(txHashes: TxHash[]): Promise<void>;
 
   /**
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
@@ -51,7 +58,7 @@ export interface TxPool {
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
    */
-  getMinedTxHashes(): TxHash[];
+  getMinedTxHashes(): [tx: TxHash, blockNumber: number][];
 
   /**
    * Returns whether the given tx hash is flagged as pending or mined.

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -38,14 +38,46 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx2 = mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([tx1.getTxHash()]);
+    await pool.markAsMined([tx1.getTxHash()], 1);
 
     expect(pool.getTxByHash(tx1.getTxHash())).toEqual(tx1);
     expect(pool.getTxStatus(tx1.getTxHash())).toEqual('mined');
-    expect(pool.getMinedTxHashes()).toEqual([tx1.getTxHash()]);
+    expect(pool.getMinedTxHashes()).toEqual([[tx1.getTxHash(), 1]]);
     expect(pool.getPendingTxHashes()).toEqual([tx2.getTxHash()]);
   });
 
+  it('Marks txs as pending after being mined', async () => {
+    const tx1 = mockTx(1);
+    const tx2 = mockTx(2);
+
+    await pool.addTxs([tx1, tx2]);
+    await pool.markAsMined([tx1.getTxHash()], 1);
+
+    await pool.markMinedAsPending([tx1.getTxHash()]);
+    expect(pool.getMinedTxHashes()).toEqual([]);
+    const pending = pool.getPendingTxHashes();
+    expect(pending).toHaveLength(2);
+    expect(pending).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash()]));
+  });
+
+  it('Only marks txs as pending if they are known', async () => {
+    const tx1 = mockTx(1);
+    // simulate a situation where not all peers have all the txs
+    const someTxHashThatThisPeerDidNotSee = mockTx(2).getTxHash();
+    await pool.addTxs([tx1]);
+    // this peer knows that tx2 was mined, but it does not have the tx object
+    await pool.markAsMined([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
+    expect(pool.getMinedTxHashes()).toEqual([
+      [tx1.getTxHash(), 1],
+      [someTxHashThatThisPeerDidNotSee, 1],
+    ]);
+
+    // reorg: both txs should now become available again
+    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    expect(pool.getMinedTxHashes()).toEqual([]);
+    expect(pool.getPendingTxHashes()).toEqual([tx1.getTxHash()]); // tx2 is not in the pool
+  });
+
   it('Returns all transactions in the pool', async () => {
     const tx1 = mockTx(1);
     const tx2 = mockTx(2);

package/src/mocks/index.ts

@@ -4,8 +4,9 @@ import {
   type Tx,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
-import { type DataStoreConfig } from '@aztec/kv-store/utils';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
@@ -90,7 +91,7 @@ export async function createLibp2pNode(
  * Test Libp2p service
  * P2P functionality is operational, however everything else is default
  *
- * WORKTODO: more description
+ *
  */
 export async function createTestLibP2PService(
   boostrapAddrs: string[] = [],
@@ -114,7 +115,7 @@ export async function createTestLibP2PService(
     p2pEnabled: true,
     peerIdPrivateKey: Buffer.from(peerId.privateKey!).toString('hex'),
   } as P2PConfig & DataStoreConfig;
-  const discoveryService = new DiscV5Service(peerId, config);
+  const discoveryService = new DiscV5Service(peerId, config, telemetry);
   const proofVerifier = new AlwaysTrueCircuitVerifier();
 
   // No bootstrap nodes provided as the libp2p service will register them in the constructor
@@ -233,20 +234,27 @@ export function createBootstrapNodeConfig(privateKey: string, port: number): Boo
   };
 }
 
-export function createBootstrapNodeFromPrivateKey(privateKey: string, port: number): Promise<BootstrapNode> {
+export function createBootstrapNodeFromPrivateKey(
+  privateKey: string,
+  port: number,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+): Promise<BootstrapNode> {
   const config = createBootstrapNodeConfig(privateKey, port);
-  return startBootstrapNode(config);
+  return startBootstrapNode(config, telemetry);
 }
 
-export async function createBootstrapNode(port: number): Promise<BootstrapNode> {
+export async function createBootstrapNode(
+  port: number,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+): Promise<BootstrapNode> {
   const peerId = await createLibP2PPeerId();
   const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey!).toString('hex'), port);
 
-  return startBootstrapNode(config);
+  return startBootstrapNode(config, telemetry);
 }
 
-async function startBootstrapNode(config: BootnodeConfig) {
-  const bootstrapNode = new BootstrapNode();
+async function startBootstrapNode(config: BootnodeConfig, telemetry: TelemetryClient) {
+  const bootstrapNode = new BootstrapNode(telemetry);
   await bootstrapNode.start(config);
   return bootstrapNode;
 }

package/src/service/discV5_service.ts

@@ -1,5 +1,6 @@
 import { createDebugLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
+import { OtelMetricsAdapter, type TelemetryClient } from '@aztec/telemetry-client';
 
 import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
 import { ENR, SignableENR } from '@chainsafe/enr';
@@ -41,7 +42,12 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private startTime = 0;
 
-  constructor(private peerId: PeerId, config: P2PConfig, private logger = createDebugLogger('aztec:discv5_service')) {
+  constructor(
+    private peerId: PeerId,
+    config: P2PConfig,
+    telemetry: TelemetryClient,
+    private logger = createDebugLogger('aztec:discv5_service'),
+  ) {
     super();
     const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
     this.bootstrapNodes = bootstrapNodes;
@@ -66,14 +72,17 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.enr.setLocationMultiaddr(multiAddrUdp);
     this.enr.setLocationMultiaddr(multiAddrTcp);
 
+    const metricsRegistry = new OtelMetricsAdapter(telemetry);
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,
       bindAddrs: { ip4: listenMultiAddrUdp },
       config: {
         lookupTimeout: 2000,
+        requestTimeout: 2000,
         allowUnverifiedSessions: true,
       },
+      metricsRegistry,
     });
 
     this.logger.info(`ENR NodeId: ${this.enr.nodeId}`);

package/src/service/libp2p_service.ts

@@ -12,13 +12,14 @@ import {
   Tx,
   TxHash,
   type WorldStateSynchronizer,
+  metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import type { AztecKVStore } from '@aztec/kv-store';
-import { Attributes, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
+import { Attributes, OtelMetricsAdapter, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
 
 import { type ENR } from '@chainsafe/enr';
 import { type GossipSub, type GossipSubComponents, gossipsub } from '@chainsafe/libp2p-gossipsub';
@@ -218,6 +219,8 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     const datastore = new AztecDatastore(store);
 
+    const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
+
     const node = await createLibp2p({
       start: false,
       peerId,
@@ -257,6 +260,8 @@ export class LibP2PService extends WithTracer implements P2PService {
           heartbeatInterval: config.gossipsubInterval,
           mcacheLength: config.gossipsubMcacheLength,
           mcacheGossip: config.gossipsubMcacheGossip,
+          metricsRegister: otelMetricsAdapter,
+          metricsTopicStrToLabel: metricsTopicStrToLabels(),
           scoreParams: createPeerScoreParams({
             topics: {
               [Tx.p2pTopic]: createTopicScoreParams({

package/src/tx_validator/double_spend_validator.ts

@@ -36,7 +36,9 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
-    const nullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
+    const nullifiers = (tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers).map(x =>
+      x.toBigInt(),
+    );
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers);

package/src/tx_validator/metadata_validator.ts

@@ -45,11 +45,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   #isValidForBlockNumber(tx: T): boolean {
-    const target =
-      tx instanceof Tx
-        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
-        : tx.data.rollupValidationRequests;
-    const maxBlockNumber = target.maxBlockNumber;
+    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
       this.#log.warn(

package/src/util.ts

@@ -1,4 +1,4 @@
-import { type DataStoreConfig } from '@aztec/kv-store/utils';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
 
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
 import { resolve } from 'dns/promises';