@aztec/sequencer-client 0.34.0 → 0.35.0

package/src/tx_validator/gas_validator.ts

@@ -0,0 +1,81 @@
+import { Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AztecAddress, Fr } from '@aztec/circuits.js';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { GasTokenContract } from '@aztec/noir-contracts.js';
+import { AbstractPhaseManager, PublicKernelPhase } from '@aztec/simulator';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}
+
+export class GasTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
+  #publicDataSource: PublicStateSource;
+  #gasTokenAddress: AztecAddress;
+  #requireFees: boolean;
+
+  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, requireFees = false) {
+    this.#publicDataSource = publicDataSource;
+    this.#gasTokenAddress = gasTokenAddress;
+    this.#requireFees = requireFees;
+  }
+
+  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+
+    for (const tx of txs) {
+      if (await this.#validateTxFee(tx)) {
+        validTxs.push(tx);
+      } else {
+        invalidTxs.push(tx);
+      }
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  async #validateTxFee(tx: Tx): Promise<boolean> {
+    const { [PublicKernelPhase.TEARDOWN]: teardownFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(
+      tx.data,
+      tx.enqueuedPublicFunctionCalls,
+    );
+
+    if (teardownFns.length === 0) {
+      if (this.#requireFees) {
+        this.#log.warn(
+          `Rejecting tx ${Tx.getHash(tx)} because it should pay for gas but has no enqueued teardown functions`,
+        );
+        return false;
+      } else {
+        this.#log.debug(`Tx ${Tx.getHash(tx)} does not pay fees. Skipping balance check.`);
+        return true;
+      }
+    }
+
+    if (teardownFns.length > 1) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because it has multiple teardown functions`);
+      return false;
+    }
+
+    // check that the caller of the teardown function has enough balance to pay for tx costs
+    const teardownFn = teardownFns[0];
+    const slot = pedersenHash([GasTokenContract.storage.balances.slot, teardownFn.callContext.msgSender]);
+    const gasBalance = await this.#publicDataSource.storageRead(this.#gasTokenAddress, slot);
+
+    // TODO(#5004) calculate fee needed based on tx limits and gas prices
+    const gasAmountNeeded = new Fr(1);
+    if (gasBalance.lt(gasAmountNeeded)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because it should pay for gas but has insufficient balance ${gasBalance.toShortString()} < ${gasAmountNeeded.toShortString()}`,
+      );
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/tx_validator/metadata_validator.ts

@@ -0,0 +1,60 @@
+import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type GlobalVariables } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_metadata');
+  #globalVariables: GlobalVariables;
+
+  constructor(globalVariables: GlobalVariables) {
+    this.#globalVariables = globalVariables;
+  }
+
+  validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    for (const tx of txs) {
+      if (!this.#hasCorrectChainId(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      if (!this.#isValidForBlockNumber(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  #hasCorrectChainId(tx: T): boolean {
+    if (!tx.data.constants.txContext.chainId.equals(this.#globalVariables.chainId)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.#globalVariables.chainId.toNumber()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  #isValidForBlockNumber(tx: T): boolean {
+    const target =
+      tx instanceof Tx
+        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
+        : tx.data.rollupValidationRequests;
+    const maxBlockNumber = target.maxBlockNumber;
+
+    if (maxBlockNumber.isSome && maxBlockNumber.value < this.#globalVariables.blockNumber) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for low max block number`);
+      return false;
+    } else {
+      return true;
+    }
+  }
+}

package/src/tx_validator/phases_validator.ts

@@ -0,0 +1,101 @@
+import { type AllowedFunction, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type PublicCallRequest } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AbstractPhaseManager, PublicKernelPhase } from '@aztec/simulator';
+import { type ContractDataSource } from '@aztec/types/contracts';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
+
+  constructor(
+    private contractDataSource: ContractDataSource,
+    private setupAllowList: AllowedFunction[],
+    private teardownAllowList: AllowedFunction[],
+  ) {}
+
+  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+
+    for (const tx of txs) {
+      if (await this.#validateTx(tx)) {
+        validTxs.push(tx);
+      } else {
+        invalidTxs.push(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 { [PublicKernelPhase.SETUP]: setupFns, [PublicKernelPhase.TEARDOWN]: teardownFns } =
+      AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls);
+
+    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.contractAddress
+          }:${setupFn.functionData.selector}`,
+        );
+
+        return false;
+      }
+    }
+
+    for (const teardownFn of teardownFns) {
+      if (!(await this.isOnAllowList(teardownFn, this.teardownAllowList))) {
+        this.#log.warn(
+          `Rejecting tx ${Tx.getHash(tx)} because it calls teardown function not on allowlist: ${
+            teardownFn.contractAddress
+          }:${teardownFn.functionData.selector}`,
+        );
+
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  async isOnAllowList(publicCall: PublicCallRequest, allowList: AllowedFunction[]): Promise<boolean> {
+    const {
+      contractAddress,
+      functionData: { selector },
+    } = publicCall;
+
+    // do these checks first since they don't require the contract class
+    for (const entry of allowList) {
+      if (!('address' in entry)) {
+        continue;
+      }
+
+      if (contractAddress.equals(entry.address) && entry.selector.equals(selector)) {
+        return true;
+      }
+    }
+
+    const contractClass = await this.contractDataSource.getContract(contractAddress);
+    if (!contractClass) {
+      throw new Error(`Contract not found: ${publicCall.contractAddress.toString()}`);
+    }
+
+    for (const entry of allowList) {
+      if (!('classId' in entry)) {
+        continue;
+      }
+
+      if (contractClass.contractClassId.equals(entry.classId) && entry.selector.equals(selector)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/src/tx_validator/tx_validator_factory.ts

@@ -0,0 +1,37 @@
+import { type AllowedFunction, type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+import { type EthAddress, type GlobalVariables } from '@aztec/circuits.js';
+import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { WorldStateDB, WorldStatePublicDB } from '@aztec/simulator';
+import { type ContractDataSource } from '@aztec/types/contracts';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { AggregateTxValidator } from './aggregate_tx_validator.js';
+import { DoubleSpendTxValidator } from './double_spend_validator.js';
+import { GasTxValidator } from './gas_validator.js';
+import { MetadataTxValidator } from './metadata_validator.js';
+import { PhasesTxValidator } from './phases_validator.js';
+
+export class TxValidatorFactory {
+  constructor(
+    private merkleTreeDb: MerkleTreeOperations,
+    private contractDataSource: ContractDataSource,
+    private gasPortalAddress: EthAddress,
+  ) {}
+
+  validatorForNewTxs(
+    globalVariables: GlobalVariables,
+    setupAllowList: AllowedFunction[],
+    teardownAllowList: AllowedFunction[],
+  ): TxValidator<Tx> {
+    return new AggregateTxValidator(
+      new MetadataTxValidator(globalVariables),
+      new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb)),
+      new PhasesTxValidator(this.contractDataSource, setupAllowList, teardownAllowList),
+      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), getCanonicalGasTokenAddress(this.gasPortalAddress)),
+    );
+  }
+
+  validatorForProcessedTxs(): TxValidator<ProcessedTx> {
+    return new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb));
+  }
+}

package/dest/sequencer/abstract_phase_manager.d.ts

@@ -1,77 +0,0 @@
-import { type SimulationError, type Tx, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
-import { Fr, type GlobalVariables, type Header, type KernelCircuitPublicInputs, type PrivateKernelTailCircuitPublicInputs, type Proof, PublicCallData, type PublicCallRequest, PublicCallStackItem, PublicCircuitPublicInputs, type PublicKernelCircuitPublicInputs, PublicKernelData } from '@aztec/circuits.js';
-import { type ProcessReturnValues } from '@aztec/foundation/abi';
-import { type DebugLogger } from '@aztec/foundation/log';
-import { type PublicExecutionResult, type PublicExecutor } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { HintsBuilder } from './hints_builder.js';
-export declare enum PublicKernelPhase {
-    SETUP = "setup",
-    APP_LOGIC = "app-logic",
-    TEARDOWN = "teardown",
-    TAIL = "tail"
-}
-export declare const PhaseIsRevertible: Record<PublicKernelPhase, boolean>;
-export declare abstract class AbstractPhaseManager {
-    protected db: MerkleTreeOperations;
-    protected publicExecutor: PublicExecutor;
-    protected publicKernel: PublicKernelCircuitSimulator;
-    protected globalVariables: GlobalVariables;
-    protected historicalHeader: Header;
-    phase: PublicKernelPhase;
-    protected hintsBuilder: HintsBuilder;
-    protected log: DebugLogger;
-    constructor(db: MerkleTreeOperations, publicExecutor: PublicExecutor, publicKernel: PublicKernelCircuitSimulator, globalVariables: GlobalVariables, historicalHeader: Header, phase: PublicKernelPhase);
-    /**
-     *
-     * @param tx - the tx to be processed
-     * @param publicKernelPublicInputs - the output of the public kernel circuit for the previous phase
-     * @param previousPublicKernelProof - the proof of the public kernel circuit for the previous phase
-     */
-    abstract handle(tx: Tx, publicKernelPublicInputs: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof): Promise<{
-        /**
-         * the output of the public kernel circuit for this phase
-         */
-        publicKernelOutput: PublicKernelCircuitPublicInputs;
-        /**
-         * the final output of the public kernel circuit for this phase
-         */
-        finalKernelOutput?: KernelCircuitPublicInputs;
-        /**
-         * the proof of the public kernel circuit for this phase
-         */
-        publicKernelProof: Proof;
-        /**
-         * revert reason, if any
-         */
-        revertReason: SimulationError | undefined;
-        returnValues: ProcessReturnValues;
-    }>;
-    static extractEnqueuedPublicCallsByPhase(publicInputs: PrivateKernelTailCircuitPublicInputs, enqueuedPublicFunctionCalls: PublicCallRequest[]): Record<PublicKernelPhase, PublicCallRequest[]>;
-    protected extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[];
-    protected processEnqueuedPublicCalls(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof): Promise<[
-        PublicKernelCircuitPublicInputs,
-        Proof,
-        UnencryptedFunctionL2Logs[],
-        SimulationError | undefined,
-        ProcessReturnValues
-    ]>;
-    protected runKernelCircuit(previousOutput: PublicKernelCircuitPublicInputs, previousProof: Proof, callData: PublicCallData): Promise<[PublicKernelCircuitPublicInputs, Proof]>;
-    protected getKernelCircuitOutput(previousOutput: PublicKernelCircuitPublicInputs, previousProof: Proof, callData: PublicCallData): Promise<PublicKernelCircuitPublicInputs>;
-    protected getPreviousKernelData(previousOutput: PublicKernelCircuitPublicInputs, previousProof: Proof): PublicKernelData;
-    protected getPublicCircuitPublicInputs(result: PublicExecutionResult): Promise<PublicCircuitPublicInputs>;
-    protected getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest?: boolean): Promise<PublicCallStackItem>;
-    protected getPublicCallStackPreimages(result: PublicExecutionResult): Promise<PublicCallStackItem[]>;
-    protected getBytecodeHash(_result: PublicExecutionResult): Promise<Fr>;
-    /**
-     * Calculates the PublicCircuitOutput for this execution result along with its proof,
-     * and assembles a PublicCallData object from it.
-     * @param result - The execution result.
-     * @param preimages - The preimages of the callstack items.
-     * @param isExecutionRequest - Whether the current callstack item should be considered a public fn execution request.
-     * @returns A corresponding PublicCallData object.
-     */
-    protected getPublicCallData(result: PublicExecutionResult, isExecutionRequest?: boolean): Promise<PublicCallData>;
-}
-//# sourceMappingURL=abstract_phase_manager.d.ts.map

package/dest/sequencer/abstract_phase_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract_phase_manager.d.ts","sourceRoot":"","sources":["../../src/sequencer/abstract_phase_manager.ts"],"names":[],"mappings":"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"}