@aztec/sequencer-client 0.31.0 → 0.32.0

package/src/sequencer/tx_validator.ts

@@ -1,8 +1,9 @@
 import { ProcessedTx, Tx } from '@aztec/circuit-types';
-import { AztecAddress, EthAddress, Fr, GlobalVariables } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress, Fr, GlobalVariables, PublicCallRequest } from '@aztec/circuits.js';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { Logger, createDebugLogger } from '@aztec/foundation/log';
 import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { ContractDataSource } from '@aztec/types/contracts';
 
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 
@@ -27,25 +28,33 @@ type TxValidationStatus = typeof VALID_TX | typeof INVALID_TX;
 // the storage slot associated with "storage.balances"
 const GAS_TOKEN_BALANCES_SLOT = new Fr(1);
 
+type FeeValidationConfig = {
+  gasPortalAddress: EthAddress;
+  allowedFeePaymentContractClasses: Fr[];
+  allowedFeePaymentContractInstances: AztecAddress[];
+};
+
 export class TxValidator {
   #log: Logger;
   #globalVariables: GlobalVariables;
   #nullifierSource: NullifierSource;
   #publicStateSource: PublicStateSource;
-  #gasPortalAddress: EthAddress;
+  #contractDataSource: ContractDataSource;
+  #feeValidationConfig: FeeValidationConfig;
 
   constructor(
     nullifierSource: NullifierSource,
     publicStateSource: PublicStateSource,
-    gasPortalAddress: EthAddress,
+    contractDataSource: ContractDataSource,
     globalVariables: GlobalVariables,
+    feeValidationConfig: FeeValidationConfig,
     log = createDebugLogger('aztec:sequencer:tx_validator'),
   ) {
     this.#nullifierSource = nullifierSource;
-    this.#globalVariables = globalVariables;
     this.#publicStateSource = publicStateSource;
-    this.#gasPortalAddress = gasPortalAddress;
-
+    this.#contractDataSource = contractDataSource;
+    this.#globalVariables = globalVariables;
+    this.#feeValidationConfig = feeValidationConfig;
     this.#log = log;
   }
 
@@ -71,9 +80,15 @@ export class TxValidator {
       }
 
       // skip already processed transactions
-      if (tx instanceof Tx && (await this.#validateFee(tx)) === INVALID_TX) {
-        invalidTxs.push(tx);
-        continue;
+      if (tx instanceof Tx) {
+        if ((await this.#validateFee(tx)) === INVALID_TX) {
+          invalidTxs.push(tx);
+          continue;
+        }
+        if ((await this.#validateGasBalance(tx)) === INVALID_TX) {
+          invalidTxs.push(tx);
+          continue;
+        }
       }
 
       if (this.#validateMaxBlockNumber(tx) === INVALID_TX) {
@@ -150,30 +165,17 @@ export class TxValidator {
     return VALID_TX;
   }
 
-  async #validateFee(tx: Tx): Promise<TxValidationStatus> {
+  async #validateGasBalance(tx: Tx): Promise<TxValidationStatus> {
     if (!tx.data.needsTeardown) {
-      // TODO check if fees are mandatory and reject this tx
-      this.#log.debug(`Tx ${Tx.getHash(tx)} doesn't pay for gas`);
       return VALID_TX;
     }
 
-    const {
-      // TODO what if there's more than one function call?
-      // if we're to enshrine that teardown = 1 function call, then we should turn this into a single function call
-      [PublicKernelPhase.TEARDOWN]: [teardownFn],
-    } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls);
-
-    if (!teardownFn) {
-      this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because it should pay for gas but has no enqueued teardown function call`,
-      );
-      return INVALID_TX;
-    }
+    const teardownFn = TxValidator.#extractFeeExecutionCall(tx)!;
 
     // TODO(#1204) if a generator index is used for the derived storage slot of a map, update it here as well
-    const slot = pedersenHash([GAS_TOKEN_BALANCES_SLOT.toBuffer(), teardownFn.callContext.msgSender.toBuffer()]);
+    const slot = pedersenHash([GAS_TOKEN_BALANCES_SLOT, teardownFn.callContext.msgSender]);
     const gasBalance = await this.#publicStateSource.storageRead(
-      getCanonicalGasTokenAddress(this.#gasPortalAddress),
+      getCanonicalGasTokenAddress(this.#feeValidationConfig.gasPortalAddress),
       slot,
     );
 
@@ -201,4 +203,55 @@ export class TxValidator {
       return VALID_TX;
     }
   }
+
+  async #validateFee(tx: Tx): Promise<TxValidationStatus> {
+    if (!tx.data.needsTeardown) {
+      // TODO check if fees are mandatory and reject this tx
+      this.#log.debug(`Tx ${Tx.getHash(tx)} doesn't pay for gas`);
+      return VALID_TX;
+    }
+
+    const teardownFn = TxValidator.#extractFeeExecutionCall(tx);
+    if (!teardownFn) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(tx)} because it should pay for gas but has no enqueued teardown function call`,
+      );
+      return INVALID_TX;
+    }
+
+    const fpcAddress = teardownFn.contractAddress;
+    const contractClass = await this.#contractDataSource.getContract(fpcAddress);
+
+    if (!contractClass) {
+      return INVALID_TX;
+    }
+
+    if (fpcAddress.equals(getCanonicalGasTokenAddress(this.#feeValidationConfig.gasPortalAddress))) {
+      return VALID_TX;
+    }
+
+    for (const allowedContract of this.#feeValidationConfig.allowedFeePaymentContractInstances) {
+      if (fpcAddress.equals(allowedContract)) {
+        return VALID_TX;
+      }
+    }
+
+    for (const allowedContractClass of this.#feeValidationConfig.allowedFeePaymentContractClasses) {
+      if (contractClass.contractClassId.equals(allowedContractClass)) {
+        return VALID_TX;
+      }
+    }
+
+    return INVALID_TX;
+  }
+
+  static #extractFeeExecutionCall(tx: Tx): PublicCallRequest | undefined {
+    const {
+      // TODO what if there's more than one function call?
+      // if we're to enshrine that teardown = 1 function call, then we should turn this into a single function call
+      [PublicKernelPhase.TEARDOWN]: [teardownFn],
+    } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls);
+
+    return teardownFn;
+  }
 }

package/src/sequencer/tx_validator_factory.ts

@@ -0,0 +1,32 @@
+import { AztecAddress, EthAddress, Fr, GlobalVariables } from '@aztec/circuits.js';
+import { ContractDataSource } from '@aztec/types/contracts';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+import { WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
+import { TxValidator } from './tx_validator.js';
+
+export class TxValidatorFactory {
+  constructor(
+    private merkleTreeDb: MerkleTreeOperations,
+    private contractDataSource: ContractDataSource,
+    private gasPortalAddress: EthAddress,
+  ) {}
+
+  buildTxValidator(
+    globalVariables: GlobalVariables,
+    allowedFeePaymentContractClasses: Fr[],
+    allowedFeePaymentContractInstances: AztecAddress[],
+  ): TxValidator {
+    return new TxValidator(
+      new WorldStateDB(this.merkleTreeDb),
+      new WorldStatePublicDB(this.merkleTreeDb),
+      this.contractDataSource,
+      globalVariables,
+      {
+        allowedFeePaymentContractClasses,
+        allowedFeePaymentContractInstances,
+        gasPortalAddress: this.gasPortalAddress,
+      },
+    );
+  }
+}

package/src/simulator/public_executor.ts

@@ -1,10 +1,4 @@
-import {
-  L1ToL2MessageSource,
-  MerkleTreeId,
-  NullifierMembershipWitness,
-  Tx,
-  UnencryptedL2Log,
-} from '@aztec/circuit-types';
+import { MerkleTreeId, NullifierMembershipWitness, Tx } from '@aztec/circuit-types';
 import {
   AztecAddress,
   ContractClassRegisteredEvent,
@@ -42,7 +36,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    */
   public addNewContracts(tx: Tx): Promise<void> {
     // Extract contract class and instance data from logs and add to cache for this block
-    const logs = tx.unencryptedLogs.unrollLogs().map(UnencryptedL2Log.fromBuffer);
+    const logs = tx.unencryptedLogs.unrollLogs();
     ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e => {
       this.log(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
@@ -65,7 +59,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?
-    const logs = tx.unencryptedLogs.unrollLogs().map(UnencryptedL2Log.fromBuffer);
+    const logs = tx.unencryptedLogs.unrollLogs();
     ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e =>
       this.classCache.delete(e.contractClassId.toString()),
     );
@@ -198,7 +192,7 @@ export class WorldStatePublicDB implements PublicStateDB {
  * Implements WorldState db using a world state database.
  */
 export class WorldStateDB implements CommitmentsDB {
-  constructor(private db: MerkleTreeOperations, private l1ToL2MessageSource: L1ToL2MessageSource) {}
+  constructor(private db: MerkleTreeOperations) {}
 
   public async getNullifierMembershipWitnessAtLatestBlock(
     nullifier: Fr,
@@ -235,11 +229,7 @@ export class WorldStateDB implements CommitmentsDB {
     // We iterate over messages until we find one whose nullifier is not in the nullifier tree --> we need to check
     // for nullifiers because messages can have duplicates.
     do {
-      messageIndex = (await this.db.findLeafIndexAfter(
-        MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-        messageHash.toBuffer(),
-        startIndex,
-      ))!;
+      messageIndex = (await this.db.findLeafIndexAfter(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash, startIndex))!;
       if (messageIndex === undefined) {
         throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
       }
@@ -259,7 +249,7 @@ export class WorldStateDB implements CommitmentsDB {
   }
 
   public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
-    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment.toBuffer());
+    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
   }
 
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {