@aztec/sequencer-client 0.0.0-test.0

package/src/tx_validator/phases_validator.ts

@@ -0,0 +1,98 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import {
+  type PublicExecutionRequest,
+  Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log = createLogger('sequencer:tx_validator:tx_phases');
+  private contractDataSource: ContractsDataSourcePublicDB;
+
+  constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[]) {
+    this.contractDataSource = new ContractsDataSourcePublicDB(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.contractDataSource.addNewContracts(tx);
+
+      if (!tx.data.forPublic) {
+        this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
+        return { result: 'valid' };
+      }
+
+      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 { result: 'valid' };
+    } finally {
+      this.contractDataSource.clearContractsForTx();
+    }
+  }
+
+  async isOnAllowList(publicCall: PublicExecutionRequest, allowList: AllowedElement[]): Promise<boolean> {
+    if (publicCall.isEmpty()) {
+      return true;
+    }
+
+    const { contractAddress, functionSelector } = publicCall.callContext;
+
+    // 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.contractDataSource.getContractInstance(contractAddress);
+
+      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/tx_validator/test_utils.ts

@@ -0,0 +1,48 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+import type { Tx } from '@aztec/stdlib/tx';
+
+export function patchNonRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<{ address: AztecAddress; selector: FunctionSelector }> {
+  return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+
+export function patchRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<{ address: AztecAddress; selector: FunctionSelector }> {
+  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<{ address: AztecAddress; selector: FunctionSelector }> {
+  const fn = tx.enqueuedPublicFunctionCalls.at(-1 * index - 1)!;
+  fn.callContext.contractAddress = overrides.address ?? fn.callContext.contractAddress;
+  fn.callContext.functionSelector = overrides.selector;
+  fn.args = overrides.args ?? fn.args;
+  fn.callContext.msgSender = overrides.msgSender ?? fn.callContext.msgSender;
+  tx.enqueuedPublicFunctionCalls[index] = fn;
+
+  const request = tx.data.forPublic![where].publicCallRequests[index];
+  request.contractAddress = fn.callContext.contractAddress;
+  request.msgSender = fn.callContext.msgSender;
+  request.functionSelector = fn.callContext.functionSelector;
+  request.isStaticCall = fn.callContext.isStaticCall;
+  request.argsHash = await computeVarArgsHash(fn.args);
+  tx.data.forPublic![where].publicCallRequests[index] = request;
+
+  return {
+    address: fn.callContext.contractAddress,
+    selector: fn.callContext.functionSelector,
+  };
+}

package/src/tx_validator/tx_validator_factory.ts

@@ -0,0 +1,120 @@
+import { Fr } from '@aztec/foundation/fields';
+import {
+  AggregateTxValidator,
+  BlockHeaderTxValidator,
+  DataTxValidator,
+  DoubleSpendTxValidator,
+  MetadataTxValidator,
+  TxProofValidator,
+} from '@aztec/p2p';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { readPublicState } from '@aztec/simulator/server';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { GasFees } from '@aztec/stdlib/gas';
+import type {
+  AllowedElement,
+  ClientProtocolCircuitVerifier,
+  MerkleTreeReadOperations,
+} from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables, type ProcessedTx, type Tx, type TxValidator } from '@aztec/stdlib/tx';
+
+import { ArchiveCache } from './archive_cache.js';
+import { GasTxValidator, type PublicStateSource } from './gas_validator.js';
+import { NullifierCache } from './nullifier_cache.js';
+import { PhasesTxValidator } from './phases_validator.js';
+
+export function createValidatorForAcceptingTxs(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  verifier: ClientProtocolCircuitVerifier | undefined,
+  {
+    blockNumber,
+    l1ChainId,
+    setupAllowList,
+    gasFees,
+    skipFeeEnforcement,
+  }: {
+    blockNumber: number;
+    l1ChainId: number;
+    setupAllowList: AllowedElement[];
+    gasFees: GasFees;
+    skipFeeEnforcement?: boolean;
+  },
+): TxValidator<Tx> {
+  const validators: TxValidator<Tx>[] = [
+    new DataTxValidator(),
+    new MetadataTxValidator(new Fr(l1ChainId), new Fr(blockNumber)),
+    new DoubleSpendTxValidator(new NullifierCache(db)),
+    new PhasesTxValidator(contractDataSource, setupAllowList),
+    new BlockHeaderTxValidator(new ArchiveCache(db)),
+  ];
+
+  if (!skipFeeEnforcement) {
+    validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
+  }
+
+  if (verifier) {
+    validators.push(new TxProofValidator(verifier));
+  }
+
+  return new AggregateTxValidator(...validators);
+}
+
+export function createValidatorsForBlockBuilding(
+  db: MerkleTreeReadOperations,
+  contractDataSource: ContractDataSource,
+  globalVariables: GlobalVariables,
+  setupAllowList: AllowedElement[],
+): {
+  preprocessValidator: TxValidator<Tx>;
+  postprocessValidator: TxValidator<ProcessedTx>;
+  nullifierCache: NullifierCache;
+} {
+  const nullifierCache = new NullifierCache(db);
+  const archiveCache = new ArchiveCache(db);
+  const publicStateSource = new DatabasePublicStateSource(db);
+
+  return {
+    preprocessValidator: preprocessValidator(
+      nullifierCache,
+      archiveCache,
+      publicStateSource,
+      contractDataSource,
+      globalVariables,
+      setupAllowList,
+    ),
+    postprocessValidator: postprocessValidator(nullifierCache),
+    nullifierCache,
+  };
+}
+
+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,
+  archiveCache: ArchiveCache,
+  publicStateSource: PublicStateSource,
+  contractDataSource: ContractDataSource,
+  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, globalVariables.gasFees),
+    new BlockHeaderTxValidator(archiveCache),
+  );
+}
+
+function postprocessValidator(nullifierCache: NullifierCache): TxValidator<ProcessedTx> {
+  return new DoubleSpendTxValidator(nullifierCache);
+}