@aztec/ethereum 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/contracts/{tally_slashing_proposer.ts → slashing_proposer.ts}

@@ -3,11 +3,13 @@ import type { ViemClient } from '@aztec/ethereum/types';
 import { mergeAbis, tryExtractEvent } from '@aztec/ethereum/utils';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
+import { createLogger } from '@aztec/foundation/log';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
-import { TallySlashingProposerAbi } from '@aztec/l1-artifacts/TallySlashingProposerAbi';
+import { SlashingProposerAbi } from '@aztec/l1-artifacts/SlashingProposerAbi';
 
 import {
   type GetContractReturnType,
@@ -18,14 +20,23 @@ import {
   getContract,
 } from 'viem';
 
+import { type WatchContractEventOptions, watchContractEvent } from './watch_event.js';
+
 /**
- * Wrapper around the TallySlashingProposer contract that provides
+ * Wrapper around the SlashingProposer contract that provides
  * a TypeScript interface for interacting with the consensus-based slashing system.
  */
-export class TallySlashingProposerContract {
-  private readonly contract: GetContractReturnType<typeof TallySlashingProposerAbi, ViemClient>;
+export class SlashingProposerContract {
+  private readonly contract: GetContractReturnType<typeof SlashingProposerAbi, ViemClient>;
+  private readonly logger = createLogger('ethereum:slashing_proposer');
 
-  public readonly type = 'tally' as const;
+  /**
+   * Slash target validators of the last round asked for. Safe to cache because a round's targets are the committees
+   * of epochs that had already ended when the round opened (see SLASH_OFFSET_IN_ROUNDS), and those committees are
+   * sampled from validator set and randao snapshots taken before the epoch started, so they cannot change while the
+   * round is live. The promise is cached rather than the result, so concurrent callers share one in-flight read.
+   */
+  private slashTargetValidators: { round: bigint; validators: Promise<EthAddress[]> } | undefined;
 
   constructor(
     public readonly client: ViemClient,
@@ -33,7 +44,7 @@ export class TallySlashingProposerContract {
   ) {
     this.contract = getContract({
       address: typeof address === 'string' ? address : address.toString(),
-      abi: TallySlashingProposerAbi,
+      abi: SlashingProposerAbi,
       client,
     });
   }
@@ -66,6 +77,8 @@ export class TallySlashingProposerContract {
     return this.contract.read.EXECUTION_DELAY_IN_ROUNDS();
   }
 
+  /** Returns the slash amounts for the three slash unit levels. Immutable on the contract, so memoized. */
+  @memoize
   public getSlashingAmounts(): Promise<[bigint, bigint, bigint]> {
     return Promise.all([
       this.contract.read.SLASH_AMOUNT_SMALL(),
@@ -136,12 +149,12 @@ export class TallySlashingProposerContract {
 
   /** Tries to extract a VoteCast event from the given logs. */
   public tryExtractVoteCastEvent(logs: Log[]) {
-    return tryExtractEvent(logs, this.address.toString(), TallySlashingProposerAbi, 'VoteCast');
+    return tryExtractEvent(logs, this.address.toString(), SlashingProposerAbi, 'VoteCast');
   }
 
   /** Tries to extract a RoundExecuted event from the given logs. */
   public tryExtractRoundExecutedEvent(logs: Log[]) {
-    return tryExtractEvent(logs, this.address.toString(), TallySlashingProposerAbi, 'RoundExecuted');
+    return tryExtractEvent(logs, this.address.toString(), SlashingProposerAbi, 'RoundExecuted');
   }
 
   /**
@@ -161,9 +174,9 @@ export class TallySlashingProposerContract {
 
     return {
       to: this.contract.address,
-      abi: TallySlashingProposerAbi,
+      abi: SlashingProposerAbi,
       data: encodeFunctionData({
-        abi: TallySlashingProposerAbi,
+        abi: SlashingProposerAbi,
         functionName: 'vote',
         args: [votes, signature.toViemSignature()],
       }),
@@ -173,7 +186,7 @@ export class TallySlashingProposerContract {
   /** Returns the typed data definition to EIP712-sign for voting */
   public buildVoteTypedData(votes: Hex, slot: SlotNumber): TypedDataDefinition {
     const domain = {
-      name: 'TallySlashingProposer',
+      name: 'SlashingProposer',
       version: '1',
       chainId: this.client.chain.id,
       verifyingContract: this.contract.address,
@@ -209,9 +222,9 @@ export class TallySlashingProposerContract {
   public buildVoteRequestWithSignature(votes: Hex, signature: { v: number; r: Hex; s: Hex }): L1TxRequest {
     return {
       to: this.contract.address,
-      abi: TallySlashingProposerAbi,
+      abi: SlashingProposerAbi,
       data: encodeFunctionData({
-        abi: TallySlashingProposerAbi,
+        abi: SlashingProposerAbi,
         functionName: 'vote',
         args: [votes, signature],
       }),
@@ -227,75 +240,136 @@ export class TallySlashingProposerContract {
   public buildExecuteRoundRequest(round: bigint, committees: EthAddress[][]): L1TxRequest {
     return {
       to: this.contract.address,
-      abi: mergeAbis([TallySlashingProposerAbi, SlasherAbi]),
+      abi: mergeAbis([SlashingProposerAbi, SlasherAbi]),
       data: encodeFunctionData({
-        abi: TallySlashingProposerAbi,
+        abi: SlashingProposerAbi,
         functionName: 'executeRound',
         args: [round, committees.map(c => c.map(addr => addr.toString()))],
       }),
     };
   }
 
+  /**
+   * Returns the validators eligible to be voted against in a round, in the order votes encode them. Cached for the
+   * last round asked for: reading them runs a committee sampling simulation on L1, and every vote of a round decodes
+   * against the same list, so a caller walking a round's votes would otherwise repeat that call per vote. Only the
+   * last round is kept since callers move forward round by round.
+   */
+  public getSlashTargetValidators(round: bigint): Promise<EthAddress[]> {
+    const cached = this.slashTargetValidators;
+    if (cached?.round === round) {
+      return cached.validators;
+    }
+
+    const entry = { round, validators: this.fetchSlashTargetValidators(round) };
+    this.slashTargetValidators = entry;
+    // A failed read must not stay cached, or every later vote of the round would replay the same rejection
+    entry.validators.catch(() => {
+      if (this.slashTargetValidators === entry) {
+        this.slashTargetValidators = undefined;
+      }
+    });
+    return entry.validators;
+  }
+
+  private async fetchSlashTargetValidators(round: bigint): Promise<EthAddress[]> {
+    const { result } = await this.contract.simulate.getSlashTargetCommittees([round]);
+    return result.flat().map(validator => EthAddress.fromString(validator));
+  }
+
+  /**
+   * Returns the slash amount voted for each target validator by a single vote of a round.
+   * @param index - Position of the vote within the round, from 0 (inclusive) to the round's vote count (exclusive)
+   */
+  public async getVoteAt(round: bigint, index: bigint): Promise<SlashVoteTarget[]> {
+    const [validators, vote, slashAmounts] = await Promise.all([
+      this.getSlashTargetValidators(round),
+      this.contract.read.getVotes([round, index]),
+      this.getSlashingAmounts(),
+    ]);
+    return decodeVote(vote, validators, slashAmounts);
+  }
+
   /** Returns the last vote emitted for a given round  */
   public async getLastVote(round: bigint) {
     const { voteCount } = await this.getRound(round);
-    const validators = (await this.contract.simulate.getSlashTargetCommittees([round])).result.flat();
-    const vote = await this.contract.read.getVotes([round, voteCount - 1n]);
-    const decoded = decodeSlashConsensusVotes(hexToBuffer(vote));
-    const slashAmounts = await this.getSlashingAmounts();
-    return decoded
-      .map((units, i) => ({
-        validator: EthAddress.fromString(validators[i]),
-        slashAmount: slashAmounts[units - 1] ?? 0n,
-      }))
-      .filter(v => v.slashAmount > 0n);
+    return await this.getVoteAt(round, voteCount - 1n);
   }
 
   /**
-   * Listen for VoteCast events
+   * Listen for VoteCast events. Events are delivered by polling `eth_getLogs`: a reorg may re-emit them and
+   * removals are never reported, and events mined within roughly one polling interval of subscribing may be missed.
    * @param callback - Callback function to handle vote cast events
    * @returns Unwatch function
    */
-  public listenToVoteCast(callback: (args: { round: bigint; proposer: string }) => void): () => void {
-    return this.contract.watchEvent.VoteCast(
-      {},
+  public listenToVoteCast(
+    callback: (args: { round: bigint; proposer: string }) => unknown,
+    options?: WatchContractEventOptions,
+  ): () => void {
+    return watchContractEvent(
+      this.client,
+      this.logger,
       {
-        onLogs: logs => {
-          for (const log of logs) {
-            const { round, proposer } = log.args;
-            if (round !== undefined && proposer) {
-              callback({ round, proposer });
-            }
+        address: this.contract.address,
+        abi: SlashingProposerAbi,
+        eventName: 'VoteCast',
+        onLog: log => {
+          const { round, proposer } = log.args;
+          if (round !== undefined && proposer) {
+            return callback({ round, proposer });
           }
         },
       },
+      options,
     );
   }
 
   /**
-   * Listen for RoundExecuted events
+   * Listen for RoundExecuted events. Events are delivered by polling `eth_getLogs`: a reorg may re-emit them and
+   * removals are never reported, and events mined within roughly one polling interval of subscribing may be missed.
    * @param callback - Callback function to handle round executed events
    * @returns Unwatch function
    */
   public listenToRoundExecuted(
-    callback: (args: { round: bigint; slashCount: bigint; l1BlockHash: Hex }) => void,
+    callback: (args: { round: bigint; slashCount: bigint; l1BlockHash: Hex }) => unknown,
+    options?: WatchContractEventOptions,
   ): () => void {
-    return this.contract.watchEvent.RoundExecuted(
-      {},
+    return watchContractEvent(
+      this.client,
+      this.logger,
       {
-        onLogs: logs => {
-          for (const log of logs) {
-            const { round, slashCount } = log.args;
-            if (round !== undefined && slashCount !== undefined) {
-              callback({ round, slashCount, l1BlockHash: log.blockHash });
-            }
+        address: this.contract.address,
+        abi: SlashingProposerAbi,
+        eventName: 'RoundExecuted',
+        onLog: log => {
+          const { round, slashCount } = log.args;
+          if (round !== undefined && slashCount !== undefined) {
+            return callback({ round, slashCount, l1BlockHash: log.blockHash });
           }
         },
       },
+      options,
     );
   }
 }
 
+/**
+ * A validator targeted by a slashing vote, with the amount voted. The position is the validator's index in the
+ * round's flattened slash target committees — the unit the contract tallies quorum by. A validator sitting in
+ * several of the round's committees holds several positions, each with its own tally.
+ */
+export type SlashVoteTarget = { validator: EthAddress; slashAmount: bigint; position: number };
+
+function decodeVote(vote: Hex, validators: EthAddress[], slashAmounts: [bigint, bigint, bigint]): SlashVoteTarget[] {
+  return decodeSlashConsensusVotes(hexToBuffer(vote))
+    .map((units, position) => ({
+      validator: validators[position],
+      slashAmount: slashAmounts[units - 1] ?? 0n,
+      position,
+    }))
+    .filter(v => v.slashAmount > 0n);
+}
+
 /**
  * Decodes a Buffer containing slash votes back into an array of numbers.
  * Each vote is represented as a 2-bit value (0, 1, 2, or 3) representing slashing units.

package/src/contracts/watch_event.ts

@@ -0,0 +1,110 @@
+import type { Logger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+
+import type { Abi, ContractEventName, GetContractEventsReturnType, Hex } from 'viem';
+
+import type { ViemClient } from '../types.js';
+
+/** Default maximum number of blocks queried per `eth_getLogs` request. */
+const DEFAULT_MAX_BLOCK_RANGE = 100;
+
+/** Options for {@link watchContractEvent}. */
+export type WatchContractEventOptions = {
+  /** How often to poll for new L1 blocks, in ms. Defaults to the client's polling interval. */
+  pollingIntervalMs?: number;
+  /** Maximum number of blocks per `eth_getLogs` request; wider catch-up ranges are split into chunks. */
+  maxBlockRange?: number;
+};
+
+/** Event identity and handler for {@link watchContractEvent}. */
+export type WatchContractEventParameters<
+  TAbi extends Abi,
+  TEventName extends ContractEventName<TAbi>,
+  TStrict extends boolean | undefined = undefined,
+> = {
+  address: Hex;
+  abi: TAbi;
+  eventName: TEventName;
+  /** Whether logs must decode against the event's indexed/non-indexed arguments (defaults to false). */
+  strict?: TStrict;
+  /** Called once per event log. Errors, thrown or from a returned promise, are caught and logged. */
+  onLog: (log: GetContractEventsReturnType<TAbi, TEventName, TStrict>[number]) => unknown;
+};
+
+/**
+ * Watches for contract events by polling `eth_blockNumber` (cached by viem per client) and fetching new logs with
+ * ranged `eth_getLogs` requests, never installing server-side filters. Server-side filters are unusable against
+ * real-world endpoints: a load balancer routes polls to backends that never saw the filter, and providers report a
+ * purged filter with error codes viem does not recognize as "filter gone", so viem's own watchers either churn
+ * recreating filters or poll a dead filter id forever while silently missing events.
+ *
+ * The block that is latest on the first poll becomes the starting cursor, so its events are reported and events from
+ * earlier blocks are not. Requests never span more than `maxBlockRange` blocks: catching up after downtime is
+ * chunked into multiple requests, and the cursor advances per successful chunk so a failure retries from where it
+ * left off on the next tick. A reorg may re-emit events and removals are never reported.
+ *
+ * @returns A function that stops the watcher.
+ */
+export function watchContractEvent<
+  TAbi extends Abi,
+  TEventName extends ContractEventName<TAbi>,
+  TStrict extends boolean | undefined = undefined,
+>(
+  client: ViemClient,
+  logger: Logger,
+  params: WatchContractEventParameters<TAbi, TEventName, TStrict>,
+  options: WatchContractEventOptions = {},
+): () => void {
+  const { address, abi, eventName, strict, onLog } = params;
+  const pollingIntervalMs = options.pollingIntervalMs ?? client.pollingInterval;
+  const maxBlockRange = BigInt(options.maxBlockRange ?? DEFAULT_MAX_BLOCK_RANGE);
+
+  const logHandlerError = (err: unknown) => logger.error(`Error handling ${eventName} L1 event`, err);
+  const deliver = (log: GetContractEventsReturnType<TAbi, TEventName, TStrict>[number]) => {
+    try {
+      const result = onLog(log);
+      if (result instanceof Promise) {
+        result.catch(logHandlerError);
+      }
+    } catch (err) {
+      logHandlerError(err);
+    }
+  };
+
+  let stopped = false;
+  let nextBlock: bigint | undefined;
+
+  const poll = async () => {
+    const latestBlock = await client.getBlockNumber();
+    if (nextBlock === undefined) {
+      nextBlock = latestBlock;
+      return;
+    }
+    let fromBlock: bigint = nextBlock;
+    while (fromBlock <= latestBlock && !stopped) {
+      const chunkEnd = fromBlock + maxBlockRange - 1n;
+      const toBlock = chunkEnd < latestBlock ? chunkEnd : latestBlock;
+      const logs = await client.getContractEvents<TAbi, TEventName, TStrict, bigint, bigint>({
+        address,
+        abi,
+        eventName,
+        strict,
+        fromBlock,
+        toBlock,
+      });
+      for (const log of logs) {
+        deliver(log);
+      }
+      fromBlock = toBlock + 1n;
+      nextBlock = fromBlock;
+    }
+  };
+
+  const handlePollError = (err: unknown) => logger.warn(`Error polling for ${eventName} L1 events`, { err });
+  const runner = new RunningPromise(poll, logger, pollingIntervalMs, handlePollError).start();
+
+  return () => {
+    stopped = true;
+    void runner.stop();
+  };
+}

package/src/deploy_aztec_l1_contracts.ts

@@ -19,11 +19,11 @@ import { mainnet, sepolia } from 'viem/chains';
 
 import { createEthereumChain, isAnvilTestChain } from './chain.js';
 import { createExtendedL1Client } from './client.js';
-import type { L1ContractsConfig } from './config.js';
+import { type L1ContractsConfig, assertValidSlotDurations } from './config.js';
 import { deployMulticall3 } from './contracts/multicall.js';
 import { RollupContract } from './contracts/rollup.js';
+import { resolveFoundryBinary } from './foundry_binary.js';
 import type { L1ContractAddresses } from './l1_contract_addresses.js';
-import type { L1TxUtilsConfig } from './l1_tx_utils/config.js';
 import type { ExtendedViemWalletClient } from './types.js';
 
 const logger = createLogger('ethereum:deploy_aztec_l1_contracts');
@@ -31,9 +31,9 @@ const logger = createLogger('ethereum:deploy_aztec_l1_contracts');
 const JSON_DEPLOY_RESULT_PREFIX = 'JSON DEPLOY RESULT:';
 
 /**
- * Runs a process with the given command, arguments, and environment.
- * If the process outputs a line starting with JSON_DEPLOY_RESULT_PREFIX,
- * the JSON is parsed and returned.
+ * Runs a process and parses JSON deploy results from stdout.
+ * Lines starting with JSON_DEPLOY_RESULT_PREFIX are parsed and returned.
+ * All other stdout goes to logger.info, stderr goes to logger.warn.
  */
 function runProcess<T>(
   command: string,
@@ -49,26 +49,41 @@ function runProcess<T>(
   });
 
   let result: T | undefined;
+  let parseError: Error | undefined;
+  let settled = false;
 
   readline.createInterface({ input: proc.stdout }).on('line', line => {
     const trimmedLine = line.trim();
     if (trimmedLine.startsWith(JSON_DEPLOY_RESULT_PREFIX)) {
       const jsonStr = trimmedLine.slice(JSON_DEPLOY_RESULT_PREFIX.length).trim();
-      // TODO(AD): should this be a zod parse?
-      result = JSON.parse(jsonStr);
+      try {
+        result = JSON.parse(jsonStr);
+      } catch {
+        parseError = new Error(`Failed to parse deploy result JSON: ${jsonStr.slice(0, 200)}`);
+      }
     } else {
       logger.info(line);
     }
   });
-  readline.createInterface({ input: proc.stderr }).on('line', logger.error.bind(logger));
+  readline.createInterface({ input: proc.stderr }).on('line', logger.warn.bind(logger));
 
   proc.on('error', error => {
+    if (settled) {
+      return;
+    }
+    settled = true;
     reject(new Error(`Failed to spawn ${command}: ${error.message}`));
   });
 
   proc.on('close', code => {
+    if (settled) {
+      return;
+    }
+    settled = true;
     if (code !== 0) {
-      reject(new Error(`${command} exited with code ${code}. See logs for details.\n`));
+      reject(new Error(`${command} exited with code ${code}`));
+    } else if (parseError) {
+      reject(parseError);
     } else {
       resolve(result);
     }
@@ -79,11 +94,16 @@ function runProcess<T>(
 
 // Covers an edge where where we may have a cached BlobLib that is not meant for production.
 // Despite the profile apparently sometimes cached code remains (so says Lasse after his ignition-monorepo arc).
-async function maybeForgeForceProductionBuild(l1ContractsPath: string, script: string, chainId: number) {
+async function maybeForgeForceProductionBuild(
+  forgeBin: string,
+  l1ContractsPath: string,
+  script: string,
+  chainId: number,
+) {
   if (chainId === mainnet.id) {
     logger.info(`Recompiling ${script} with production profile for mainnet deployment`);
     logger.info('This may take a minute but ensures production BlobLib is used.');
-    await runProcess('forge', ['build', script, '--force'], { FOUNDRY_PROFILE: 'production' }, l1ContractsPath);
+    await runProcess(forgeBin, ['build', script, '--force'], { FOUNDRY_PROFILE: 'production' }, l1ContractsPath);
   }
 }
 
@@ -216,7 +236,6 @@ export function computeValidatorData(operator: Operator): ValidatorJson {
 export interface RollupUpgradeAddresses {
   rollupAddress: string;
   verifierAddress: string;
-  slashFactoryAddress: string;
   inboxAddress: string;
   outboxAddress: string;
   feeJuicePortalAddress: string;
@@ -229,7 +248,6 @@ export interface RollupUpgradeAddresses {
 export interface ForgeRollupUpgradeResult {
   rollupAddress: Hex;
   verifierAddress: Hex;
-  slashFactoryAddress: Hex;
   inboxAddress: Hex;
   outboxAddress: Hex;
   feeJuicePortalAddress: Hex;
@@ -270,6 +288,7 @@ export async function deployAztecL1Contracts(
   args: DeployAztecL1ContractsArgs,
 ): Promise<DeployAztecL1ContractsReturnType> {
   logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
+  assertValidSlotDurations(args);
   if (args.initialValidators && args.initialValidators.length > 0 && args.existingTokenAddress) {
     throw new Error(
       'Cannot deploy with both initialValidators and existingTokenAddress. ' +
@@ -307,8 +326,9 @@ export async function deployAztecL1Contracts(
   // Use foundry-artifacts from l1-artifacts package
   const l1ContractsPath = prepareL1ContractsForDeployment();
 
+  const forgeBin = resolveFoundryBinary('forge');
   const FORGE_SCRIPT = 'script/deploy/DeployAztecL1Contracts.s.sol';
-  await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
+  await maybeForgeForceProductionBuild(forgeBin, l1ContractsPath, FORGE_SCRIPT, chainId);
 
   // Verify contracts on Etherscan when on mainnet/sepolia and ETHERSCAN_API_KEY is available.
   const isVerifiableChain = chainId === mainnet.id || chainId === sepolia.id;
@@ -321,11 +341,8 @@ export async function deployAztecL1Contracts(
     );
   }
 
-  // From heuristic testing. More caused issues with anvil.
-  const MAGIC_ANVIL_BATCH_SIZE = 8;
-  // Anvil seems to stall with unbounded batch size. Otherwise no max batch size is desirable.
+  const scriptPath = join(getL1ContractsPath(), 'scripts', 'forge_broadcast.js');
   const forgeArgs = [
-    'script',
     FORGE_SCRIPT,
     '--sig',
     'run()',
@@ -333,18 +350,22 @@ export async function deployAztecL1Contracts(
     privateKey,
     '--rpc-url',
     rpcUrl,
-    '--broadcast',
-    '--batch-size',
-    MAGIC_ANVIL_BATCH_SIZE.toString(),
     ...(shouldVerify ? ['--verify'] : []),
   ];
   const forgeEnv = {
+    // Resolved forge binary picked up by forge_broadcast.js, so it works without forge on PATH.
+    FORGE_BIN: forgeBin,
     // Env vars required by l1-contracts/script/deploy/DeploymentConfiguration.sol.
     NETWORK: getActiveNetworkName(),
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
     ...getDeployAztecL1ContractsEnvVars(args),
   };
-  const result = await runProcess<ForgeL1ContractsDeployResult>('forge', forgeArgs, forgeEnv, l1ContractsPath);
+  const result = await runProcess<ForgeL1ContractsDeployResult>(
+    process.execPath,
+    [scriptPath, ...forgeArgs],
+    forgeEnv,
+    l1ContractsPath,
+  );
   if (!result) {
     throw new Error('Forge script did not output deployment result');
   }
@@ -390,7 +411,6 @@ export async function deployAztecL1Contracts(
       governanceProposerAddress: EthAddress.fromString(result.governanceProposerAddress),
       governanceAddress: EthAddress.fromString(result.governanceAddress),
       stakingAssetAddress: EthAddress.fromString(result.stakingAssetAddress),
-      slashFactoryAddress: result.slashFactoryAddress ? EthAddress.fromString(result.slashFactoryAddress) : undefined,
       feeAssetHandlerAddress: result.feeAssetHandlerAddress
         ? EthAddress.fromString(result.feeAssetHandlerAddress)
         : undefined,
@@ -477,7 +497,25 @@ export type VerificationRecord = {
   libraries: VerificationLibraryEntry[];
 };
 
-export interface DeployAztecL1ContractsArgs extends Omit<L1ContractsConfig, keyof L1TxUtilsConfig> {
+export interface DeployAztecL1ContractsArgs
+  extends Omit<
+    L1ContractsConfig,
+    | 'gasLimitBufferPercentage'
+    | 'maxGwei'
+    | 'maxBlobGwei'
+    | 'priorityFeeBumpPercentage'
+    | 'priorityFeeRetryBumpPercentage'
+    | 'minimumPriorityFeePerGas'
+    | 'maxSpeedUpAttempts'
+    | 'checkIntervalMs'
+    | 'stallTimeMs'
+    | 'txTimeoutMs'
+    | 'cancelTxOnTimeout'
+    | 'txCancellationFinalTimeoutMs'
+    | 'txUnseenConsideredDroppedMs'
+    | 'enableDelayer'
+    | 'txDelayerMaxInclusionTimeIntoSlot'
+  > {
   /** The vk tree root. */
   vkTreeRoot: Fr;
   /** The hash of the protocol contracts. */
@@ -554,7 +592,7 @@ export function getDeployRollupForUpgradeEnvVars(
     AZTEC_EXIT_DELAY_SECONDS: args.exitDelaySeconds.toString(),
     AZTEC_PROVING_COST_PER_MANA: args.provingCostPerMana.toString(),
     AZTEC_INITIAL_ETH_PER_FEE_ASSET: args.initialEthPerFeeAsset.toString(),
-    AZTEC_SLASHER_FLAVOR: args.slasherFlavor,
+    AZTEC_SLASHER_ENABLED: args.slasherEnabled ? 'true' : 'false',
     AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: args.slashingRoundSizeInEpochs.toString(),
     AZTEC_SLASHING_QUORUM: args.slashingQuorum?.toString(),
     AZTEC_SLASHING_OFFSET_IN_ROUNDS: args.slashingOffsetInRounds.toString(),
@@ -584,21 +622,15 @@ export const deployRollupForUpgrade = async (
   // Use foundry-artifacts from l1-artifacts package
   const l1ContractsPath = prepareL1ContractsForDeployment();
 
+  const forgeBin = resolveFoundryBinary('forge');
   const FORGE_SCRIPT = 'script/deploy/DeployRollupForUpgrade.s.sol';
-  await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
+  await maybeForgeForceProductionBuild(forgeBin, l1ContractsPath, FORGE_SCRIPT, chainId);
 
-  const forgeArgs = [
-    'script',
-    FORGE_SCRIPT,
-    '--sig',
-    'run()',
-    '--private-key',
-    privateKey,
-    '--rpc-url',
-    rpcUrl,
-    '--broadcast',
-  ];
+  const scriptPath = join(getL1ContractsPath(), 'scripts', 'forge_broadcast.js');
+  const forgeArgs = [FORGE_SCRIPT, '--sig', 'run()', '--private-key', privateKey, '--rpc-url', rpcUrl];
   const forgeEnv = {
+    // Resolved forge binary picked up by forge_broadcast.js, so it works without forge on PATH.
+    FORGE_BIN: forgeBin,
     FOUNDRY_PROFILE: chainId === mainnet.id ? 'production' : undefined,
     // Env vars required by l1-contracts/script/deploy/RollupConfiguration.sol.
     REGISTRY_ADDRESS: registryAddress.toString(),
@@ -606,7 +638,12 @@ export const deployRollupForUpgrade = async (
     ...getDeployRollupForUpgradeEnvVars(args),
   };
 
-  const result = await runProcess<ForgeRollupUpgradeResult>('forge', forgeArgs, forgeEnv, l1ContractsPath);
+  const result = await runProcess<ForgeRollupUpgradeResult>(
+    process.execPath,
+    [scriptPath, ...forgeArgs],
+    forgeEnv,
+    l1ContractsPath,
+  );
   if (!result) {
     throw new Error('Forge script did not output deployment result');
   }
@@ -618,6 +655,5 @@ export const deployRollupForUpgrade = async (
 
   return {
     rollup,
-    slashFactoryAddress: result.slashFactoryAddress,
   };
 };

package/src/deploy_l1_contract.ts

@@ -24,7 +24,7 @@ import {
 } from './deploy_aztec_l1_contracts.js';
 import { RegisterNewRollupVersionPayloadArtifact } from './l1_artifacts.js';
 import { type L1TxUtilsConfig, getL1TxUtilsConfigEnvVars } from './l1_tx_utils/config.js';
-import { createL1TxUtilsFromViemWallet } from './l1_tx_utils/factory.js';
+import { createL1TxUtils } from './l1_tx_utils/factory.js';
 import type { L1TxUtils } from './l1_tx_utils/l1_tx_utils.js';
 import type { GasPrice, L1TxConfig, L1TxRequest } from './l1_tx_utils/types.js';
 import type { ExtendedViemWalletClient } from './types.js';
@@ -46,7 +46,7 @@ export class L1Deployer {
     private createVerificationJson: boolean = false,
   ) {
     this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), { size: 32 }) : undefined;
-    this.l1TxUtils = createL1TxUtilsFromViemWallet(
+    this.l1TxUtils = createL1TxUtils(
       this.client,
       { logger: this.logger, dateProvider },
       { ...this.txUtilsConfig, debugMaxGasLimit: acceleratedTestDeployments },
@@ -179,7 +179,7 @@ export async function deployL1Contract(
 
   if (!l1TxUtils) {
     const config = getL1TxUtilsConfigEnvVars();
-    l1TxUtils = createL1TxUtilsFromViemWallet(
+    l1TxUtils = createL1TxUtils(
       extendedClient,
       { logger },
       { ...config, debugMaxGasLimit: acceleratedTestDeployments },