@aztec/sequencer-client 0.66.0 → 0.67.1-devnet

package/src/tx_validator/gas_validator.ts

@@ -1,6 +1,6 @@
 import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, FunctionSelector } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
@@ -9,39 +9,65 @@ export interface PublicStateSource {
 }
 
 export class GasTxValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
+  #log = createLogger('sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
   #feeJuiceAddress: AztecAddress;
+  #enforceFees: boolean;
+  #gasFees: GasFees;
 
-  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, public enforceFees: boolean) {
+  constructor(
+    publicDataSource: PublicStateSource,
+    feeJuiceAddress: AztecAddress,
+    enforceFees: boolean,
+    gasFees: GasFees,
+  ) {
     this.#publicDataSource = publicDataSource;
     this.#feeJuiceAddress = feeJuiceAddress;
+    this.#enforceFees = enforceFees;
+    this.#gasFees = gasFees;
   }
 
-  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+  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 (await this.#validateTxFee(tx)) {
+      if (this.#shouldSkip(tx)) {
+        skippedTxs.push(tx);
+      } else if (await this.#validateTxFee(tx)) {
         validTxs.push(tx);
       } else {
         invalidTxs.push(tx);
       }
     }
 
-    return [validTxs, invalidTxs];
+    return [validTxs, invalidTxs, skippedTxs];
   }
 
   validateTx(tx: Tx): Promise<boolean> {
     return this.#validateTxFee(tx);
   }
 
+  #shouldSkip(tx: Tx): boolean {
+    const gasSettings = tx.data.constants.txContext.gasSettings;
+
+    // Skip the tx if its max fees are not enough for the current block's gas fees.
+    const maxFeesPerGas = gasSettings.maxFeesPerGas;
+    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> {
     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) {
+      if (this.#enforceFees) {
         this.#log.warn(`Rejecting transaction ${tx.getTxHash()} due to missing fee payer`);
       } else {
         return true;

package/src/tx_validator/phases_validator.ts

@@ -6,11 +6,11 @@ import {
   type TxValidator,
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
+  #log = createLogger('sequencer:tx_validator:tx_phases');
   private contractDataSource: ContractsDataSourcePublicDB;
 
   constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[]) {

package/src/tx_validator/tx_validator_factory.ts

@@ -29,7 +29,10 @@ export class TxValidatorFactory {
     private enforceFees: boolean,
   ) {
     this.nullifierSource = {
-      getNullifierIndex: nullifier => this.committedDb.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer()),
+      getNullifierIndices: nullifiers =>
+        this.committedDb
+          .findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers)
+          .then(x => x.filter(index => index !== undefined) as bigint[]),
     };
 
     this.publicStateSource = {
@@ -45,13 +48,18 @@ export class TxValidatorFactory {
       new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber),
       new DoubleSpendTxValidator(this.nullifierSource),
       new PhasesTxValidator(this.contractDataSource, setupAllowList),
-      new GasTxValidator(this.publicStateSource, ProtocolContractAddress.FeeJuice, this.enforceFees),
+      new GasTxValidator(
+        this.publicStateSource,
+        ProtocolContractAddress.FeeJuice,
+        this.enforceFees,
+        globalVariables.gasFees,
+      ),
     );
   }
 
   validatorForProcessedTxs(fork: MerkleTreeReadOperations): TxValidator<ProcessedTx> {
     return new DoubleSpendTxValidator({
-      getNullifierIndex: nullifier => fork.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer()),
+      getNullifierIndices: nullifiers => fork.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers),
     });
   }
 }