@aztec/p2p 0.67.1 → 0.68.1

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -0,0 +1,153 @@
+import { BlockAttestation } from '@aztec/circuit-types';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { type AztecKVStore, type AztecMapWithSize, type AztecMultiMap } from '@aztec/kv-store';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { type AttestationPool } from './attestation_pool.js';
+
+export class KvAttestationPool implements AttestationPool {
+  private metrics: PoolInstrumentation<BlockAttestation>;
+
+  // Index of all proposal ids in a slot
+  private attestations: AztecMultiMap<string, string>;
+
+  constructor(
+    private store: AztecKVStore,
+    telemetry: TelemetryClient,
+    private log = createLogger('aztec:attestation_pool'),
+  ) {
+    this.attestations = store.openMultiMap('attestations');
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+  }
+
+  private getProposalMapKey(slot: string, proposalId: string): string {
+    return `proposal-${slot}-${proposalId}`;
+  }
+
+  /**
+   * Get the proposal map for a given slot and proposalId
+   *
+   * Essentially a nested mapping of address -> attestation
+   *
+   * @param slot - The slot to get the proposal map for
+   * @param proposalId - The proposalId to get the map for
+   * @returns The proposal map
+   */
+  private getProposalMap(slot: string, proposalId: string): AztecMapWithSize<string, Buffer> {
+    const mapKey = this.getProposalMapKey(slot, proposalId);
+    return this.store.openMapWithSize(mapKey);
+  }
+
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
+      const proposalId = attestation.archive.toString();
+      const address = attestation.getSender().toString();
+
+      // Index the proposalId in the slot map
+      await this.attestations.set(slotNumber, proposalId);
+
+      // Store the actual attestation in the proposal map
+      const proposalMap = this.getProposalMap(slotNumber, proposalId);
+      await proposalMap.set(address, attestation.toBuffer());
+
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+    }
+
+    this.metrics.recordAddedObjects(attestations.length);
+  }
+
+  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+    const slotNumber = new Fr(slot).toString();
+    const proposalMap = this.getProposalMap(slotNumber, proposalId);
+    const attestations = proposalMap.values();
+    const attestationsArray = Array.from(attestations).map(attestation => BlockAttestation.fromBuffer(attestation));
+    return Promise.resolve(attestationsArray);
+  }
+
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = [];
+
+    const slots = this.attestations.keys();
+    for (const slot of slots) {
+      if (BigInt(slot) < oldestSlot) {
+        olderThan.push(slot);
+      }
+    }
+
+    await Promise.all(olderThan.map(oldSlot => this.deleteAttestationsForSlot(BigInt(oldSlot))));
+    return Promise.resolve();
+  }
+
+  public async deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    const deletionPromises = [];
+
+    const slotString = new Fr(slot).toString();
+    let numberOfAttestations = 0;
+    const proposalIds = this.attestations.getValues(slotString);
+
+    if (proposalIds) {
+      for (const proposalId of proposalIds) {
+        const proposalMap = this.getProposalMap(slotString, proposalId);
+        numberOfAttestations += proposalMap.size();
+        deletionPromises.push(proposalMap.clear());
+      }
+    }
+
+    await Promise.all(deletionPromises);
+
+    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+    this.metrics.recordRemovedObjects(numberOfAttestations);
+    return Promise.resolve();
+  }
+
+  public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+    const deletionPromises = [];
+
+    const slotString = new Fr(slot).toString();
+    const exists = this.attestations.get(slotString);
+
+    if (exists) {
+      // Remove the proposalId from the slot index
+      deletionPromises.push(this.attestations.deleteValue(slotString, proposalId));
+
+      // Delete all attestations for the proposalId
+      const proposalMap = this.getProposalMap(slotString, proposalId);
+      const numberOfAttestations = proposalMap.size();
+      deletionPromises.push(proposalMap.clear());
+
+      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+      this.metrics.recordRemovedObjects(numberOfAttestations);
+    }
+
+    await Promise.all(deletionPromises);
+    return Promise.resolve();
+  }
+
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+    const deletionPromises = [];
+
+    for (const attestation of attestations) {
+      const slotNumber = attestation.payload.header.globalVariables.slotNumber.toString();
+      const proposalId = attestation.archive.toString();
+      const proposalMap = this.getProposalMap(slotNumber, proposalId);
+
+      if (proposalMap) {
+        const address = attestation.getSender().toString();
+        deletionPromises.push(proposalMap.delete(address));
+        this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+      }
+
+      if (proposalMap.size() === 0) {
+        deletionPromises.push(this.attestations.deleteValue(slotNumber, proposalId));
+      }
+    }
+
+    await Promise.all(deletionPromises);
+
+    this.metrics.recordRemovedObjects(attestations.length);
+    return Promise.resolve();
+  }
+}

package/src/mem_pools/interface.ts

@@ -1,3 +1,5 @@
+import { type P2PClientType } from '@aztec/circuit-types';
+
 import { type AttestationPool } from './attestation_pool/attestation_pool.js';
 import { type EpochProofQuotePool } from './epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type TxPool } from './tx_pool/tx_pool.js';
@@ -5,8 +7,8 @@ import { type TxPool } from './tx_pool/tx_pool.js';
 /**
  * A interface the combines all mempools
  */
-export interface MemPools {
+export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
   txPool: TxPool;
-  attestationPool: AttestationPool;
+  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   epochProofQuotePool: EpochProofQuotePool;
-}
+};

package/src/mocks/index.ts

@@ -1,9 +1,11 @@
 import {
   type ClientProtocolCircuitVerifier,
   type L2BlockSource,
+  type P2PClientType,
   type Tx,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { type TelemetryClient } from '@aztec/telemetry-client';
@@ -23,11 +25,11 @@ import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 import { BootstrapNode } from '../bootstrap/bootstrap.js';
 import { type BootnodeConfig, type P2PConfig } from '../config.js';
 import { type MemPools } from '../mem_pools/interface.js';
-import { DiscV5Service } from '../service/discV5_service.js';
-import { LibP2PService } from '../service/libp2p_service.js';
-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 { DiscV5Service } from '../services/discv5/discV5_service.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import { type PeerManager } from '../services/peer_manager.js';
+import { type P2PReqRespConfig } from '../services/reqresp/config.js';
+import { pingHandler, statusHandler } from '../services/reqresp/handlers.js';
 import {
   PING_PROTOCOL,
   type ReqRespSubProtocolHandlers,
@@ -35,8 +37,8 @@ import {
   STATUS_PROTOCOL,
   TX_REQ_PROTOCOL,
   noopValidator,
-} from '../service/reqresp/interface.js';
-import { ReqResp } from '../service/reqresp/reqresp.js';
+} from '../services/reqresp/interface.js';
+import { ReqResp } from '../services/reqresp/reqresp.js';
 import { type PubSubLibp2p } from '../util.js';
 
 /**
@@ -95,11 +97,13 @@ export async function createLibp2pNode(
  *
  *
  */
-export async function createTestLibP2PService(
+export async function createTestLibP2PService<T extends P2PClientType>(
+  clientType: T,
   boostrapAddrs: string[] = [],
   l2BlockSource: L2BlockSource,
   worldStateSynchronizer: WorldStateSynchronizer,
-  mempools: MemPools,
+  epochCache: EpochCache,
+  mempools: MemPools<T>,
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,
@@ -123,12 +127,14 @@ export async function createTestLibP2PService(
   // No bootstrap nodes provided as the libp2p service will register them in the constructor
   const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
 
-  return new LibP2PService(
+  return new LibP2PService<T>(
+    clientType,
     config,
     p2pNode as PubSubLibp2p,
     discoveryService,
     mempools,
     l2BlockSource,
+    epochCache,
     proofVerifier,
     worldStateSynchronizer,
     telemetry,

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -0,0 +1,26 @@
+import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
+
+export class AttestationValidator implements P2PValidator<BlockAttestation> {
+  private epochCache: EpochCache;
+
+  constructor(epochCache: EpochCache) {
+    this.epochCache = epochCache;
+  }
+
+  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+    const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+
+    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
+    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    const attester = message.getSender();
+    if (!(await this.epochCache.isInCommittee(attester))) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/attestation_validator/index.ts

@@ -0,0 +1 @@
+export * from './attestation_validator.js';

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -0,0 +1,29 @@
+import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
+
+export class BlockProposalValidator implements P2PValidator<BlockProposal> {
+  private epochCache: EpochCache;
+
+  constructor(epochCache: EpochCache) {
+    this.epochCache = epochCache;
+  }
+
+  async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
+    const { currentProposer, nextProposer, currentSlot, nextSlot } =
+      await this.epochCache.getProposerInCurrentOrNextSlot();
+
+    // Check that the attestation is for the current or next slot
+    const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
+    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    // Check that the block proposal is from the current or next proposer
+    const proposer = block.getSender();
+    if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/block_proposal_validator/index.ts

@@ -0,0 +1 @@
+export * from './block_proposal_validator.js';

package/src/msg_validators/epoch_proof_quote_validator/epoch_proof_quote_validator.ts

@@ -0,0 +1,22 @@
+import { type EpochProofQuote, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
+import { type EpochCache } from '@aztec/epoch-cache';
+
+export class EpochProofQuoteValidator implements P2PValidator<EpochProofQuote> {
+  private epochCache: EpochCache;
+
+  constructor(epochCache: EpochCache) {
+    this.epochCache = epochCache;
+  }
+
+  validate(message: EpochProofQuote): Promise<PeerErrorSeverity | undefined> {
+    const { epoch } = this.epochCache.getEpochAndSlotNow();
+
+    // Check that the epoch proof quote is for the current epoch
+    const epochToProve = message.payload.epochToProve;
+    if (epochToProve !== epoch && epochToProve !== epoch - 1n) {
+      return Promise.resolve(PeerErrorSeverity.HighToleranceError);
+    }
+
+    return Promise.resolve(undefined);
+  }
+}

package/src/msg_validators/epoch_proof_quote_validator/index.ts

@@ -0,0 +1 @@
+export { EpochProofQuoteValidator } from './epoch_proof_quote_validator.js';

package/src/msg_validators/index.ts

@@ -0,0 +1,3 @@
+export * from './tx_validator/index.js';
+export * from './block_proposal_validator/index.js';
+export * from './attestation_validator/index.js';

package/src/{tx_validator → msg_validators/tx_validator}/aggregate_tx_validator.ts

@@ -10,16 +10,18 @@ export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValid
     this.#validators = validators;
   }
 
-  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[], skippedTxs: T[]]> {
     const invalidTxs: T[] = [];
+    const skippedTxs: T[] = [];
     let txPool = txs;
     for (const validator of this.#validators) {
-      const [valid, invalid] = await validator.validateTxs(txPool);
+      const [valid, invalid, skipped] = await validator.validateTxs(txPool);
       invalidTxs.push(...invalid);
+      skippedTxs.push(...(skipped ?? []));
       txPool = valid;
     }
 
-    return [txPool, invalidTxs];
+    return [txPool, invalidTxs, skippedTxs];
   }
 
   async validateTx(tx: T): Promise<boolean> {

package/src/{tx_validator → msg_validators/tx_validator}/double_spend_validator.ts

@@ -1,9 +1,8 @@
 import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 
 export interface NullifierSource {
-  getNullifierIndex: (nullifier: Fr) => Promise<bigint | undefined>;
+  getNullifierIndices: (nullifiers: Buffer[]) => Promise<(bigint | undefined)[]>;
 }
 
 export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
@@ -36,9 +35,7 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
-    const nullifiers = (tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers).map(x =>
-      x.toBigInt(),
-    );
+    const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers);
@@ -49,16 +46,17 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
 
     if (this.isValidatingBlock) {
       for (const nullifier of nullifiers) {
-        if (thisBlockNullifiers.has(nullifier)) {
+        const nullifierBigInt = nullifier.toBigInt();
+        if (thisBlockNullifiers.has(nullifierBigInt)) {
           this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier in the same block`);
           return false;
         }
 
-        thisBlockNullifiers.add(nullifier);
+        thisBlockNullifiers.add(nullifierBigInt);
       }
     }
 
-    const nullifierIndexes = await Promise.all(nullifiers.map(n => this.#nullifierSource.getNullifierIndex(new Fr(n))));
+    const nullifierIndexes = await this.#nullifierSource.getNullifierIndices(nullifiers.map(n => n.toBuffer()));
 
     const hasDuplicates = nullifierIndexes.some(index => index !== undefined);
     if (hasDuplicates) {

package/src/{service → services/discv5}/discV5_service.ts

@@ -8,29 +8,19 @@ import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
-import type { P2PConfig } from '../config.js';
-import { convertToMultiaddr } from '../util.js';
-import { type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
-
-export const AZTEC_ENR_KEY = 'aztec_network';
+import type { P2PConfig } from '../../config.js';
+import { convertToMultiaddr } from '../../util.js';
+import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
+import { AZTEC_ENR_KEY, AZTEC_NET, Discv5Event, PeerEvent } from '../types.js';
 
 const delayBeforeStart = 2000; // 2sec
 
-export enum AztecENR {
-  devnet = 0x01,
-  testnet = 0x02,
-  mainnet = 0x03,
-}
-
-// TODO: Make this an env var
-export const AZTEC_NET = AztecENR.devnet;
-
 /**
  * Peer discovery service using Discv5.
  */
 export class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
   /** The Discv5 instance */
-  private discv5: Discv5;
+  private discv5: Discv5 & Discv5EventEmitter;
 
   /** This instance's ENR */
   private enr: SignableENR;
@@ -88,13 +78,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       metricsRegistry,
     });
 
-    (this.discv5 as Discv5EventEmitter).on('discovered', (enr: ENR) => this.onDiscovered(enr));
-    (this.discv5 as Discv5EventEmitter).on('enrAdded', async (enr: ENR) => {
-      const multiAddrTcp = await enr.getFullMultiaddr('tcp');
-      const multiAddrUdp = await enr.getFullMultiaddr('udp');
-      this.logger.debug(`Added ENR ${enr.encodeTxt()}`, { multiAddrTcp, multiAddrUdp, nodeId: enr.nodeId });
-      this.onDiscovered(enr);
-    });
+    this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
+    this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
   }
 
   public async start(): Promise<void> {
@@ -168,10 +153,21 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   public async stop(): Promise<void> {
+    await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
+    await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+
     await this.discv5.stop();
+
     this.currentState = PeerDiscoveryState.STOPPED;
   }
 
+  private async onEnrAdded(enr: ENR) {
+    const multiAddrTcp = await enr.getFullMultiaddr('tcp');
+    const multiAddrUdp = await enr.getFullMultiaddr('udp');
+    this.logger.debug(`Added ENR ${enr.encodeTxt()}`, { multiAddrTcp, multiAddrUdp, nodeId: enr.nodeId });
+    this.onDiscovered(enr);
+  }
+
   private onDiscovered(enr: ENR) {
     // check the peer is an aztec peer
     const value = enr.kvs.get(AZTEC_ENR_KEY);
@@ -179,7 +175,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       const network = value[0];
       // check if the peer is on the same network
       if (network === AZTEC_NET) {
-        this.emit('peer:discovered', enr);
+        this.emit(PeerEvent.DISCOVERED, enr);
       }
     }
   }

package/src/{service → services}/encoding.ts

@@ -49,13 +49,31 @@ export function getMsgIdFn(message: Message) {
   return sha256(Buffer.concat(vec)).subarray(0, 20);
 }
 
+/**
+ * Snappy transform for libp2p gossipsub
+ */
 export class SnappyTransform implements DataTransform {
+  // Topic string included to satisfy DataTransform interface
   inboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    const uncompressed = Buffer.from(uncompressSync(Buffer.from(data), { asBuffer: true }));
-    return new Uint8Array(uncompressed);
+    return this.inboundTransformNoTopic(Buffer.from(data));
+  }
+
+  public inboundTransformNoTopic(data: Buffer): Buffer {
+    if (data.length === 0) {
+      return data;
+    }
+    return Buffer.from(uncompressSync(data, { asBuffer: true }));
   }
 
+  // Topic string included to satisfy DataTransform interface
   outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    return new Uint8Array(compressSync(Buffer.from(data)));
+    return this.outboundTransformNoTopic(Buffer.from(data));
+  }
+
+  public outboundTransformNoTopic(data: Buffer): Buffer {
+    if (data.length === 0) {
+      return data;
+    }
+    return Buffer.from(compressSync(data));
   }
 }

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './libp2p/libp2p_service.js';