@aztec/p2p 0.67.1 → 0.68.0

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,9 +8,9 @@ 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';
+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';
 

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';