@aztec/sequencer-client 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/src/global_variable_builder/global_builder.ts

@@ -1,23 +1,23 @@
-import { RollupContract } from '@aztec/ethereum/contracts';
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import {
+  RollupContract,
+  type SimulationOverridesPlan,
+  buildSimulationOverridesStateOverride,
+} from '@aztec/ethereum/contracts';
 import type { ViemPublicClient } from '@aztec/ethereum/types';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import type { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type L1RollupConstants, getNextL1SlotTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
 import type {
   CheckpointGlobalVariables,
   GlobalVariableBuilder as GlobalVariableBuilderInterface,
 } from '@aztec/stdlib/tx';
-import { GlobalVariables } from '@aztec/stdlib/tx';
 
 /** Configuration for the GlobalVariableBuilder (excludes L1 client config). */
 export type GlobalVariableBuilderConfig = {
-  l1Contracts: Pick<L1ContractAddresses, 'rollupAddress'>;
+  rollupAddress: EthAddress;
   ethereumSlotDuration: number;
   rollupVersion: bigint;
 } & Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'>;
@@ -26,12 +26,7 @@ export type GlobalVariableBuilderConfig = {
  * Simple global variables builder.
  */
 export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
-  private log = createLogger('sequencer:global_variable_builder');
-  private currentMinFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
-  private currentL1BlockNumber: bigint | undefined = undefined;
-
   private readonly rollupContract: RollupContract;
-  private readonly ethereumSlotDuration: number;
   private readonly aztecSlotDuration: number;
   private readonly l1GenesisTime: bigint;
 
@@ -39,79 +34,16 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private version: Fr;
 
   constructor(
-    private readonly dateProvider: DateProvider,
     private readonly publicClient: ViemPublicClient,
     config: GlobalVariableBuilderConfig,
   ) {
     this.version = new Fr(config.rollupVersion);
     this.chainId = new Fr(this.publicClient.chain!.id);
 
-    this.ethereumSlotDuration = config.ethereumSlotDuration;
     this.aztecSlotDuration = config.slotDuration;
     this.l1GenesisTime = config.l1GenesisTime;
 
-    this.rollupContract = new RollupContract(this.publicClient, config.l1Contracts.rollupAddress);
-  }
-
-  /**
-   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
-   * @returns Min fees for the next block
-   */
-  private async computeCurrentMinFees(): Promise<GasFees> {
-    // Since this might be called in the middle of a slot where a block might have been published,
-    // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
-    // The timestamp of that last block will act as a lower bound for the next block.
-
-    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
-    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
-    );
-    const nextEthTimestamp = getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), {
-      l1GenesisTime: this.l1GenesisTime,
-      ethereumSlotDuration: this.ethereumSlotDuration,
-    });
-    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
-
-    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
-  }
-
-  public async getCurrentMinFees(): Promise<GasFees> {
-    // Get the current block number
-    const blockNumber = await this.publicClient.getBlockNumber();
-
-    // If the L1 block number has changed then chain a new promise to get the current min fees
-    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
-      this.currentL1BlockNumber = blockNumber;
-      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
-    }
-    return this.currentMinFees;
-  }
-
-  /**
-   * Simple builder of global variables.
-   * @param blockNumber - The block number to build global variables for.
-   * @param coinbase - The address to receive block reward.
-   * @param feeRecipient - The address to receive fees.
-   * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
-   * @returns The global variables for the given block number.
-   */
-  public async buildGlobalVariables(
-    blockNumber: BlockNumber,
-    coinbase: EthAddress,
-    feeRecipient: AztecAddress,
-    maybeSlot?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    const slot: SlotNumber =
-      maybeSlot ??
-      (await this.rollupContract.getSlotAt(
-        getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), {
-          l1GenesisTime: this.l1GenesisTime,
-          ethereumSlotDuration: this.ethereumSlotDuration,
-        }),
-      ));
-
-    const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);
-    return GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables });
+    this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
   }
 
   /** Builds global variables that are constant throughout a checkpoint. */
@@ -119,6 +51,7 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables> {
     const { chainId, version } = this;
 
@@ -127,9 +60,8 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
       l1GenesisTime: this.l1GenesisTime,
     });
 
-    // We can skip much of the logic in getCurrentMinFees since it we already check that we are not within a slot elsewhere.
-    // TODO(palla/mbps): Can we use a cached value here?
-    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+    const stateOverride = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true, stateOverride));
 
     return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }

package/src/global_variable_builder/index.ts

@@ -1 +1,3 @@
+export { FeeProviderImpl } from './fee_provider.js';
 export { GlobalVariableBuilder, type GlobalVariableBuilderConfig } from './global_builder.js';
+export { FeePredictor } from './fee_predictor.js';

package/src/publisher/config.ts

@@ -1,7 +1,12 @@
 import { type BlobClientConfig, blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l1-tx-utils/config';
-import { type ConfigMappingsType, SecretValue, booleanConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  SecretValue,
+  booleanConfigHelper,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { parseEther } from 'viem';
@@ -90,6 +95,10 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     sequencerPublisherAllowInvalidStates?: boolean;
     sequencerPublisherForwarderAddress?: EthAddress;
+    /** How long to wait for the previous L1 block before sending scheduled publisher txs anyway. */
+    sequencerPublisherPreviousL1BlockWaitTimeoutMs: number;
+    /** Poll interval while waiting for the previous L1 block before scheduled publisher txs. */
+    sequencerPublisherPreviousL1BlockWaitPollIntervalMs: number;
     /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
     l1TxFailedStore?: string;
     /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
@@ -115,12 +124,13 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
   };
 }
 
-export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSenderConfig, 'l1Contracts'>> = {
+export const proverTxSenderConfigMappings: ConfigMappingsType<ProverTxSenderConfig> = {
   ...l1ReaderConfigMappings,
   proverPublisherPrivateKeys: {
     env: `PROVER_PUBLISHER_PRIVATE_KEYS`,
     description: 'The private keys to be used by the prover publisher.',
-    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`PROVER_PUBLISHER_PRIVATE_KEY`],
   },
@@ -132,12 +142,13 @@ export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSende
   },
 };
 
-export const sequencerTxSenderConfigMappings: ConfigMappingsType<Omit<SequencerTxSenderConfig, 'l1Contracts'>> = {
+export const sequencerTxSenderConfigMappings: ConfigMappingsType<SequencerTxSenderConfig> = {
   ...l1ReaderConfigMappings,
   sequencerPublisherPrivateKeys: {
     env: `SEQ_PUBLISHER_PRIVATE_KEYS`,
     description: 'The private keys to be used by the sequencer publisher.',
-    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`SEQ_PUBLISHER_PRIVATE_KEY`],
   },
@@ -166,7 +177,19 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
   sequencerPublisherForwarderAddress: {
     env: `SEQ_PUBLISHER_FORWARDER_ADDRESS`,
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
-    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
+  },
+  sequencerPublisherPreviousL1BlockWaitTimeoutMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_TIMEOUT_MS`,
+    description:
+      'How long to wait for the previous L1 block before sending scheduled publisher txs anyway, in milliseconds.',
+    ...numberConfigHelper(8_000),
+  },
+  sequencerPublisherPreviousL1BlockWaitPollIntervalMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_POLL_INTERVAL_MS`,
+    description:
+      'Poll interval while waiting for the previous L1 block before scheduled publisher txs, in milliseconds.',
+    ...numberConfigHelper(500),
   },
   l1TxFailedStore: {
     env: 'L1_TX_FAILED_STORE',
@@ -192,7 +215,7 @@ export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherCo
   proverPublisherForwarderAddress: {
     env: `PROVER_PUBLISHER_FORWARDER_ADDRESS`,
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
-    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
   },
   ...publisherFundingConfigMappings,
 };

package/src/publisher/l1_to_l2_messaging.ts

@@ -0,0 +1,85 @@
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { tryJsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { InboxAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { decodeEventLog, getContract } from 'viem';
+
+/**
+ * Sends an L1-to-L2 message via the Inbox contract and returns its hash and global leaf index.
+ * Test helper copied from the end-to-end fixtures so this integration test can live in sequencer-client.
+ */
+export async function sendL1ToL2Message(
+  message: { recipient: AztecAddress; content: Fr; secretHash: Fr },
+  ctx: {
+    l1Client: ExtendedViemWalletClient;
+    l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress' | 'rollupAddress'>;
+  },
+) {
+  const logger = createLogger('sequencer-client:l1_to_l2_messaging');
+  const inbox = getContract({
+    address: ctx.l1ContractAddresses.inboxAddress.toString(),
+    abi: InboxAbi,
+    client: ctx.l1Client,
+  });
+
+  const { recipient, content, secretHash } = message;
+
+  const version = await new RollupContract(ctx.l1Client, ctx.l1ContractAddresses.rollupAddress.toString()).getVersion();
+
+  // We inject the message to Inbox
+  const txHash = await inbox.write.sendL2Message(
+    [{ actor: recipient.toString(), version: BigInt(version) }, content.toString(), secretHash.toString()],
+    {
+      gas: 1_000_000n,
+    },
+  );
+  logger.info(`L1 to L2 message sent in tx ${txHash}`);
+
+  // We check that the message was correctly injected by checking the emitted event
+  const txReceipt = await ctx.l1Client.waitForTransactionReceipt({ hash: txHash });
+
+  if (txReceipt.status !== 'success') {
+    throw new Error(`L1 to L2 message failed to be sent in tx ${txHash}. Status: ${txReceipt.status}`);
+  }
+
+  logger.info(`L1 to L2 message receipt retrieved for tx ${txReceipt.transactionHash}`, txReceipt);
+
+  if (txReceipt.transactionHash !== txHash) {
+    throw new Error(`Receipt transaction hash mismatch: ${txReceipt.transactionHash} !== ${txHash}`);
+  }
+
+  // Filter for MessageSent events from the Inbox contract by trying to decode each log
+  const messageSentLogs = txReceipt.logs
+    .filter(log => log.address.toLowerCase() === ctx.l1ContractAddresses.inboxAddress.toString().toLowerCase())
+    .map(log => {
+      try {
+        const decoded = decodeEventLog({
+          abi: InboxAbi,
+          data: log.data,
+          topics: log.topics,
+        });
+        return { log, decoded };
+      } catch {
+        return null; // Not a decodable event from this ABI
+      }
+    })
+    .filter((item): item is { log: any; decoded: any } => item !== null && item.decoded.eventName === 'MessageSent');
+
+  if (messageSentLogs.length !== 1) {
+    throw new Error(
+      `Wrong number of MessageSent logs found in ${txHash} transaction (got ${messageSentLogs.length} expected 1)\n${tryJsonStringify(messageSentLogs.map(item => item.log))}`,
+    );
+  }
+
+  // We already have the decoded event
+  const topics = messageSentLogs[0].decoded;
+  const receivedMsgHash = topics.args.hash;
+  const receivedGlobalLeafIndex = topics.args.index;
+
+  return { msgHash: Fr.fromHexString(receivedMsgHash), globalLeafIndex: new Fr(receivedGlobalLeafIndex), txReceipt };
+}

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -1,7 +1,9 @@
+import type { Branded } from '@aztec/foundation/branded-types';
+
 import type { Hex } from 'viem';
 
 /** URI pointing to a stored failed L1 transaction. */
-export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+export type FailedL1TxUri = Branded<string, 'FailedL1TxUri'>;
 
 /** A failed L1 transaction captured for debugging and replay. */
 export type FailedL1Tx = {

package/src/publisher/sequencer-bundle-simulator.ts

@@ -0,0 +1,254 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { Multicall3, type RollupContract, buildSimulationOverridesStateOverride } from '@aztec/ethereum/contracts';
+import { type L1TxUtils, MAX_L1_TX_LIMIT } from '@aztec/ethereum/l1-tx-utils';
+import { formatViemError } from '@aztec/ethereum/utils';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { getLastL1SlotTimestampForL2Slot } from '@aztec/stdlib/epoch-helpers';
+
+import type { Hex, StateOverride } from 'viem';
+
+import type { RequestWithExpiry } from './sequencer-publisher.js';
+
+/** A request that was dropped by bundle simulation, with the decoded revert reason. */
+export type DroppedRequest = {
+  request: RequestWithExpiry;
+  revertReason: string | undefined;
+  returnData: Hex | undefined;
+};
+
+/**
+ * Result of {@link SequencerBundleSimulator.simulate}.
+ *
+ * - `success`: simulation succeeded. `requests` is the filtered survivor list, `gasLimit` is
+ *   the bumped gas limit derived from `gasUsed` (plus blob evaluation gas). `droppedRequests`
+ *   lists the entries that were observed to revert in simulation.
+ * - `fallback`: the node does not support eth_simulateV1 (or the simulate call threw). The
+ *   caller should send `requests` as-is with a safe gas limit (e.g. {@link MAX_L1_TX_LIMIT}).
+ *   `droppedRequests` carries any entries that the first pass already proved reverted, so the
+ *   caller does not re-include them when the second pass falls back.
+ * - `aborted`: the bundle cannot be sent. `droppedRequests` contains only entries that were
+ *   actually observed to revert (so they can be reported as simulation failures); it is empty
+ *   when the abort was caused by an empty input bundle.
+ */
+export type BundleSimulateResult =
+  | { kind: 'success'; requests: RequestWithExpiry[]; gasLimit: bigint; droppedRequests: DroppedRequest[] }
+  | { kind: 'fallback'; requests: RequestWithExpiry[]; droppedRequests: DroppedRequest[] }
+  | { kind: 'aborted'; reason: AbortReason; droppedRequests: DroppedRequest[] };
+
+export type AbortReason = 'empty-bundle' | 'all-reverted' | 'second-pass-reverts';
+
+type SimulatePassResult =
+  | { kind: 'decoded'; survivors: RequestWithExpiry[]; droppedRequests: DroppedRequest[]; gasUsed: bigint }
+  | { kind: 'fallback' };
+
+/**
+ * Bundle-level simulator for the aggregate3 payload that `SequencerPublisher` is about to send.
+ *
+ * Runs `eth_simulateV1` against `Multicall3.aggregate3`, drops entries that revert, and returns
+ * a gasLimit for the survivors. When `eth_simulateV1` is unavailable, signals fallback to the
+ * caller so it can send the bundle as-is with a conservative gas limit.
+ */
+export class SequencerBundleSimulator {
+  private readonly log: Logger;
+
+  constructor(
+    private readonly deps: {
+      getL1TxUtils: () => L1TxUtils;
+      rollupContract: RollupContract;
+      epochCache: EpochCache;
+      log?: Logger;
+    },
+  ) {
+    this.log = deps.log ?? createLogger('sequencer:publisher:bundle-simulator');
+  }
+
+  /**
+   * Simulates the given bundle near the end of the target slot and filters out entries
+   * that revert.
+   *
+   * - If all entries pass on the first pass, returns `success` with the gasLimit.
+   * - If some entries revert, re-simulates the survivors. If the second pass is clean, returns
+   *   `success` with the survivors and dropped entries. If the second pass surfaces any revert,
+   *   returns `aborted` — we refuse to send a bundle whose composition still has internal
+   *   reverts after one round of filtering.
+   * - If eth_simulateV1 is unavailable, returns `fallback`. The caller is expected to send the
+   *   bundle as-is with a safe gas limit.
+   *
+   * The simulation `block.timestamp` is the last L1 slot timestamp inside the target L2 slot.
+   * This still maps to the target L2 slot for propose's `validateHeader` and EIP-712 signature
+   * checks, while avoiding eth_simulateV1 rejecting a child block whose timestamp is not strictly
+   * greater than the current L1 head.
+   *
+   * Known limitation: on networks where L1 is mining behind cadence (missed L1 slots, anvil with
+   * overridden timestamps), the actual `block.timestamp` at send time can land in the prior L2
+   * slot. In that case `propose` would revert silently inside the multicall. The simulator does
+   * not detect this case because it simulates inside the target slot — the prior implementation
+   * used `min(predictedNextL1Ts, targetTimestamp)` to surface this failure mode at simulate time.
+   */
+  public async simulate(validRequests: RequestWithExpiry[], targetSlot: SlotNumber): Promise<BundleSimulateResult> {
+    if (validRequests.length === 0) {
+      return { kind: 'aborted', reason: 'empty-bundle', droppedRequests: [] };
+    }
+    // Pin the publisher we'll use across the whole simulate call so that the publisher's rotation
+    // can't change l1TxUtils mid-flight.
+    const l1TxUtils = this.deps.getL1TxUtils();
+
+    const proposeRequest = validRequests.find(r => r.action === 'propose');
+    const simulateTimestamp = getLastL1SlotTimestampForL2Slot(targetSlot, this.deps.epochCache.getL1Constants());
+    const firstPassOverrides = await this.buildStateOverrides(!!proposeRequest);
+
+    const firstPass = await this.simulateAndDecode(l1TxUtils, validRequests, simulateTimestamp, firstPassOverrides);
+
+    if (firstPass.kind === 'fallback') {
+      this.log.warn('Bundle simulate fallback (eth_simulateV1 unavailable); caller will send bundle as-is', {
+        actions: validRequests.map(r => r.action),
+      });
+      return { kind: 'fallback', requests: validRequests, droppedRequests: [] };
+    }
+
+    if (firstPass.survivors.length === 0) {
+      this.log.warn('All bundle entries dropped in simulation; aborting send', {
+        actions: validRequests.map(r => r.action),
+      });
+      return { kind: 'aborted', reason: 'all-reverted', droppedRequests: firstPass.droppedRequests };
+    }
+
+    if (firstPass.droppedRequests.length === 0) {
+      return this.buildSuccessResult(l1TxUtils, firstPass.survivors, [], firstPass.gasUsed, proposeRequest);
+    }
+
+    this.log.warn('Some bundle entries reverted; re-simulating reduced bundle', {
+      droppedActions: firstPass.droppedRequests.map(d => d.request.action),
+      remainingActions: firstPass.survivors.map(r => r.action),
+    });
+
+    // Rebuild overrides for the reduced bundle: if propose was dropped, we no longer need the blob-check override
+    const proposeSurvived = proposeRequest !== undefined && firstPass.survivors.includes(proposeRequest);
+    const secondPassOverrides = proposeSurvived ? firstPassOverrides : await this.buildStateOverrides(false);
+    const secondPass = await this.simulateAndDecode(
+      l1TxUtils,
+      firstPass.survivors,
+      simulateTimestamp,
+      secondPassOverrides,
+    );
+
+    if (secondPass.kind === 'fallback') {
+      this.log.warn(
+        'Bundle simulate errored on second pass (eth_simulateV1 unavailable); sending first-pass survivors as-is',
+        {
+          actions: firstPass.survivors.map(r => r.action),
+          droppedActions: firstPass.droppedRequests.map(d => d.request.action),
+        },
+      );
+      return { kind: 'fallback', requests: firstPass.survivors, droppedRequests: firstPass.droppedRequests };
+    }
+
+    // We refuse to chase reverts through repeated trimming: anything other than a clean second pass aborts the whole send
+    if (secondPass.droppedRequests.length > 0) {
+      this.log.error('Re-simulate surfaced reverts; aborting send', {
+        secondPassDroppedActions: secondPass.droppedRequests.map(d => d.request.action),
+      });
+      return {
+        kind: 'aborted',
+        reason: 'second-pass-reverts',
+        droppedRequests: [...firstPass.droppedRequests, ...secondPass.droppedRequests],
+      };
+    }
+
+    return this.buildSuccessResult(
+      l1TxUtils,
+      secondPass.survivors,
+      firstPass.droppedRequests,
+      secondPass.gasUsed,
+      proposeRequest,
+    );
+  }
+
+  private buildSuccessResult(
+    l1TxUtils: L1TxUtils,
+    survivors: RequestWithExpiry[],
+    droppedRequests: DroppedRequest[],
+    bundleGasUsed: bigint,
+    proposeRequest: RequestWithExpiry | undefined,
+  ): BundleSimulateResult {
+    const proposeSurvived = proposeRequest !== undefined && survivors.includes(proposeRequest);
+    const blobEvaluationGas = proposeSurvived ? (proposeRequest?.blobEvaluationGas ?? 0n) : 0n;
+    const gasLimit = this.computeGasLimit(l1TxUtils, bundleGasUsed, blobEvaluationGas);
+    this.log.debug('Bundle simulate complete', {
+      survivingRequests: survivors.length,
+      bundleGasUsed,
+      gasLimit,
+      actions: survivors.map(r => r.action),
+    });
+    return { kind: 'success', requests: survivors, gasLimit, droppedRequests };
+  }
+
+  /**
+   * `gasLimit = bumpGasLimit(ceil(gasUsed * 64 / 63))`, plus blob evaluation gas if a propose
+   * survived, capped at the L1 block gas limit.
+   */
+  private computeGasLimit(l1TxUtils: L1TxUtils, bundleGasUsed: bigint, blobEvaluationGas: bigint): bigint {
+    const gasUsedWithEip150 = (bundleGasUsed * 64n + 62n) / 63n;
+    const gasLimit = l1TxUtils.bumpGasLimit(gasUsedWithEip150) + blobEvaluationGas;
+    return gasLimit > MAX_L1_TX_LIMIT ? MAX_L1_TX_LIMIT : gasLimit;
+  }
+
+  /**
+   * eth_simulateV1 cannot carry blob sidecar data, so disable the rollup's on-chain blob check
+   * when a propose is in the bundle.
+   */
+  private buildStateOverrides(hasProposeAction: boolean): Promise<StateOverride> {
+    return buildSimulationOverridesStateOverride(
+      this.deps.rollupContract,
+      hasProposeAction ? { disableBlobCheck: true } : undefined,
+    );
+  }
+
+  private async simulateAndDecode(
+    l1TxUtils: L1TxUtils,
+    requests: RequestWithExpiry[],
+    simulateTimestamp: bigint,
+    stateOverrides: StateOverride,
+  ): Promise<SimulatePassResult> {
+    let simResult: Awaited<ReturnType<typeof Multicall3.simulateAggregate3>>;
+    try {
+      simResult = await Multicall3.simulateAggregate3(
+        requests.map(r => ({ to: r.request.to! as Hex, data: r.request.data! as Hex, abi: r.request.abi })),
+        l1TxUtils,
+        {
+          blockOverrides: { time: simulateTimestamp, gasLimit: MAX_L1_TX_LIMIT * 2n },
+          stateOverrides,
+          gas: MAX_L1_TX_LIMIT,
+          fallbackGasEstimate: MAX_L1_TX_LIMIT,
+        },
+      );
+    } catch (err) {
+      this.log.warn('Bundle simulate threw; treating as fallback', {
+        err: formatViemError(err),
+        actions: requests.map(r => r.action),
+      });
+      return { kind: 'fallback' };
+    }
+
+    if (simResult.kind === 'fallback') {
+      return { kind: 'fallback' };
+    }
+
+    const survivors: RequestWithExpiry[] = [];
+    const droppedRequests: DroppedRequest[] = [];
+    for (let i = 0; i < requests.length; i++) {
+      const entry = simResult.entries[i];
+      if (entry.success) {
+        survivors.push(requests[i]);
+        continue;
+      }
+      droppedRequests.push({
+        request: requests[i],
+        revertReason: entry.revertReason,
+        returnData: entry.returnData,
+      });
+    }
+    return { kind: 'decoded', survivors, droppedRequests, gasUsed: simResult.gasUsed };
+  }
+}

package/src/publisher/sequencer-publisher-factory.ts

@@ -7,7 +7,6 @@ import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherFilter, PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 import { NodeKeystoreAdapter } from '@aztec/validator-client';
 
@@ -40,7 +39,6 @@ export class SequencerPublisherFactory {
       epochCache: EpochCache;
       rollupContract: RollupContract;
       governanceProposerContract: GovernanceProposerContract;
-      slashFactoryContract: SlashFactoryContract;
       nodeKeyStore: NodeKeystoreAdapter;
       logger?: Logger;
     },
@@ -104,7 +102,6 @@ export class SequencerPublisherFactory {
       epochCache: this.deps.epochCache,
       governanceProposerContract: this.deps.governanceProposerContract,
       slashingProposerContract,
-      slashFactoryContract: this.deps.slashFactoryContract,
       dateProvider: this.deps.dateProvider,
       metrics: this.publisherMetrics,
       lastActions: this.lastActions,