@aztec/p2p 0.76.4-devnet-test → 0.76.4-devnet-test-rc3

package/src/client/p2p_client.ts

@@ -1,6 +1,7 @@
 import {
   type BlockAttestation,
   type BlockProposal,
+  type EpochProofQuote,
   type L2Block,
   type L2BlockId,
   type L2BlockSource,
@@ -29,6 +30,7 @@ import { type ENR } from '@chainsafe/enr';
 
 import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
 import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type MemPools } from '../mem_pools/interface.js';
 import { type TxPool } from '../mem_pools/tx_pool/index.js';
 import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
@@ -70,6 +72,21 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = ProverCoordinati
      */
     broadcastProposal(proposal: BlockProposal): void;
 
+    /**
+     * Queries the EpochProofQuote pool for quotes for the given epoch
+     *
+     * @param epoch  - the epoch to query
+     * @returns EpochProofQuotes
+     */
+    getEpochProofQuotes(epoch: bigint): Promise<EpochProofQuote[]>;
+
+    /**
+     * Adds an EpochProofQuote to the pool and broadcasts an EpochProofQuote to other peers.
+     *
+     * @param quote - the quote to broadcast
+     */
+    addEpochProofQuote(quote: EpochProofQuote): Promise<void>;
+
     /**
      * Registers a callback from the validator client that determines how to behave when
      * foreign block proposals are received
@@ -194,6 +211,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
   private txPool: TxPool;
   private attestationPool: T extends P2PClientType.Full ? AttestationPool : undefined;
+  private epochProofQuotePool: EpochProofQuotePool;
 
   /** How many slots to keep attestations for. */
   private keepAttestationsInPoolFor: number;
@@ -242,6 +260,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
 
     this.txPool = mempools.txPool;
+    this.epochProofQuotePool = mempools.epochProofQuotePool;
     this.attestationPool = mempools.attestationPool!;
   }
 
@@ -318,6 +337,26 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     }
   }
 
+  /**
+   * Adds an EpochProofQuote to the pool and broadcasts an EpochProofQuote to other peers.
+   * @param quote - the quote to broadcast
+   */
+  addEpochProofQuote(quote: EpochProofQuote): Promise<void> {
+    this.epochProofQuotePool.addQuote(quote);
+    this.broadcastEpochProofQuote(quote);
+    return Promise.resolve();
+  }
+
+  getEpochProofQuotes(epoch: bigint): Promise<EpochProofQuote[]> {
+    return Promise.resolve(this.epochProofQuotePool.getQuotes(epoch));
+  }
+
+  broadcastEpochProofQuote(quote: EpochProofQuote): void {
+    this.#assertIsReady();
+    this.log.info('Broadcasting epoch proof quote', quote.toViemArgs());
+    return this.p2pService.propagate(quote);
+  }
+
   /**
    * Starts the P2P client.
    * @returns An empty promise signalling the synching process.
@@ -692,6 +731,11 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlotMinusKeepAttestationsInPoolFor);
     }
 
+    const provenEpochNumber = await this.l2BlockSource.getProvenL2EpochNumber();
+    if (provenEpochNumber !== undefined) {
+      this.epochProofQuotePool.deleteQuotesToEpoch(BigInt(provenEpochNumber));
+    }
+
     await this.synchedProvenBlockNumber.set(lastBlockNum);
     this.log.debug(`Synched to proven block ${lastBlockNum}`);
 

package/src/index.ts

@@ -1,7 +1,8 @@
+export * from './mem_pools/attestation_pool/index.js';
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
 export * from './config.js';
-export * from './mem_pools/attestation_pool/index.js';
+export * from './mem_pools/epoch_proof_quote_pool/index.js';
+export * from './services/index.js';
 export * from './mem_pools/tx_pool/index.js';
 export * from './msg_validators/index.js';
-export * from './services/index.js';

package/src/mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.ts

@@ -0,0 +1,7 @@
+import { type EpochProofQuote } from '@aztec/circuit-types';
+
+export interface EpochProofQuotePool {
+  addQuote(quote: EpochProofQuote): void;
+  getQuotes(epoch: bigint): EpochProofQuote[];
+  deleteQuotesToEpoch(epoch: bigint): void;
+}

package/src/mem_pools/epoch_proof_quote_pool/index.ts

@@ -0,0 +1,3 @@
+export * from './epoch_proof_quote_pool.js';
+export * from './memory_epoch_proof_quote_pool.js';
+export * from './test_utils.js';

package/src/mem_pools/epoch_proof_quote_pool/memory_epoch_proof_quote_pool.ts

@@ -0,0 +1,41 @@
+import { type EpochProofQuote } from '@aztec/circuit-types';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { type EpochProofQuotePool } from './epoch_proof_quote_pool.js';
+
+export class MemoryEpochProofQuotePool implements EpochProofQuotePool {
+  private quotes: Map<bigint, EpochProofQuote[]>;
+  private metrics: PoolInstrumentation<EpochProofQuote>;
+
+  constructor(telemetry: TelemetryClient = getTelemetryClient()) {
+    this.quotes = new Map();
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.EPOCH_PROOF_QUOTE_POOL);
+  }
+
+  addQuote(quote: EpochProofQuote) {
+    const epoch = quote.payload.epochToProve;
+    if (!this.quotes.has(epoch)) {
+      this.quotes.set(epoch, []);
+    }
+    this.quotes.get(epoch)!.push(quote);
+
+    this.metrics.recordAddedObjects(1);
+  }
+  getQuotes(epoch: bigint): EpochProofQuote[] {
+    return this.quotes.get(epoch) || [];
+  }
+  deleteQuotesToEpoch(epoch: bigint): void {
+    const expiredEpochs = Array.from(this.quotes.keys()).filter(k => k <= epoch);
+
+    let removedObjectsCount = 0;
+    for (const expiredEpoch of expiredEpochs) {
+      // For logging
+      removedObjectsCount += this.quotes.get(expiredEpoch)?.length || 0;
+
+      this.quotes.delete(expiredEpoch);
+    }
+
+    this.metrics.recordRemovedObjects(removedObjectsCount);
+  }
+}

package/src/mem_pools/epoch_proof_quote_pool/test_utils.ts

@@ -0,0 +1,26 @@
+import { EpochProofQuote, EpochProofQuotePayload } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Secp256k1Signer, randomBigInt, randomInt } from '@aztec/foundation/crypto';
+
+export function makeRandomEpochProofQuotePayload(): EpochProofQuotePayload {
+  return EpochProofQuotePayload.from({
+    basisPointFee: randomInt(10000),
+    bondAmount: 1000000000000000000n,
+    epochToProve: randomBigInt(1000000n),
+    prover: EthAddress.random(),
+    validUntilSlot: randomBigInt(1000000n),
+  });
+}
+
+export function makeRandomEpochProofQuote(payload?: EpochProofQuotePayload): {
+  quote: EpochProofQuote;
+  signer: Secp256k1Signer;
+} {
+  const signer = Secp256k1Signer.random();
+
+  return {
+    quote: EpochProofQuote.new(Buffer32.random(), payload ?? makeRandomEpochProofQuotePayload(), signer),
+    signer,
+  };
+}

package/src/mem_pools/index.ts

@@ -1,3 +1,4 @@
+export { TxPool } from './tx_pool/tx_pool.js';
 export { AttestationPool } from './attestation_pool/attestation_pool.js';
+export { EpochProofQuotePool } from './epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 export { type MemPools } from './interface.js';
-export { TxPool } from './tx_pool/tx_pool.js';

package/src/mem_pools/instrumentation.ts

@@ -12,6 +12,7 @@ import {
 export enum PoolName {
   TX_POOL = 'TxPool',
   ATTESTATION_POOL = 'AttestationPool',
+  EPOCH_PROOF_QUOTE_POOL = 'EpochProofQuotePool',
 }
 
 type MetricsLabels = {
@@ -35,6 +36,11 @@ function getMetricsLabels(name: PoolName): MetricsLabels {
       objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
       objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
     };
+  } else if (name === PoolName.EPOCH_PROOF_QUOTE_POOL) {
+    return {
+      objectInMempool: Metrics.MEMPOOL_PROVER_QUOTE_COUNT,
+      objectSize: Metrics.MEMPOOL_PROVER_QUOTE_SIZE,
+    };
   }
 
   throw new Error('Invalid pool type');

package/src/mem_pools/interface.ts

@@ -1,6 +1,7 @@
 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';
 
 /**
@@ -9,4 +10,5 @@ import { type TxPool } from './tx_pool/tx_pool.js';
 export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
   txPool: TxPool;
   attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+  epochProofQuotePool: EpochProofQuotePool;
 };

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 EpochCacheInterface } from '@aztec/epoch-cache';
+
+export class EpochProofQuoteValidator implements P2PValidator<EpochProofQuote> {
+  private epochCache: EpochCacheInterface;
+
+  constructor(epochCache: EpochCacheInterface) {
+    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/services/libp2p/libp2p_service.ts

@@ -2,6 +2,7 @@ import {
   BlockAttestation,
   BlockProposal,
   type ClientProtocolCircuitVerifier,
+  EpochProofQuote,
   type Gossipable,
   type L2BlockSource,
   MerkleTreeId,
@@ -47,6 +48,7 @@ import { createLibp2p } from 'libp2p';
 
 import { type P2PConfig } from '../../config.js';
 import { type MemPools } from '../../mem_pools/interface.js';
+import { EpochProofQuoteValidator } from '../../msg_validators/epoch_proof_quote_validator/index.js';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
 import {
   DataTxValidator,
@@ -93,6 +95,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   // Message validators
   private attestationValidator: AttestationValidator;
   private blockProposalValidator: BlockProposalValidator;
+  private epochProofQuoteValidator: EpochProofQuoteValidator;
 
   // Request and response sub service
   public reqresp: ReqResp;
@@ -140,6 +143,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
 
     this.attestationValidator = new AttestationValidator(epochCache);
     this.blockProposalValidator = new BlockProposalValidator(epochCache);
+    this.epochProofQuoteValidator = new EpochProofQuoteValidator(epochCache);
 
     this.blockReceivedCallback = async (block: BlockProposal): Promise<BlockAttestation | undefined> => {
       this.logger.warn(
@@ -261,6 +265,11 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
                 invalidMessageDeliveriesWeight: -20,
                 invalidMessageDeliveriesDecay: 0.5,
               }),
+              [EpochProofQuote.p2pTopic]: createTopicScoreParams({
+                topicWeight: 1,
+                invalidMessageDeliveriesWeight: -20,
+                invalidMessageDeliveriesDecay: 0.5,
+              }),
             },
           }),
         }) as (components: GossipSubComponents) => GossipSub,
@@ -334,6 +343,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       [Tx.p2pTopic]: this.validatePropagatedTxFromMessage.bind(this),
       [BlockAttestation.p2pTopic]: this.validatePropagatedAttestationFromMessage.bind(this),
       [BlockProposal.p2pTopic]: this.validatePropagatedBlockFromMessage.bind(this),
+      [EpochProofQuote.p2pTopic]: this.validatePropagatedEpochProofQuoteFromMessage.bind(this),
     };
     // When running bandwidth benchmarks, we use send blobs of data we do not want to validate
     // NEVER switch this off in production
@@ -497,6 +507,10 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       const block = BlockProposal.fromBuffer(Buffer.from(message.data));
       await this.processBlockFromPeer(block);
     }
+    if (message.topic == EpochProofQuote.p2pTopic) {
+      const epochProofQuote = EpochProofQuote.fromBuffer(Buffer.from(message.data));
+      await this.processEpochProofQuoteFromPeer(epochProofQuote);
+    }
 
     return;
   }
@@ -580,6 +594,17 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     await this.propagate(attestation);
   }
 
+  private async processEpochProofQuoteFromPeer(epochProofQuote: EpochProofQuote) {
+    const epoch = epochProofQuote.payload.epochToProve;
+    const prover = epochProofQuote.payload.prover.toString();
+    const p2pMessageIdentifier = await epochProofQuote.p2pMessageIdentifier();
+    this.logger.verbose(
+      `Received epoch proof quote ${p2pMessageIdentifier} by prover ${prover} for epoch ${epoch} from external peer.`,
+      { quote: epochProofQuote.toInspect(), p2pMessageIdentifier },
+    );
+    this.mempools.epochProofQuotePool.addQuote(epochProofQuote);
+  }
+
   /**
    * Propagates provided message to peers.
    * @param message - The message to propagate.
@@ -693,6 +718,25 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
   }
 
+  /**
+   * Validate an epoch proof quote from a peer.
+   * @param propagationSource - The peer ID of the peer that sent the epoch proof quote.
+   * @param msg - The epoch proof quote message.
+   * @returns True if the epoch proof quote is valid, false otherwise.
+   */
+  private async validatePropagatedEpochProofQuoteFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const epochProofQuote = EpochProofQuote.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validateEpochProofQuote(propagationSource, epochProofQuote);
+    this.logger.trace(`validatePropagatedEpochProofQuote: ${isValid}`, {
+      [Attributes.EPOCH_NUMBER]: epochProofQuote.payload.epochToProve.toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
   @trackSpan('Libp2pService.validatePropagatedTx', async tx => ({
     [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
@@ -864,6 +908,25 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return true;
   }
 
+  /**
+   * Validate an epoch proof quote.
+   *
+   * @param epochProofQuote - The epoch proof quote to validate.
+   * @returns True if the epoch proof quote is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validateEpochProofQuote', (_peerId, epochProofQuote) => ({
+    [Attributes.EPOCH_NUMBER]: epochProofQuote.payload.epochToProve.toString(),
+  }))
+  public async validateEpochProofQuote(peerId: PeerId, epochProofQuote: EpochProofQuote): Promise<boolean> {
+    const severity = await this.epochProofQuoteValidator.validate(epochProofQuote);
+    if (severity) {
+      this.peerManager.penalizePeer(peerId, severity);
+      return false;
+    }
+
+    return true;
+  }
+
   public getPeerScore(peerId: PeerId): number {
     return this.node.services.pubsub.score.score(peerId.toString());
   }

package/src/test-helpers/make-test-p2p-clients.ts

@@ -9,6 +9,7 @@ import { createP2PClient } from '../client/index.js';
 import { type P2PClient } from '../client/p2p_client.js';
 import { type P2PConfig } from '../config.js';
 import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type TxPool } from '../mem_pools/tx_pool/index.js';
 import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
 import { getPorts } from './get-ports.js';
@@ -17,6 +18,7 @@ import { AlwaysFalseCircuitVerifier, AlwaysTrueCircuitVerifier } from './reqresp
 
 interface MakeTestP2PClientOptions {
   mockAttestationPool: AttestationPool;
+  mockEpochProofQuotePool: EpochProofQuotePool;
   mockTxPool: TxPool;
   mockEpochCache: EpochCache;
   mockWorldState: WorldStateSynchronizer;
@@ -43,6 +45,7 @@ export async function makeTestP2PClient(
     p2pBaseConfig,
     p2pConfigOverrides = {},
     mockAttestationPool,
+    mockEpochProofQuotePool,
     mockTxPool,
     mockEpochCache,
     mockWorldState,
@@ -76,6 +79,7 @@ export async function makeTestP2PClient(
   const deps = {
     txPool: mockTxPool as unknown as TxPool,
     attestationPool: mockAttestationPool as unknown as AttestationPool,
+    epochProofQuotePool: mockEpochProofQuotePool as unknown as EpochProofQuotePool,
     store: kvStore,
     logger,
   };

package/src/testbench/p2p_client_testbench_worker.ts

@@ -15,6 +15,7 @@ import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { type P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
 import { type AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import { type EpochProofQuotePool } from '../mem_pools/epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 import { type TxPool } from '../mem_pools/tx_pool/index.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
 
@@ -47,6 +48,14 @@ function mockAttestationPool(): AttestationPool {
   };
 }
 
+function mockEpochProofQuotePool(): EpochProofQuotePool {
+  return {
+    addQuote: () => {},
+    getQuotes: () => [],
+    deleteQuotesToEpoch: () => {},
+  };
+}
+
 function mockEpochCache(): EpochCacheInterface {
   return {
     getCommittee: () => Promise.resolve([] as EthAddress[]),
@@ -72,6 +81,7 @@ process.on('message', async msg => {
     if (type === 'START') {
       const txPool = mockTxPool();
       const attestationPool = mockAttestationPool();
+      const epochProofQuotePool = mockEpochProofQuotePool();
       const epochCache = mockEpochCache();
       const worldState = {} as WorldStateSynchronizer;
       const l2BlockSource = new MockL2BlockSource();
@@ -84,6 +94,7 @@ process.on('message', async msg => {
       const deps = {
         txPool,
         attestationPool,
+        epochProofQuotePool,
         store: kvStore,
         logger,
       };