@aztec/sequencer-client 0.67.1 → 0.68.1

package/src/tx_validator/gas_validator.ts

@@ -1,5 +1,5 @@
 import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, FunctionSelector } from '@aztec/circuits.js';
+import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
 
@@ -12,36 +12,62 @@ export class GasTxValidator implements TxValidator<Tx> {
   #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/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),
     });
   }
 }