@aztec/p2p 0.83.1 → 0.84.0

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -0,0 +1,104 @@
+import { createLogger } from '@aztec/foundation/log';
+import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import {
+  type PublicCallRequestWithCalldata,
+  Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log = createLogger('sequencer:tx_validator:tx_phases');
+  private contractsDB: PublicContractsDB;
+
+  constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[], private blockNumber: number) {
+    this.contractsDB = new PublicContractsDB(contracts);
+  }
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    try {
+      // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+      // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+      // which is what we're trying to do as part of the current txs.
+      await this.contractsDB.addNewContracts(tx);
+
+      if (!tx.data.forPublic) {
+        this.#log.debug(
+          `Tx ${await Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`,
+        );
+        return { result: 'valid' };
+      }
+
+      const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+      for (const setupFn of setupFns) {
+        if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
+          this.#log.warn(
+            `Rejecting tx ${await Tx.getHash(tx)} because it calls setup function not on allow list: ${
+              setupFn.request.contractAddress
+            }:${setupFn.functionSelector}`,
+            { allowList: this.setupAllowList },
+          );
+
+          return { result: 'invalid', reason: ['Setup function not on allow list'] };
+        }
+      }
+
+      return { result: 'valid' };
+    } finally {
+      this.contractsDB.clearContractsForTx();
+    }
+  }
+
+  private async isOnAllowList(
+    publicCall: PublicCallRequestWithCalldata,
+    allowList: AllowedElement[],
+  ): Promise<boolean> {
+    if (publicCall.isEmpty()) {
+      return true;
+    }
+
+    const contractAddress = publicCall.request.contractAddress;
+    const functionSelector = publicCall.functionSelector;
+
+    // do these checks first since they don't require the contract class
+    for (const entry of allowList) {
+      if ('address' in entry && !('selector' in entry)) {
+        if (contractAddress.equals(entry.address)) {
+          return true;
+        }
+      }
+
+      if ('address' in entry && 'selector' in entry) {
+        if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+          return true;
+        }
+      }
+
+      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.blockNumber);
+
+      if (!contractClass) {
+        throw new Error(`Contract not found: ${contractAddress}`);
+      }
+
+      if ('classId' in entry && !('selector' in entry)) {
+        if (contractClass.currentContractClassId.equals(entry.classId)) {
+          return true;
+        }
+      }
+
+      if ('classId' in entry && 'selector' in entry) {
+        if (
+          contractClass.currentContractClassId.equals(entry.classId) &&
+          (entry.selector === undefined || entry.selector.equals(functionSelector))
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/src/msg_validators/tx_validator/test_utils.ts

@@ -0,0 +1,43 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HashedValues, type Tx } from '@aztec/stdlib/tx';
+
+export function patchNonRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+
+export function patchRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+
+async function patchFn(
+  where: 'revertibleAccumulatedData' | 'nonRevertibleAccumulatedData',
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  const calldataIndex =
+    where === 'nonRevertibleAccumulatedData'
+      ? index
+      : index + tx.data.forPublic!.nonRevertibleAccumulatedData.publicCallRequests.length;
+  const calldata = [overrides.selector.toField(), ...(overrides.args ?? [])];
+  const hashedCalldata = await HashedValues.fromCalldata(calldata);
+  tx.publicFunctionCalldata[calldataIndex] = hashedCalldata;
+
+  const request = tx.data.forPublic![where].publicCallRequests[index];
+  request.contractAddress = overrides.address ?? request.contractAddress;
+  request.msgSender = overrides.msgSender ?? request.msgSender;
+  request.calldataHash = hashedCalldata.hash;
+  tx.data.forPublic![where].publicCallRequests[index] = request;
+
+  return request.contractAddress;
+}

package/src/services/libp2p/libp2p_service.ts

@@ -4,7 +4,10 @@ import { createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { GasFees } from '@aztec/stdlib/gas';
 import type { ClientProtocolCircuitVerifier, PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import {
   BlockAttestation,
@@ -16,7 +19,7 @@ import {
   getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/stdlib/p2p';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
 import { Tx, type TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
 import { Attributes, OtelMetricsAdapter, type TelemetryClient, WithTracer, trackSpan } from '@aztec/telemetry-client';
 
@@ -43,10 +46,13 @@ import { createLibp2p } from 'libp2p';
 import type { P2PConfig } from '../../config.js';
 import type { MemPools } from '../../mem_pools/interface.js';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
+import { getDefaultAllowedSetupFunctions } from '../../msg_validators/tx_validator/allowed_public_setup.js';
 import {
   DataTxValidator,
   DoubleSpendTxValidator,
+  GasTxValidator,
   MetadataTxValidator,
+  PhasesTxValidator,
   TxProofValidator,
 } from '../../msg_validators/tx_validator/index.js';
 import { GossipSubEvent } from '../../types/index.js';
@@ -95,6 +101,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
   // Trusted peers ids
   private trustedPeersIds: PeerId[] = [];
 
+  private feesCache: { blockNumber: number; gasFees: GasFees } | undefined;
+
   /**
    * Callback for when a block is received from a peer.
    * @param block - The block received from the peer.
@@ -110,7 +118,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
     private mempools: MemPools<T>,
-    private l2BlockSource: L2BlockSource,
+    private archiver: L2BlockSource & ContractDataSource,
     epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
@@ -164,7 +172,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
     mempools: MemPools<T>,
-    l2BlockSource: L2BlockSource,
+    l2BlockSource: L2BlockSource & ContractDataSource,
     epochCache: EpochCacheInterface,
     proofVerifier: ClientProtocolCircuitVerifier,
     worldStateSynchronizer: WorldStateSynchronizer,
@@ -322,7 +330,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     // Create request response protocol handlers
     const txHandler = reqRespTxHandler(this.mempools);
     const goodbyeHandler = reqGoodbyeHandler(this.peerManager);
-    const blockHandler = reqRespBlockHandler(this.l2BlockSource);
+    const blockHandler = reqRespBlockHandler(this.archiver);
 
     const requestResponseHandlers = {
       [ReqRespSubProtocol.PING]: pingHandler,
@@ -686,8 +694,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
   }))
   private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
-    const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
-    const messageValidators = this.createMessageValidators(blockNumber);
+    const blockNumber = (await this.archiver.getBlockNumber()) + 1;
+    const messageValidators = await this.createMessageValidators(blockNumber);
     const outcome = await this.runValidations(tx, messageValidators);
 
     if (outcome.allPassed) {
@@ -705,6 +713,17 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     return false;
   }
 
+  private async getGasFees(blockNumber: number): Promise<GasFees> {
+    if (blockNumber === this.feesCache?.blockNumber) {
+      return this.feesCache.gasFees;
+    }
+
+    const header = await this.archiver.getBlockHeader(blockNumber);
+    const gasFees = header?.globalVariables.gasFees ?? GasFees.empty();
+    this.feesCache = { blockNumber, gasFees };
+    return gasFees;
+  }
+
   /**
    * Create message validators for the given block number.
    *
@@ -714,7 +733,11 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
    * @param blockNumber - The block number to create validators for.
    * @returns The message validators.
    */
-  private createMessageValidators(blockNumber: number): Record<string, MessageValidator> {
+  private async createMessageValidators(blockNumber: number): Promise<Record<string, MessageValidator>> {
+    const merkleTree = this.worldStateSynchronizer.getCommitted();
+    const gasFees = await this.getGasFees(blockNumber - 1);
+    const allowedInSetup = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+
     return {
       dataValidator: {
         validator: new DataTxValidator(),
@@ -742,6 +765,18 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
         }),
         severity: PeerErrorSeverity.HighToleranceError,
       },
+      gasValidator: {
+        validator: new GasTxValidator(
+          new DatabasePublicStateSource(merkleTree),
+          ProtocolContractAddress.FeeJuice,
+          gasFees,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      phasesValidator: {
+        validator: new PhasesTxValidator(this.archiver, allowedInSetup, blockNumber),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
     };
   }
 

package/src/services/peer-manager/peer_manager.ts

@@ -45,7 +45,11 @@ export class PeerManager {
   private trustedPeersInitialized: boolean = false;
 
   private metrics: PeerManagerMetrics;
-  private discoveredPeerHandler;
+  private handlers: {
+    handleConnectedPeerEvent: (e: CustomEvent<PeerId>) => void;
+    handleDisconnectedPeerEvent: (e: CustomEvent<PeerId>) => void;
+    handleDiscoveredPeer: (enr: ENR) => Promise<void>;
+  } = {} as any;
 
   constructor(
     private libP2PNode: PubSubLibp2p,
@@ -58,17 +62,21 @@ export class PeerManager {
   ) {
     this.metrics = new PeerManagerMetrics(telemetryClient, 'PeerManager');
 
+    // Handle Discovered peers
+    this.handlers = {
+      handleConnectedPeerEvent: this.handleConnectedPeerEvent.bind(this),
+      handleDisconnectedPeerEvent: this.handleDisconnectedPeerEvent.bind(this),
+      handleDiscoveredPeer: (enr: ENR) =>
+        this.handleDiscoveredPeer(enr).catch(e => this.logger.error('Error handling discovered peer', e)),
+    };
+
     // Handle new established connections
-    this.libP2PNode.addEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent.bind(this));
+    this.libP2PNode.addEventListener(PeerEvent.CONNECTED, this.handlers.handleConnectedPeerEvent);
     // Handle lost connections
-    this.libP2PNode.addEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent.bind(this));
-
-    // Handle Discovered peers
-    this.discoveredPeerHandler = (enr: ENR) =>
-      this.handleDiscoveredPeer(enr).catch(e => this.logger.error('Error handling discovered peer', e));
+    this.libP2PNode.addEventListener(PeerEvent.DISCONNECTED, this.handlers.handleDisconnectedPeerEvent);
 
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    this.peerDiscoveryService.on(PeerEvent.DISCOVERED, this.discoveredPeerHandler);
+    this.peerDiscoveryService.on(PeerEvent.DISCOVERED, this.handlers.handleDiscoveredPeer);
 
     // Display peer counts every 60 seconds
     this.displayPeerCountsPeerHeartbeat = Math.floor(60_000 / this.config.peerCheckIntervalMS);
@@ -538,15 +546,15 @@ export class PeerManager {
    */
   public async stop() {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.discoveredPeerHandler);
+    this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.handlers.handleDiscoveredPeer);
 
     // Send goodbyes to all peers
     await Promise.all(
       this.libP2PNode.getPeers().map(peer => this.goodbyeAndDisconnectPeer(peer, GoodByeReason.SHUTDOWN)),
     );
 
-    this.libP2PNode.removeEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent);
-    this.libP2PNode.removeEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent);
+    this.libP2PNode.removeEventListener(PeerEvent.CONNECTED, this.handlers.handleConnectedPeerEvent);
+    this.libP2PNode.removeEventListener(PeerEvent.DISCONNECTED, this.handlers.handleDisconnectedPeerEvent);
   }
 }
 

package/src/test-helpers/reqresp-nodes.ts

@@ -4,6 +4,7 @@ import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
@@ -98,7 +99,7 @@ export async function createLibp2pNode(
 export async function createTestLibP2PService<T extends P2PClientType>(
   clientType: T,
   boostrapAddrs: string[] = [],
-  l2BlockSource: L2BlockSource,
+  archiver: L2BlockSource & ContractDataSource,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCache,
   mempools: MemPools<T>,
@@ -131,7 +132,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     p2pNode as PubSubLibp2p,
     discoveryService,
     mempools,
-    l2BlockSource,
+    archiver,
     epochCache,
     proofVerifier,
     worldStateSynchronizer,