@aztec/sequencer-client 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/slasher/slasher_client.ts

@@ -1,193 +0,0 @@
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  type ViemPublicClient,
-  createEthereumChain,
-} from '@aztec/ethereum';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { SlashFactoryAbi } from '@aztec/l1-artifacts';
-import {
-  type L2BlockId,
-  type L2BlockSourceEvent,
-  type L2BlockSourceEventEmitter,
-  L2BlockSourceEvents,
-} from '@aztec/stdlib/block';
-import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
-
-import { type GetContractReturnType, createPublicClient, fallback, getAddress, getContract, http } from 'viem';
-
-/**
- * Enum defining the possible states of the Slasher client.
- */
-export enum SlasherClientState {
-  IDLE,
-  RUNNING,
-  STOPPED,
-}
-
-/**
- * The synchronization status of the Slasher client.
- */
-export interface SlasherSyncState {
-  /**
-   * The current state of the slasher client.
-   */
-  state: SlasherClientState;
-  /**
-   * The block number that the slasher client is synced to.
-   */
-  syncedToL2Block: L2BlockId;
-}
-
-export interface SlasherConfig {
-  blockCheckIntervalMS: number;
-  blockRequestBatchSize: number;
-}
-
-type SlashEvent = {
-  epoch: bigint;
-  amount: bigint;
-  lifetime: bigint;
-};
-
-/**
- * @notice A Hypomeiones slasher client implementation
- *
- * Hypomeiones: a class of individuals in ancient Sparta who were considered inferior or lesser citizens compared
- * to the full Spartan citizens.
- *
- * The implementation here is less than ideal. It exists, not to be the end all be all, but to show that
- * slashing can be done with this mechanism.
- *
- * The implementation is VERY brute in the sense that it only looks for pruned blocks and then tries to slash
- * the full committee of that.
- * If it sees a prune, it will mark the full epoch as "to be slashed".
- *
- * Also, it is not particularly smart around what it should if there were to be multiple slashing events.
- *
- * A few improvements:
- * - Only vote on the proposal if it is possible to reach, e.g., if 6 votes are needed and only 4 slots are left don't vote.
- * - Stop voting on a payload once it is processed.
- * - Only vote on the proposal if it have not already been executed
- *  - Caveat, we need to fully decide if it is acceptable to have the same payload address multiple times. In the current
- *    slash factory that could mean slashing the same committee for the same error multiple times.
- * - Decide how to deal with multiple slashing events in the same round.
- *  - This could be that multiple epochs are pruned in the same round, but with the current naive implementation we could end up
- *    slashing only the first, because the "lifetime" of the second would have passed after that vote
- */
-export class SlasherClient extends WithTracer {
-  private slashEvents: SlashEvent[] = [];
-
-  protected slashFactoryContract?: GetContractReturnType<typeof SlashFactoryAbi, ViemPublicClient> = undefined;
-
-  // The amount to slash for a prune.
-  // Note that we set it to 0, such that no actual slashing will happen, but the event will be fired,
-  // showing that the slashing mechanism is working.
-  private slashingAmount: bigint = 0n;
-
-  constructor(
-    private config: SlasherConfig & L1ContractsConfig & L1ReaderConfig,
-    private l2BlockSource: L2BlockSourceEventEmitter,
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('slasher'),
-  ) {
-    super(telemetry, 'slasher');
-
-    if (config.l1Contracts.slashFactoryAddress && config.l1Contracts.slashFactoryAddress !== EthAddress.ZERO) {
-      const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
-      const publicClient = createPublicClient({
-        chain: chain.chainInfo,
-        transport: fallback(chain.rpcUrls.map(url => http(url))),
-        pollingInterval: config.viemPollingIntervalMS,
-      });
-
-      this.slashFactoryContract = getContract({
-        address: getAddress(config.l1Contracts.slashFactoryAddress.toString()),
-        abi: SlashFactoryAbi,
-        client: publicClient,
-      });
-    } else {
-      this.log.warn('No slash factory address found, slashing will not be enabled');
-    }
-
-    this.log.info(`Slasher client initialized`);
-  }
-
-  public start() {
-    this.log.info('Starting Slasher client...');
-    this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
-  }
-
-  // This is where we should put a bunch of the improvements mentioned earlier.
-  public async getSlashPayload(slotNumber: bigint): Promise<EthAddress | undefined> {
-    if (!this.slashFactoryContract) {
-      return undefined;
-    }
-
-    // As long as the slot is greater than the lifetime, we want to keep deleting the first element
-    // since it will not make sense to include anymore.
-    while (this.slashEvents.length > 0 && this.slashEvents[0].lifetime < slotNumber) {
-      this.slashEvents.shift();
-    }
-
-    if (this.slashEvents.length == 0) {
-      return undefined;
-    }
-
-    const slashEvent = this.slashEvents[0];
-
-    const [payloadAddress, isDeployed] = await this.slashFactoryContract.read.getAddressAndIsDeployed([
-      slashEvent.epoch,
-      slashEvent.amount,
-    ]);
-
-    if (!isDeployed) {
-      // The proposal cannot be executed until it is deployed
-      this.log.verbose(`Voting on not yet deployed payload: ${payloadAddress}`);
-    }
-
-    return EthAddress.fromString(payloadAddress);
-  }
-
-  public handleBlockStreamEvent(event: L2BlockSourceEvent): Promise<void> {
-    this.log.debug(`Handling block stream event ${event.type}`);
-    switch (event.type) {
-      case L2BlockSourceEvents.L2PruneDetected:
-        this.handlePruneL2Blocks(event);
-        break;
-      default: {
-        break;
-      }
-    }
-    return Promise.resolve();
-  }
-
-  /**
-   * Allows consumers to stop the instance of the slasher client.
-   * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
-   */
-  public stop() {
-    this.log.debug('Stopping Slasher client...');
-    this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
-    this.log.info('Slasher client stopped.');
-  }
-
-  // I need to get the slot number from the block that was just pruned
-  private handlePruneL2Blocks(event: L2BlockSourceEvent): void {
-    const { slotNumber, epochNumber } = event;
-    this.log.info(`Detected chain prune. Punishing the validators at epoch ${epochNumber}`);
-
-    // Set the lifetime such that we have a full round that we could vote throughout.
-    const slotsIntoRound = slotNumber % BigInt(this.config.slashingRoundSize);
-    const toNext = slotsIntoRound == 0n ? 0n : BigInt(this.config.slashingRoundSize) - slotsIntoRound;
-
-    const lifetime = slotNumber + toNext + BigInt(this.config.slashingRoundSize);
-
-    this.slashEvents.push({
-      epoch: epochNumber,
-      amount: this.slashingAmount,
-      lifetime,
-    });
-  }
-}

package/src/tx_validator/archive_cache.ts

@@ -1,28 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { ArchiveSource } from '@aztec/p2p';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-
-/**
- * Implements an archive source by checking a DB and an in-memory collection.
- * Intended for validating transactions as they are added to a block.
- */
-export class ArchiveCache implements ArchiveSource {
-  archives: Map<string, bigint>;
-
-  constructor(private db: MerkleTreeReadOperations) {
-    this.archives = new Map<string, bigint>();
-  }
-
-  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
-    const toCheckDb = archives.filter(n => !this.archives.has(n.toString()));
-    const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
-    dbHits.forEach((x, index) => {
-      if (x !== undefined) {
-        this.archives.set(toCheckDb[index].toString(), x);
-      }
-    });
-
-    return archives.map(n => this.archives.get(n.toString()));
-  }
-}

package/src/tx_validator/gas_validator.ts

@@ -1,101 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { getExecutionRequestsByPhase } from '@aztec/simulator/server';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasFees } from '@aztec/stdlib/gas';
-import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
-
-/** Provides a view into public contract state */
-export interface PublicStateSource {
-  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
-}
-
-export class GasTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_gas');
-  #publicDataSource: PublicStateSource;
-  #feeJuiceAddress: AztecAddress;
-  #gasFees: GasFees;
-
-  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees) {
-    this.#publicDataSource = publicDataSource;
-    this.#feeJuiceAddress = feeJuiceAddress;
-    this.#gasFees = gasFees;
-  }
-
-  async validateTx(tx: Tx): Promise<TxValidationResult> {
-    if (await this.#shouldSkip(tx)) {
-      return Promise.resolve({ result: 'skipped', reason: ['Insufficient fee per gas'] });
-    }
-    return this.#validateTxFee(tx);
-  }
-
-  /**
-   * Check whether the tx's max fees are valid for the current block, and skip if not.
-   * We skip instead of invalidating since the tx may become eligible later.
-   * Note that circuits check max fees even if fee payer is unset, so we
-   * keep this validation even if the tx does not pay fees.
-   */
-  async #shouldSkip(tx: Tx): Promise<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 ${await tx.getTxHash()} due to insufficient fee per gas`, {
-        txMaxFeesPerGas: maxFeesPerGas.toInspect(),
-        currentGasFees: this.#gasFees.toInspect(),
-      });
-    }
-    return notEnoughMaxFees;
-  }
-
-  async #validateTxFee(tx: Tx): Promise<TxValidationResult> {
-    const feePayer = tx.data.feePayer;
-
-    // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
-    const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
-
-    // Read current balance of the feePayer
-    const initialBalance = await this.#publicDataSource.storageRead(
-      this.#feeJuiceAddress,
-      await computeFeePayerBalanceStorageSlot(feePayer),
-    );
-
-    // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
-    const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
-    const increasePublicBalanceSelector = await FunctionSelector.fromSignature(
-      '_increase_public_balance((Field),u128)',
-    );
-    const claimFunctionCall = setupFns.find(
-      fn =>
-        fn.callContext.contractAddress.equals(this.#feeJuiceAddress) &&
-        fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
-        fn.args.length > 2 &&
-        // Public functions get routed through the dispatch function, whose first argument is the target function selector.
-        fn.args[0].equals(increasePublicBalanceSelector.toField()) &&
-        fn.args[1].equals(feePayer.toField()) &&
-        !fn.callContext.isStaticCall,
-    );
-
-    // The claim amount is at index 2 in the args array because:
-    // - Index 0: Target function selector (due to dispatch routing)
-    // - Index 1: Amount recipient
-    // - Index 2: Amount being claimed
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
-    if (balance.lt(feeLimit)) {
-      this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
-        feePayer,
-        balance: balance.toBigInt(),
-        feeLimit: feeLimit.toBigInt(),
-      });
-      return { result: 'invalid', reason: ['Insufficient fee payer balance'] };
-    }
-    return { result: 'valid' };
-  }
-}

package/src/tx_validator/phases_validator.ts

@@ -1,98 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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,
-  };
-}