@aztec/sequencer-client 0.69.0-devnet → 0.69.1

package/src/sequencer/utils.ts

@@ -19,9 +19,9 @@ export enum SequencerState {
    */
   PROPOSER_CHECK = 'PROPOSER_CHECK',
   /**
-   * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+   * Initializing the block proposal. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
    */
-  WAITING_FOR_TXS = 'WAITING_FOR_TXS',
+  INITIALIZING_PROPOSAL = 'INITIALIZING_PROPOSAL',
   /**
    * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
    */

package/src/tx_validator/gas_validator.ts

@@ -1,4 +1,4 @@
-import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
+import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
@@ -27,25 +27,10 @@ export class GasTxValidator implements TxValidator<Tx> {
     this.#gasFees = gasFees;
   }
 
-  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[], skippedTxs: Tx[]]> {
-    const validTxs: Tx[] = [];
-    const invalidTxs: Tx[] = [];
-    const skippedTxs: Tx[] = [];
-
-    for (const tx of txs) {
-      if (this.#shouldSkip(tx)) {
-        skippedTxs.push(tx);
-      } else if (await this.#validateTxFee(tx)) {
-        validTxs.push(tx);
-      } else {
-        invalidTxs.push(tx);
-      }
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    if (this.#shouldSkip(tx)) {
+      return Promise.resolve({ result: 'skipped', reason: ['Insufficient fee per gas'] });
     }
-
-    return [validTxs, invalidTxs, skippedTxs];
-  }
-
-  validateTx(tx: Tx): Promise<boolean> {
     return this.#validateTxFee(tx);
   }
 
@@ -57,20 +42,22 @@ export class GasTxValidator implements TxValidator<Tx> {
     const notEnoughMaxFees =
       maxFeesPerGas.feePerDaGas.lt(this.#gasFees.feePerDaGas) ||
       maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
+
     if (notEnoughMaxFees) {
       this.#log.warn(`Skipping transaction ${tx.getTxHash()} due to insufficient fee per gas`);
     }
     return notEnoughMaxFees;
   }
 
-  async #validateTxFee(tx: Tx): Promise<boolean> {
+  async #validateTxFee(tx: Tx): Promise<TxValidationResult> {
     const feePayer = tx.data.feePayer;
     // TODO(@spalladino) Eventually remove the is_zero condition as we should always charge fees to every tx
     if (feePayer.isZero()) {
       if (this.#enforceFees) {
         this.#log.warn(`Rejecting transaction ${tx.getTxHash()} due to missing fee payer`);
+        return { result: 'invalid', reason: ['Missing fee payer'] };
       } else {
-        return true;
+        return { result: 'valid' };
       }
     }
 
@@ -98,13 +85,13 @@ export class GasTxValidator implements TxValidator<Tx> {
 
     const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
     if (balance.lt(feeLimit)) {
-      this.#log.info(`Rejecting transaction due to not enough fee payer balance`, {
+      this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
         balance: balance.toBigInt(),
         feeLimit: feeLimit.toBigInt(),
       });
-      return false;
+      return { result: 'invalid', reason: ['Insufficient fee payer balance'] };
     }
-    return true;
+    return { result: 'valid' };
   }
 }

package/src/tx_validator/nullifier_cache.ts

@@ -0,0 +1,29 @@
+import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
+import { type NullifierSource } from '@aztec/p2p';
+
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class NullifierCache implements NullifierSource {
+  nullifiers: Set<string>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.nullifiers = new Set();
+  }
+
+  public async nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]> {
+    const cacheResults = nullifiers.map(n => this.nullifiers.has(n.toString()));
+    const toCheckDb = nullifiers.filter((_n, index) => !cacheResults[index]);
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+
+    let dbIndex = 0;
+    return nullifiers.map((_n, index) => cacheResults[index] || dbHits[dbIndex++] !== undefined);
+  }
+
+  public addNullifiers(nullifiers: Buffer[]) {
+    for (const nullifier of nullifiers) {
+      this.nullifiers.add(nullifier.toString());
+    }
+  }
+}

package/src/tx_validator/phases_validator.ts

@@ -3,6 +3,7 @@ import {
   type PublicExecutionRequest,
   Tx,
   TxExecutionPhase,
+  type TxValidationResult,
   type TxValidator,
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
@@ -17,48 +18,36 @@ export class PhasesTxValidator implements TxValidator<Tx> {
     this.contractDataSource = new ContractsDataSourcePublicDB(contracts);
   }
 
-  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
-    const validTxs: Tx[] = [];
-    const invalidTxs: Tx[] = [];
-
-    for (const tx of txs) {
+  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.contractDataSource.addNewContracts(tx);
 
-      if (await this.validateTx(tx)) {
-        validTxs.push(tx);
-      } else {
-        invalidTxs.push(tx);
+      if (!tx.data.forPublic) {
+        this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
+        return { result: 'valid' };
       }
 
-      await this.contractDataSource.removeNewContracts(tx);
-    }
-
-    return Promise.resolve([validTxs, invalidTxs]);
-  }
-
-  async validateTx(tx: Tx): Promise<boolean> {
-    if (!tx.data.forPublic) {
-      this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
-      return true;
-    }
-
-    const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
-    for (const setupFn of setupFns) {
-      if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
-        this.#log.warn(
-          `Rejecting tx ${Tx.getHash(tx)} because it calls setup function not on allow list: ${
-            setupFn.callContext.contractAddress
-          }:${setupFn.callContext.functionSelector}`,
-        );
-
-        return false;
+      const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
+      for (const setupFn of setupFns) {
+        if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
+          this.#log.warn(
+            `Rejecting tx ${Tx.getHash(tx)} because it calls setup function not on allow list: ${
+              setupFn.callContext.contractAddress
+            }:${setupFn.callContext.functionSelector}`,
+            { allowList: this.setupAllowList },
+          );
+
+          return { result: 'invalid', reason: ['Setup function not on allow list'] };
+        }
       }
-    }
 
-    return true;
+      return { result: 'valid' };
+    } finally {
+      await this.contractDataSource.removeNewContracts(tx);
+    }
   }
 
   async isOnAllowList(publicCall: PublicExecutionRequest, allowList: AllowedElement[]): Promise<boolean> {

package/src/tx_validator/tx_validator_factory.ts

@@ -1,65 +1,107 @@
 import {
   type AllowedElement,
-  MerkleTreeId,
+  type ClientProtocolCircuitVerifier,
   type MerkleTreeReadOperations,
   type ProcessedTx,
   type Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
-import { type ContractDataSource, type GlobalVariables } from '@aztec/circuits.js';
+import { type AztecAddress, type ContractDataSource, Fr, type GasFees, type GlobalVariables } from '@aztec/circuits.js';
 import {
   AggregateTxValidator,
   DataTxValidator,
   DoubleSpendTxValidator,
   MetadataTxValidator,
-  type NullifierSource,
+  TxProofValidator,
 } from '@aztec/p2p';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { readPublicState } from '@aztec/simulator';
 
 import { GasTxValidator, type PublicStateSource } from './gas_validator.js';
+import { NullifierCache } from './nullifier_cache.js';
 import { PhasesTxValidator } from './phases_validator.js';
 
-export class TxValidatorFactory {
-  nullifierSource: NullifierSource;
-  publicStateSource: PublicStateSource;
-  constructor(
-    private committedDb: MerkleTreeReadOperations,
-    private contractDataSource: ContractDataSource,
-    private enforceFees: boolean,
-  ) {
-    this.nullifierSource = {
-      getNullifierIndices: nullifiers =>
-        this.committedDb
-          .findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers)
-          .then(x => x.filter(index => index !== undefined) as bigint[]),
-    };
+export function createValidatorForAcceptingTxs(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  verifier: ClientProtocolCircuitVerifier | undefined,
+  data: {
+    blockNumber: number;
+    l1ChainId: number;
+    enforceFees: boolean;
+    setupAllowList: AllowedElement[];
+    gasFees: GasFees;
+  },
+): TxValidator<Tx> {
+  const { blockNumber, l1ChainId, enforceFees, setupAllowList, gasFees } = data;
+  const validators: TxValidator<Tx>[] = [
+    new DataTxValidator(),
+    new MetadataTxValidator(new Fr(l1ChainId), new Fr(blockNumber)),
+    new DoubleSpendTxValidator(new NullifierCache(db)),
+    new PhasesTxValidator(contractDataSource, setupAllowList),
+    new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, enforceFees, gasFees),
+  ];
 
-    this.publicStateSource = {
-      storageRead: (contractAddress, slot) => {
-        return readPublicState(this.committedDb, contractAddress, slot);
-      },
-    };
+  if (verifier) {
+    validators.push(new TxProofValidator(verifier));
   }
 
-  validatorForNewTxs(globalVariables: GlobalVariables, setupAllowList: AllowedElement[]): TxValidator<Tx> {
-    return new AggregateTxValidator(
-      new DataTxValidator(),
-      new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber),
-      new DoubleSpendTxValidator(this.nullifierSource),
-      new PhasesTxValidator(this.contractDataSource, setupAllowList),
-      new GasTxValidator(
-        this.publicStateSource,
-        ProtocolContractAddress.FeeJuice,
-        this.enforceFees,
-        globalVariables.gasFees,
-      ),
-    );
-  }
+  return new AggregateTxValidator(...validators);
+}
+
+export function createValidatorsForBlockBuilding(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  globalVariables: GlobalVariables,
+  enforceFees: boolean,
+  setupAllowList: AllowedElement[],
+): {
+  preprocessValidator: TxValidator<Tx>;
+  postprocessValidator: TxValidator<ProcessedTx>;
+  nullifierCache: NullifierCache;
+} {
+  const nullifierCache = new NullifierCache(db);
+  const publicStateSource = new DatabasePublicStateSource(db);
+
+  return {
+    preprocessValidator: preprocessValidator(
+      nullifierCache,
+      publicStateSource,
+      contractDataSource,
+      enforceFees,
+      globalVariables,
+      setupAllowList,
+    ),
+    postprocessValidator: postprocessValidator(nullifierCache),
+    nullifierCache,
+  };
+}
 
-  validatorForProcessedTxs(fork: MerkleTreeReadOperations): TxValidator<ProcessedTx> {
-    return new DoubleSpendTxValidator({
-      getNullifierIndices: nullifiers => fork.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers),
-    });
+class DatabasePublicStateSource implements PublicStateSource {
+  constructor(private db: MerkleTreeReadOperations) {}
+
+  storageRead(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
+    return readPublicState(this.db, contractAddress, slot);
   }
 }
+
+function preprocessValidator(
+  nullifierCache: NullifierCache,
+  publicStateSource: PublicStateSource,
+  contractDataSource: ContractDataSource,
+  enforceFees: boolean,
+  globalVariables: GlobalVariables,
+  setupAllowList: AllowedElement[],
+): TxValidator<Tx> {
+  // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
+  return new AggregateTxValidator(
+    new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber),
+    new DoubleSpendTxValidator(nullifierCache),
+    new PhasesTxValidator(contractDataSource, setupAllowList),
+    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, enforceFees, globalVariables.gasFees),
+  );
+}
+
+function postprocessValidator(nullifierCache: NullifierCache): TxValidator<ProcessedTx> {
+  return new DoubleSpendTxValidator(nullifierCache);
+}