@aztec/sequencer-client 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/publisher/sequencer-publisher.js

@@ -370,41 +370,53 @@ function applyDecs2203RFactory() {
 function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec, _dec1, _dec2, _initProto;
+var _dec, _dec1, _initProto;
 import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
-import { MULTI_CALL_3_ADDRESS, Multicall3, RollupContract } from '@aztec/ethereum/contracts';
-import { L1FeeAnalyzer } from '@aztec/ethereum/l1-fee-analysis';
-import { WEI_CONST } from '@aztec/ethereum/l1-tx-utils';
-import { FormattedViemError, formatViemError, tryExtractEvent } from '@aztec/ethereum/utils';
-import { sumBigint } from '@aztec/foundation/bigint';
-import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
+import { FeeAssetPriceOracle, MULTI_CALL_3_ADDRESS, Multicall3, MulticallForwarderRevertedError, buildSimulationOverridesStateOverride } from '@aztec/ethereum/contracts';
+import { L1FeeAnalyzer, captureWindowBlockFees } from '@aztec/ethereum/l1-fee-analysis';
+import { L1TxTimeoutError, MAX_L1_TX_LIMIT, WEI_CONST } from '@aztec/ethereum/l1-tx-utils';
+import { FormattedViemError, formatViemError, mergeAbis, tryDecodeRevertReason, tryExtractEvent } from '@aztec/ethereum/utils';
 import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { trimmedBytesLength } from '@aztec/foundation/buffer';
 import { pick } from '@aztec/foundation/collection';
+import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { createLogger } from '@aztec/foundation/log';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { bufferToHex } from '@aztec/foundation/string';
 import { Timer } from '@aztec/foundation/timer';
-import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { EmpireBaseAbi, ErrorsAbi, RollupAbi, SlashingProposerAbi } from '@aztec/l1-artifacts';
 import { encodeSlashConsensusVotes } from '@aztec/slasher';
 import { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getLastL1SlotTimestampForL2Slot, getNextL1SlotTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { encodeFunctionData, toHex } from 'viem';
+import { encodeFunctionData, keccak256, toHex } from 'viem';
+import { createL1TxFailedStore } from './l1_tx_failed_store/index.js';
+import { SequencerBundleSimulator } from './sequencer-bundle-simulator.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+/**
+ * Returns true if the receipt indicates a successful send AND the expected event was emitted
+ * by the target contract. Both pieces are required: an aggregate3 entry that reverted will
+ * have receipt.status === 'success' but no event log.
+ */ function extractEventSuccess(receipt, opts) {
+    if (!receipt || receipt.status !== 'success') {
+        return false;
+    }
+    return !!tryExtractEvent(receipt.logs, opts.address.toString(), opts.abi, opts.eventName);
+}
 export const Actions = [
     'invalidate-by-invalid-attestation',
     'invalidate-by-insufficient-attestations',
+    'prune',
     'propose',
     'governance-signal',
-    'empire-slashing-signal',
-    'create-empire-payload',
-    'execute-empire-payload',
     'vote-offenses',
     'execute-slash'
 ];
 // Sorting for actions such that invalidations go before proposals, and proposals go before votes
 export const compareActions = (a, b)=>Actions.indexOf(a) - Actions.indexOf(b);
-_dec = trackSpan('SequencerPublisher.sendRequests'), _dec1 = trackSpan('SequencerPublisher.validateBlockHeader'), _dec2 = trackSpan('SequencerPublisher.validateCheckpointForSubmission');
+_dec = trackSpan('SequencerPublisher.sendRequests'), _dec1 = trackSpan('SequencerPublisher.validateBlockHeader');
 export class SequencerPublisher {
     config;
     static{
@@ -418,58 +430,64 @@ export class SequencerPublisher {
                 _dec1,
                 2,
                 "validateBlockHeader"
-            ],
-            [
-                _dec2,
-                2,
-                "validateCheckpointForSubmission"
             ]
         ], []));
     }
     interrupted;
     metrics;
+    bundleSimulator;
     epochCache;
-    governanceLog;
-    slashingLog;
+    failedTxStore;
+    /**
+   * ABI used to decode raw revert payloads from dropped bundle entries when the original
+   * request did not carry an abi (e.g. the propose request). Merges every contract the
+   * publisher can route to so any of their custom errors decode against it.
+   */ revertDecoderAbi;
     lastActions;
-    isPayloadEmptyCache;
     log;
     ethereumSlotDuration;
+    aztecSlotDuration;
+    previousL1BlockWaitTimeoutMs;
+    previousL1BlockWaitPollIntervalMs;
+    /** Date provider for wall-clock time. */ dateProvider;
     blobClient;
-    /** Address to use for simulations in fisherman mode (actual proposer's address) */ proposerAddressForSimulation;
+    /** Optional callback to obtain a replacement publisher when the current one fails to send. */ getNextPublisher;
     /** L1 fee analyzer for fisherman mode */ l1FeeAnalyzer;
-    // @note - with blobs, the below estimate seems too large.
-    // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
-    // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
-    static PROPOSE_GAS_GUESS = 12_000_000n;
-    // A CALL to a cold address is 2700 gas
-    static MULTICALL_OVERHEAD_GAS_GUESS = 5000n;
-    // Gas report for VotingWithSigTest shows a max gas of 100k, but we've seen it cost 700k+ in testnet
-    static VOTE_GAS_GUESS = 800_000n;
+    /** Fee asset price oracle for computing price modifiers from Uniswap V4 */ feeAssetPriceOracle;
+    /** Interruptible sleep used by sendRequestsAt to wait until a target timestamp. */ interruptibleSleep;
     l1TxUtils;
     rollupContract;
     govProposerContract;
     slashingProposerContract;
-    slashFactoryContract;
     tracer;
     requests;
     constructor(config, deps){
         this.config = config;
         this.interrupted = (_initProto(this), false);
-        this.governanceLog = createLogger('sequencer:publisher:governance');
-        this.slashingLog = createLogger('sequencer:publisher:slashing');
+        this.revertDecoderAbi = mergeAbis([
+            RollupAbi,
+            SlashingProposerAbi,
+            EmpireBaseAbi,
+            ErrorsAbi
+        ]);
         this.lastActions = {};
-        this.isPayloadEmptyCache = new Map();
+        this.interruptibleSleep = new InterruptibleSleep();
         this.requests = [];
         this.log = deps.log ?? createLogger('sequencer:publisher');
         this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+        this.aztecSlotDuration = BigInt(config.aztecSlotDuration);
+        this.previousL1BlockWaitTimeoutMs = config.sequencerPublisherPreviousL1BlockWaitTimeoutMs;
+        this.previousL1BlockWaitPollIntervalMs = config.sequencerPublisherPreviousL1BlockWaitPollIntervalMs;
+        this.dateProvider = deps.dateProvider;
         this.epochCache = deps.epochCache;
         this.lastActions = deps.lastActions;
         this.blobClient = deps.blobClient;
+        this.dateProvider = deps.dateProvider;
         const telemetry = deps.telemetry ?? getTelemetryClient();
         this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
         this.tracer = telemetry.getTracer('SequencerPublisher');
         this.l1TxUtils = deps.l1TxUtils;
+        this.getNextPublisher = deps.getNextPublisher;
         this.rollupContract = deps.rollupContract;
         this.govProposerContract = deps.governanceProposerContract;
         this.slashingProposerContract = deps.slashingProposerContract;
@@ -478,15 +496,117 @@ export class SequencerPublisher {
             const newSlashingProposer = await this.rollupContract.getSlashingProposer();
             this.slashingProposerContract = newSlashingProposer;
         });
-        this.slashFactoryContract = deps.slashFactoryContract;
         // Initialize L1 fee analyzer for fisherman mode
         if (config.fishermanMode) {
-            this.l1FeeAnalyzer = new L1FeeAnalyzer(this.l1TxUtils.client, deps.dateProvider, createLogger('sequencer:publisher:fee-analyzer'));
+            this.l1FeeAnalyzer = new L1FeeAnalyzer(this.l1TxUtils.client, deps.dateProvider, this.log.createChild('fee-analyzer'));
+        }
+        // Initialize fee asset price oracle
+        this.feeAssetPriceOracle = new FeeAssetPriceOracle(this.l1TxUtils.client, this.rollupContract, this.log.createChild('price-oracle'));
+        // Initialize failed L1 tx store (optional, for test networks)
+        this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
+        this.bundleSimulator = new SequencerBundleSimulator({
+            getL1TxUtils: ()=>this.l1TxUtils,
+            rollupContract: this.rollupContract,
+            epochCache: this.epochCache,
+            log: this.log.createChild('bundle-simulator')
+        });
+    }
+    /**
+   * Logs the gas-pricing data of a failed L1 transaction at warn — so underpricing is diagnosable
+   * from logs even with no failed-tx store configured — and backs the record up to the store when
+   * one is. When captureFeeSummary is true, also records the fee data of the already-mined L1
+   * blocks in the target slot's inclusion window.
+   */ backupFailedTx(failedTx, opts) {
+        const tx = {
+            ...failedTx,
+            timestamp: Date.now()
+        };
+        // Fire and forget - don't block on backup
+        void (async ()=>{
+            try {
+                // Prefer a pre-captured summary (shared across a batch of failures in the same slot) so we
+                // don't re-read the fee window per record. A capture error must not lose the record itself.
+                const feeSummary = opts?.sharedFeeSummary ?? (opts?.captureFeeSummary ? await this.captureFeeEnvironment(opts.targetSlot).catch(()=>undefined) : undefined);
+                if (feeSummary) {
+                    tx.gasInfo = {
+                        ...tx.gasInfo,
+                        ...feeSummary
+                    };
+                }
+                if (tx.gasInfo) {
+                    this.log.warn(`Gas pricing data for failed L1 tx (${tx.failureType})`, {
+                        failureType: tx.failureType,
+                        actions: tx.context.actions,
+                        slot: tx.context.slot,
+                        ...tx.gasInfo,
+                        ...tx.timing
+                    });
+                }
+                const store = await this.failedTxStore;
+                if (store) {
+                    await store.saveFailedTx(tx);
+                }
+            } catch (err) {
+                this.log.warn(`Failed to backup failed L1 tx to store`, err);
+            }
+        })();
+    }
+    /**
+   * Captures per-block fee data for the L1 blocks in the target slot's inclusion window (the blocks the
+   * tx could have landed in) for underpricing diagnostics. Reads only already-mined blocks, so it never
+   * waits on the chain. Safe to call off the critical path: the underlying capture never throws, and this
+   * returns undefined when there is no target slot or the window is not yet mined (e.g. an early send
+   * failure), in which case the record simply carries no window data.
+   */ async captureFeeEnvironment(targetL2Slot) {
+        if (targetL2Slot === undefined) {
+            return undefined;
+        }
+        const l1Constants = this.epochCache.getL1Constants();
+        // The inclusion window is [start of slot N, start of slot N+1): all L1 blocks that can include a tx
+        // for this L2 slot. getTimestampForSlot returns seconds, matching block.timestamp.
+        const windowStartS = getTimestampForSlot(targetL2Slot, l1Constants);
+        const windowEndS = getTimestampForSlot(SlotNumber(Number(targetL2Slot) + 1), l1Constants);
+        const windowBlocks = await captureWindowBlockFees(this.l1TxUtils.client, windowStartS, windowEndS);
+        if (windowBlocks.length === 0) {
+            return undefined;
         }
+        return {
+            windowBlocks
+        };
+    }
+    /** Computes timing info relative to the L2 slot deadline. */ computeTimingInfo(targetL2Slot) {
+        if (targetL2Slot === undefined) {
+            return undefined;
+        }
+        const l1Constants = this.epochCache.getL1Constants();
+        const slotDeadlineS = getTimestampForSlot(SlotNumber(Number(targetL2Slot) + 1), l1Constants);
+        const slotDeadlineMs = Number(slotDeadlineS) * 1000;
+        return {
+            targetL2Slot: Number(targetL2Slot),
+            slotDeadlineTimestampS: slotDeadlineS,
+            msUntilSlotDeadline: slotDeadlineMs - this.dateProvider.now()
+        };
+    }
+    /**
+   * Builds an id for a synthetic failure record (send-error/timeout) that has no on-chain tx hash.
+   * Includes the failure time so each attempt — including retries of the same slot — is stored as its
+   * own record rather than overwriting the previous one.
+   */ failureRecordId(actions, targetSlot) {
+        return keccak256(toHex(`${actions.join(',')}:${targetSlot ?? ''}:${Date.now()}`));
     }
     getRollupContract() {
         return this.rollupContract;
     }
+    /**
+   * Gets the fee asset price modifier from the oracle.
+   *
+   * @param predictedParentEthPerFeeAssetE12 - Optional predicted parent eth-per-fee-asset (E12).
+   *   Pipelined proposers should pass the value from the predicted parent fee header so the
+   *   modifier matches the parent L1 will use when applying it.
+   * @returns The fee asset price modifier in basis points, or 0n if the oracle query fails.
+   */ getFeeAssetPriceModifier(predictedParentEthPerFeeAssetE12) {
+        return this.feeAssetPriceOracle.computePriceModifier(predictedParentEthPerFeeAssetE12);
+    }
     getSenderAddress() {
         return this.l1TxUtils.getSenderAddress();
     }
@@ -495,17 +615,11 @@ export class SequencerPublisher {
    */ getL1FeeAnalyzer() {
         return this.l1FeeAnalyzer;
     }
-    /**
-   * Sets the proposer address to use for simulations in fisherman mode.
-   * @param proposerAddress - The actual proposer's address to use for balance lookups in simulations
-   */ setProposerAddressForSimulation(proposerAddress) {
-        this.proposerAddressForSimulation = proposerAddress;
-    }
     addRequest(request) {
         this.requests.push(request);
     }
     getCurrentL2Slot() {
-        return this.epochCache.getEpochAndSlotNow().slot;
+        return this.epochCache.getSlotNow();
     }
     /**
    * Clears all pending requests without sending them.
@@ -544,7 +658,7 @@ export class SequencerPublisher {
         // Get the transaction requests
         const l1Requests = requestsToAnalyze.map((r)=>r.request);
         // Start the analysis
-        const analysisId = await this.l1FeeAnalyzer.startAnalysis(l2SlotNumber, gasLimit > 0n ? gasLimit : SequencerPublisher.PROPOSE_GAS_GUESS, l1Requests, blobConfig, onComplete);
+        const analysisId = await this.l1FeeAnalyzer.startAnalysis(l2SlotNumber, gasLimit > 0n ? gasLimit : MAX_L1_TX_LIMIT, l1Requests, blobConfig, onComplete);
         this.log.info('Started L1 fee analysis', {
             analysisId,
             l2SlotNumber: l2SlotNumber.toString(),
@@ -558,11 +672,15 @@ export class SequencerPublisher {
     }
     /**
    * Sends all requests that are still valid.
+   * @param targetSlot - The target L2 slot for this send. When provided (the production path, via
+   *   sendRequestsAt), it is threaded into bundleSimulate so the block.timestamp override matches
+   *   the slot the propose is built for. When omitted, falls back to getCurrentL2Slot() for the
+   *   AutomineSequencer, which publishes synchronously within the current slot.
    * @returns one of:
    * - A receipt and stats if the tx succeeded
    * - a receipt and errorMsg if it failed on L1
    * - undefined if no valid requests are found OR the tx failed to send.
-   */ async sendRequests() {
+   */ async sendRequests(targetSlot) {
         const requestsToProcess = [
             ...this.requests
         ];
@@ -570,10 +688,9 @@ export class SequencerPublisher {
         if (this.interrupted || requestsToProcess.length === 0) {
             return undefined;
         }
-        const currentL2Slot = this.getCurrentL2Slot();
+        const currentL2Slot = targetSlot ?? this.getCurrentL2Slot();
         this.log.debug(`Sending requests on L2 slot ${currentL2Slot}`);
         const validRequests = requestsToProcess.filter((request)=>request.lastValidL2Slot >= currentL2Slot);
-        const validActions = validRequests.map((x)=>x.action);
         const expiredActions = requestsToProcess.filter((request)=>request.lastValidL2Slot < currentL2Slot).map((x)=>x.action);
         if (validRequests.length !== requestsToProcess.length) {
             this.log.warn(`Some requests were expired for slot ${currentL2Slot}`, {
@@ -591,44 +708,98 @@ export class SequencerPublisher {
             this.log.debug(`No valid requests to send`);
             return undefined;
         }
-        // @note - we can only have one blob config per bundle
-        // find requests with gas and blob configs
-        // See https://github.com/AztecProtocol/aztec-packages/issues/11513
-        const gasConfigs = requestsToProcess.filter((request)=>request.gasConfig).map((request)=>request.gasConfig);
-        const blobConfigs = requestsToProcess.filter((request)=>request.blobConfig).map((request)=>request.blobConfig);
-        if (blobConfigs.length > 1) {
-            throw new Error('Multiple blob configs found');
-        }
-        const blobConfig = blobConfigs[0];
-        // Merge gasConfigs. Yields the sum of gasLimits, and the earliest txTimeoutAt, or undefined if no gasConfig sets them.
-        const gasLimits = gasConfigs.map((g)=>g?.gasLimit).filter((g)=>g !== undefined);
-        const gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
+        // Collect earliest txTimeoutAt across all requests.
+        const gasConfigs = validRequests.filter((request)=>request.gasConfig).map((request)=>request.gasConfig);
         const txTimeoutAts = gasConfigs.map((g)=>g?.txTimeoutAt).filter((g)=>g !== undefined);
-        const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map((g)=>g.getTime()))) : undefined; // earliest
-        const txConfig = {
-            gasLimit,
-            txTimeoutAt
-        };
+        const txTimeoutAt = txTimeoutAts.length > 0 ? new Date(Math.min(...txTimeoutAts.map((g)=>g.getTime()))) : undefined;
         // Sort the requests so that proposals always go first
         // This ensures the committee gets precomputed correctly
         validRequests.sort((a, b)=>compareActions(a.action, b.action));
         try {
+            // Bundle-level eth_simulateV1: filters out entries that revert and derives the gasLimit.
+            const bundleResult = await this.bundleSimulator.simulate(validRequests, currentL2Slot);
+            if (bundleResult.kind === 'aborted') {
+                this.logDroppedInSim(bundleResult.droppedRequests);
+                void this.backupDroppedInSim(bundleResult.droppedRequests, currentL2Slot).catch((err)=>this.log.error(`Failed to backup requests dropped in simulation`, err));
+                return undefined;
+            }
+            const { requests, droppedRequests, gasLimit } = bundleResult.kind === 'fallback' ? {
+                requests: bundleResult.requests,
+                droppedRequests: bundleResult.droppedRequests,
+                gasLimit: MAX_L1_TX_LIMIT
+            } : bundleResult;
+            this.logDroppedInSim(droppedRequests);
+            // Compute blobConfig from survivors (not original validRequests) so that if the propose
+            // entry was dropped by bundleSimulate we don't attach a blob-typed config to a non-blob tx.
+            const [blobConfig] = requests.filter((r)=>r.blobConfig).map((r)=>r.blobConfig);
+            const txConfig = {
+                gasLimit,
+                txTimeoutAt
+            };
             this.log.debug('Forwarding transactions', {
-                validRequests: validRequests.map((request)=>request.action),
+                requests: requests.map((request)=>request.action),
                 txConfig
             });
-            const result = await Multicall3.forward(validRequests.map((request)=>request.request), this.l1TxUtils, txConfig, blobConfig, this.rollupContract.address, this.log);
-            const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result);
+            const result = await this.forwardWithPublisherRotation(requests, txConfig, blobConfig, currentL2Slot);
+            if (result === undefined) {
+                return undefined;
+            }
+            const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(requests, result);
+            const allFailedActions = [
+                ...failedActions,
+                ...droppedRequests.map((d)=>d.request.action)
+            ];
             return {
                 result,
                 expiredActions,
-                sentActions: validActions,
+                sentActions: requests.map((x)=>x.action),
                 successfulActions,
-                failedActions
+                failedActions: allFailedActions
             };
         } catch (err) {
             const viemError = formatViemError(err);
             this.log.error(`Failed to publish bundled transactions`, viemError);
+            if (err instanceof TimeoutError) {
+                const timeoutState = err instanceof L1TxTimeoutError ? err.txState : undefined;
+                void (async ()=>{
+                    // The RPC is likely degraded right after a timeout, so back up without the block number
+                    // rather than leaking an unhandled rejection.
+                    const l1BlockNumber = await this.l1TxUtils.getBlockNumber().catch(()=>0n);
+                    this.backupFailedTx({
+                        id: this.failureRecordId(validRequests.map((r)=>r.action), currentL2Slot),
+                        failureType: 'timeout',
+                        request: {
+                            to: MULTI_CALL_3_ADDRESS,
+                            data: '0x'
+                        },
+                        l1BlockNumber,
+                        error: {
+                            message: viemError.message,
+                            name: 'TimeoutError'
+                        },
+                        context: {
+                            actions: validRequests.map((r)=>r.action),
+                            requests: validRequests.filter((r)=>r.request.to !== null).map((r)=>({
+                                    action: r.action,
+                                    to: r.request.to,
+                                    data: r.request.data
+                                })),
+                            sender: this.getSenderAddress().toString(),
+                            slot: Number(currentL2Slot)
+                        },
+                        timing: this.computeTimingInfo(currentL2Slot),
+                        gasInfo: timeoutState ? {
+                            sentGasPriceLadder: timeoutState.gasPriceHistory,
+                            attempts: timeoutState.attempts,
+                            gasLimit: timeoutState.gasLimit,
+                            nonce: timeoutState.nonce
+                        } : undefined
+                    }, {
+                        captureFeeSummary: true,
+                        targetSlot: currentL2Slot
+                    });
+                })();
+            }
             return undefined;
         } finally{
             try {
@@ -638,49 +809,302 @@ export class SequencerPublisher {
             }
         }
     }
-    callbackBundledTransactions(requests, result) {
-        const actionsListStr = requests.map((r)=>r.action).join(', ');
-        if (result instanceof FormattedViemError) {
-            this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
-            return {
-                failedActions: requests.map((r)=>r.action)
-            };
-        } else {
-            this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
-                result,
-                requests
+    /** Logs entries dropped by bundle simulation as warnings on the publisher's logger. */ logDroppedInSim(dropped) {
+        for (const drop of dropped){
+            const revertReasonDecoded = drop.revertReason ?? tryDecodeRevertReason(drop.returnData, this.revertDecoderAbi);
+            this.log.warn('Bundle entry dropped: action reverted in sim', {
+                action: drop.request.action,
+                revertReason: revertReasonDecoded ?? drop.returnData,
+                revertReasonDecoded,
+                returnData: drop.returnData
             });
-            const successfulActions = [];
-            const failedActions = [];
-            for (const request of requests){
-                if (request.checkSuccess(request.request, result)) {
-                    successfulActions.push(request.action);
-                } else {
-                    failedActions.push(request.action);
+        }
+    }
+    /** Backs up entries dropped by bundle simulation, one record per dropped action. */ async backupDroppedInSim(dropped, targetSlot) {
+        if (dropped.length === 0) {
+            return;
+        }
+        // Invoked as `void backupDroppedInSim(...)` on the publish path, so it must not throw.
+        try {
+            const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+            // Every dropped entry failed in the same slot against the same L1 fee conditions, so capture
+            // the fee environment once and share it rather than re-reading the window per entry.
+            const sharedFeeSummary = await this.captureFeeEnvironment(targetSlot).catch(()=>undefined);
+            const timing = this.computeTimingInfo(targetSlot);
+            for (const { request: req } of dropped){
+                this.backupFailedTx({
+                    id: keccak256(req.request.data),
+                    failureType: 'simulation',
+                    request: {
+                        to: req.request.to,
+                        data: req.request.data
+                    },
+                    l1BlockNumber,
+                    error: {
+                        message: 'Bundle entry dropped: action reverted in sim'
+                    },
+                    context: {
+                        actions: [
+                            req.action
+                        ],
+                        sender: this.getSenderAddress().toString(),
+                        slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+                    },
+                    timing
+                }, {
+                    sharedFeeSummary
+                });
+            }
+        } catch (err) {
+            this.log.warn(`Failed to back up dropped-in-sim entries`, err);
+        }
+    }
+    /**
+   * Forwards transactions via Multicall3, rotating to the next available publisher if a send
+   * failure occurs (i.e. the tx never reached the chain).
+   * On-chain reverts and simulation errors are returned as-is without rotation.
+   */ async forwardWithPublisherRotation(validRequests, txConfig, blobConfig, targetSlot) {
+        if (!txConfig?.gasLimit) {
+            throw new Error('gasLimit is required for bundled transactions');
+        }
+        const txConfigWithGasLimit = txConfig;
+        const triedAddresses = [];
+        let currentPublisher = this.l1TxUtils;
+        while(true){
+            if (txConfig.txTimeoutAt && new Date() > txConfig.txTimeoutAt) {
+                this.log.warn(`Tx timeout (${txConfig.txTimeoutAt.toISOString()}) elapsed; stopping publisher rotation`, {
+                    triedAddresses: triedAddresses.map((a)=>a.toString())
+                });
+                return undefined;
+            }
+            triedAddresses.push(currentPublisher.getSenderAddress());
+            try {
+                const result = await Multicall3.forward(validRequests.map((r)=>r.request), currentPublisher, txConfigWithGasLimit, blobConfig, {
+                    gasLimitRequired: true
+                });
+                this.l1TxUtils = currentPublisher;
+                return result;
+            } catch (err) {
+                if (err instanceof TimeoutError) {
+                    throw err;
                 }
+                if (err instanceof MulticallForwarderRevertedError) {
+                    this.log.error('Forwarder transaction reverted on-chain; not rotating publisher', err, {
+                        transactionHash: err.receipt.transactionHash
+                    });
+                    this.backupRevertFailure(validRequests, err, currentPublisher, targetSlot);
+                    return undefined;
+                }
+                const viemError = formatViemError(err);
+                if (!this.getNextPublisher) {
+                    this.log.error('Failed to publish bundled transactions', viemError);
+                    this.backupSendFailure(validRequests, viemError, currentPublisher, targetSlot);
+                    return undefined;
+                }
+                this.log.warn(`Publisher ${currentPublisher.getSenderAddress()} failed to send, rotating to next publisher`, viemError);
+                const nextPublisher = await this.getNextPublisher([
+                    ...triedAddresses
+                ]);
+                if (!nextPublisher) {
+                    this.log.error(`All available publishers exhausted (tried ${triedAddresses.length}), failed to publish bundled transactions`, viemError, {
+                        triedAddresses: triedAddresses.map((a)=>a.toString())
+                    });
+                    this.backupSendFailure(validRequests, viemError, currentPublisher, targetSlot);
+                    return undefined;
+                }
+                currentPublisher = nextPublisher;
             }
-            return {
-                successfulActions,
-                failedActions
-            };
         }
     }
+    /** Backs up an on-chain revert failure to the failed tx store. */ backupRevertFailure(requests, err, publisher, targetSlot) {
+        this.backupFailedTx({
+            id: err.receipt.transactionHash,
+            failureType: 'revert',
+            request: {
+                to: MULTI_CALL_3_ADDRESS,
+                data: '0x'
+            },
+            l1BlockNumber: err.receipt.blockNumber,
+            receipt: {
+                transactionHash: err.receipt.transactionHash,
+                blockNumber: err.receipt.blockNumber,
+                gasUsed: err.receipt.gasUsed,
+                status: 'reverted'
+            },
+            error: {
+                message: err.message,
+                name: err.name
+            },
+            context: {
+                actions: requests.map((r)=>r.action),
+                requests: requests.filter((r)=>r.request.to !== null).map((r)=>({
+                        action: r.action,
+                        to: r.request.to,
+                        data: r.request.data
+                    })),
+                sender: publisher.getSenderAddress().toString(),
+                slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+            },
+            gasInfo: err.txState ? {
+                sentGasPrice: err.txState.gasPrice,
+                gasLimit: err.txState.gasLimit,
+                nonce: err.txState.nonce
+            } : undefined,
+            timing: this.computeTimingInfo(targetSlot)
+        }, {
+            captureFeeSummary: true,
+            targetSlot
+        });
+    }
+    /** Backs up a send failure (tx never reached chain) to the failed tx store. */ backupSendFailure(requests, error, publisher, targetSlot) {
+        // If we can't get the block number, still back up without it.
+        void this.l1TxUtils.getBlockNumber().catch(()=>0n).then((l1BlockNumber)=>{
+            this.backupFailedTx({
+                id: this.failureRecordId(requests.map((r)=>r.action), targetSlot),
+                failureType: 'send-error',
+                request: {
+                    to: MULTI_CALL_3_ADDRESS,
+                    data: '0x'
+                },
+                l1BlockNumber,
+                error: {
+                    message: error.message,
+                    name: 'name' in error ? error.name : undefined
+                },
+                context: {
+                    actions: requests.map((r)=>r.action),
+                    requests: requests.filter((r)=>r.request.to !== null).map((r)=>({
+                            action: r.action,
+                            to: r.request.to,
+                            data: r.request.data
+                        })),
+                    sender: publisher.getSenderAddress().toString(),
+                    slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+                },
+                timing: this.computeTimingInfo(targetSlot)
+            }, {
+                captureFeeSummary: true,
+                targetSlot
+            });
+        });
+    }
+    /*
+   * Schedules sending all enqueued requests at (or after) the start of the given L2 slot.
+   */ async sendRequestsAt(targetSlot) {
+        await this.waitForTargetSlot(targetSlot);
+        if (this.interrupted) {
+            return undefined;
+        }
+        return this.sendRequests(targetSlot);
+    }
     /**
-   * @notice  Will call `canProposeAtNextEthBlock` to make sure that it is possible to propose
+   * Sleeps until one L1 slot before the L2 slot boundary, and then waits for that L1 block
+   * to be mined, so we don't risk being included in it. If that block never gets mined after
+   * a timeout, we assume it got skipped on L1, so we send the tx anyway.
+   */ async waitForTargetSlot(targetSlot) {
+        const l1Constants = this.epochCache.getL1Constants();
+        const nowInSeconds = this.dateProvider.nowInSeconds();
+        const startOfTargetSlotTs = getTimestampForSlot(targetSlot, l1Constants);
+        const previousL1BlockTs = startOfTargetSlotTs - this.ethereumSlotDuration;
+        const waitDeadlineTs = previousL1BlockTs + BigInt(this.previousL1BlockWaitTimeoutMs / 1000);
+        const logCtx = {
+            targetSlot,
+            startOfTargetSlotTs,
+            nowInSeconds,
+            previousL1BlockTs,
+            waitDeadlineTs
+        };
+        // Check if we are already past time
+        if (nowInSeconds >= startOfTargetSlotTs) {
+            this.log.verbose(`Target slot ${targetSlot} already started, sending requests immediately`, logCtx);
+            return;
+        }
+        // Otherwise we wait
+        this.log.debug(`Waiting for slot ${targetSlot} before sending requests`, logCtx);
+        // Wait until previous L1 block timestamp first
+        const sleepMs = (Number(previousL1BlockTs) - nowInSeconds) * 1000;
+        if (sleepMs > 0 && !this.interrupted) {
+            this.log.trace(`Sleeping ${sleepMs}ms before waiting for previous L1 block`, logCtx);
+            await this.interruptibleSleep.sleep(sleepMs);
+        }
+        // Then loop until we see the previous L1 block, so we know that we cannot be included in it.
+        // We time out after a while, once we are sure that that block is skipped in L1.
+        while(!this.interrupted){
+            try {
+                const nowInSeconds = this.dateProvider.nowInSeconds();
+                logCtx.nowInSeconds = nowInSeconds;
+                if (nowInSeconds >= waitDeadlineTs) {
+                    this.log.warn(`Timed out waiting for previous L1 block before sending requests, proceeding`, logCtx);
+                    return;
+                }
+                const latestBlockTs = await this.l1TxUtils.getBlock().then((b)=>b.timestamp);
+                if (latestBlockTs >= previousL1BlockTs) {
+                    this.log.debug(`Previous L1 block mined, proceeding to send requests`, {
+                        ...logCtx,
+                        latestBlockTs
+                    });
+                    return;
+                }
+                this.log.trace(`Previous L1 block not mined yet, continuing to wait`, {
+                    ...logCtx,
+                    latestBlockTs
+                });
+            } catch (err) {
+                this.log.error(`Error while waiting for previous L1 block before sending requests; retrying`, err, logCtx);
+            } finally{
+                await this.interruptibleSleep.sleep(this.previousL1BlockWaitPollIntervalMs);
+            }
+        }
+    }
+    callbackBundledTransactions(requests, result) {
+        const actionsListStr = requests.map((r)=>r.action).join(', ');
+        this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
+            result,
+            requests: requests.map((r)=>({
+                    ...r,
+                    // Avoid logging large blob data
+                    blobConfig: r.blobConfig ? {
+                        ...r.blobConfig,
+                        blobs: r.blobConfig.blobs.map((b)=>({
+                                size: trimmedBytesLength(b)
+                            }))
+                    } : undefined
+                }))
+        });
+        const successfulActions = [];
+        const failedActions = [];
+        for (const request of requests){
+            if (request.checkSuccess(request.request, result)) {
+                successfulActions.push(request.action);
+            } else {
+                failedActions.push(request.action);
+            }
+        }
+        return {
+            successfulActions,
+            failedActions
+        };
+    }
+    /**
+   * @notice  Will call `canProposeAt` to make sure that it is possible to propose
    * @param tipArchive - The archive to check
    * @returns The slot and block number if it is possible to propose, undefined otherwise
-   */ canProposeAtNextEthBlock(tipArchive, msgSender, opts = {}) {
+   */ async canProposeAt(tipArchive, msgSender, simulationOverridesPlan) {
         // TODO: #14291 - should loop through multiple keys to check if any of them can propose
-        const ignoredErrors = [
+        // These errors are expected when we cannot actually propose right now — usually because our
+        // local view of the chain is ahead of L1 (proposed parent hasn't landed yet, or someone
+        // else has just landed the slot, or the archive override doesn't match). We log a warn and
+        // skip the proposal; we do NOT treat these as bugs.
+        const expectedErrors = [
             'SlotAlreadyInChain',
             'InvalidProposer',
             'InvalidArchive'
         ];
-        return this.rollupContract.canProposeAtNextEthBlock(tipArchive.toBuffer(), msgSender.toString(), Number(this.ethereumSlotDuration), {
-            forcePendingCheckpointNumber: opts.forcePendingCheckpointNumber
-        }).catch((err)=>{
-            if (err instanceof FormattedViemError && ignoredErrors.find((e)=>err.message.includes(e))) {
-                this.log.warn(`Failed canProposeAtTime check with ${ignoredErrors.find((e)=>err.message.includes(e))}`, {
+        const slotOffset = this.aztecSlotDuration;
+        const nextL1SlotTs = this.getNextL1SlotTimestamp() + slotOffset;
+        return this.rollupContract.canProposeAt(tipArchive.toBuffer(), msgSender.toString(), nextL1SlotTs, await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan)).catch((err)=>{
+            if (err instanceof FormattedViemError && expectedErrors.find((e)=>err.message.includes(e))) {
+                this.log.warn(`Failed canProposeAtTime check with ${expectedErrors.find((e)=>err.message.includes(e))}`, {
                     error: err.message
                 });
             } else {
@@ -694,22 +1118,23 @@ export class SequencerPublisher {
    * @dev     This is a convenience function that can be used by the sequencer to validate a "partial" header.
    *          It will throw if the block header is invalid.
    * @param header - The block header to validate
-   */ async validateBlockHeader(header, opts) {
+   */ async validateBlockHeader(header, simulationOverridesPlan) {
         const flags = {
             ignoreDA: true,
             ignoreSignatures: true
         };
         const args = [
             header.toViem(),
-            CommitteeAttestationsAndSigners.empty().getPackedAttestations(),
+            CommitteeAttestationsAndSigners.packAttestations([]),
             [],
             Signature.empty().toViemSignature(),
             `0x${'0'.repeat(64)}`,
             header.blobsHash.toString(),
             flags
         ];
-        const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-        const stateOverrides = await this.rollupContract.makePendingCheckpointNumberOverride(opts?.forcePendingCheckpointNumber);
+        const l1Constants = this.epochCache.getL1Constants();
+        const ts = getLastL1SlotTimestampForL2Slot(header.slotNumber, l1Constants);
+        const stateOverrides = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
         let balance = 0n;
         if (this.config.fishermanMode) {
             // In fisherman mode, we can't know where the proposer is publishing from
@@ -731,7 +1156,7 @@ export class SequencerPublisher {
             }),
             from: MULTI_CALL_3_ADDRESS
         }, {
-            time: ts + 1n
+            time: ts
         }, stateOverrides);
         this.log.debug(`Simulated validateHeader`);
     }
@@ -761,8 +1186,12 @@ export class SequencerPublisher {
             ...logData,
             request
         });
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
         try {
-            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, ErrorsAbi);
+            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, mergeAbis([
+                request.abi ?? [],
+                ErrorsAbi
+            ]));
             this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} succeeded`, {
                 ...logData,
                 request,
@@ -773,20 +1202,21 @@ export class SequencerPublisher {
                 gasUsed,
                 checkpointNumber,
                 forcePendingCheckpointNumber: CheckpointNumber(checkpointNumber - 1),
+                lastArchive: validationResult.checkpoint.lastArchive,
                 reason
             };
         } catch (err) {
             const viemError = formatViemError(err);
             // If the error is due to the checkpoint not being in the pending chain, and it was indeed removed by someone else,
             // we can safely ignore it and return undefined so we go ahead with checkpoint building.
-            if (viemError.message?.includes('Rollup__BlockNotInPendingChain')) {
+            if (viemError.message?.includes('Rollup__CheckpointNotInPendingChain')) {
                 this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} failed due to checkpoint not being in pending chain`, {
                     ...logData,
                     request,
                     error: viemError.message
                 });
-                const latestPendingCheckpointNumber = await this.rollupContract.getCheckpointNumber();
-                if (latestPendingCheckpointNumber < checkpointNumber) {
+                const latestProposedCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+                if (latestProposedCheckpointNumber < checkpointNumber) {
                     this.log.verbose(`Checkpoint ${checkpointNumber} has already been invalidated`, {
                         ...logData
                     });
@@ -800,6 +1230,31 @@ export class SequencerPublisher {
             }
             // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
             this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
+            this.backupFailedTx({
+                id: keccak256(request.data),
+                failureType: 'simulation',
+                request: {
+                    to: request.to,
+                    data: request.data,
+                    value: request.value
+                },
+                l1BlockNumber,
+                error: {
+                    message: viemError.message,
+                    name: viemError.name
+                },
+                context: {
+                    actions: [
+                        `invalidate-${reason}`
+                    ],
+                    checkpointNumber,
+                    sender: this.getSenderAddress().toString()
+                },
+                timing: this.computeTimingInfo(this.getCurrentL2Slot())
+            }, {
+                captureFeeSummary: true,
+                targetSlot: this.getCurrentL2Slot()
+            });
             throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, {
                 cause: viemError
             });
@@ -815,7 +1270,11 @@ export class SequencerPublisher {
             reason
         };
         this.log.debug(`Building invalidate checkpoint ${checkpoint.checkpointNumber} request`, logData);
-        const attestationsAndSigners = new CommitteeAttestationsAndSigners(validationResult.attestations).getPackedAttestations();
+        // Use the exact packed tuple posted to L1 verbatim. A repack via `packAttestations` is not a
+        // byte-faithful inverse of `fromPacked` (a canonicalized yParity byte or an all-zero signature slot
+        // round-trips differently), so it would diverge from the stored `attestationsHash` and revert the
+        // invalidation.
+        const attestationsAndSigners = validationResult.verbatimAttestations;
         if (reason === 'invalid-attestation') {
             return this.rollupContract.buildInvalidateBadAttestationRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee, validationResult.invalidIndex);
         } else if (reason === 'insufficient-attestations') {
@@ -825,42 +1284,7 @@ export class SequencerPublisher {
             throw new Error(`Unknown reason for invalidation`);
         }
     }
-    /** Simulates `propose` to make sure that the checkpoint is valid for submission */ async validateCheckpointForSubmission(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, options) {
-        const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-        // TODO(palla/mbps): This should not be needed, there's no flow where we propose with zero attestations. Or is there?
-        // If we have no attestations, we still need to provide the empty attestations
-        // so that the committee is recalculated correctly
-        // const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
-        // if (ignoreSignatures) {
-        //   const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
-        //   if (!committee) {
-        //     this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-        //     throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-        //   }
-        //   attestationsAndSigners.attestations = committee.map(committeeMember =>
-        //     CommitteeAttestation.fromAddress(committeeMember),
-        //   );
-        // }
-        const blobFields = checkpoint.toBlobFields();
-        const blobs = getBlobsPerL1Block(blobFields);
-        const blobInput = getPrefixedEthBlobCommitments(blobs);
-        const args = [
-            {
-                header: checkpoint.header.toViem(),
-                archive: toHex(checkpoint.archive.root.toBuffer()),
-                oracleInput: {
-                    feeAssetPriceModifier: 0n
-                }
-            },
-            attestationsAndSigners.getPackedAttestations(),
-            attestationsAndSigners.getSigners().map((signer)=>signer.toString()),
-            attestationsAndSignersSignature.toViemSignature(),
-            blobInput
-        ];
-        await this.simulateProposeTx(args, ts, options);
-        return ts;
-    }
-    async enqueueCastSignalHelper(slotNumber, timestamp, signalType, payload, base, signerAddress, signer) {
+    async enqueueCastSignalHelper(slotNumber, signalType, payload, base, signerAddress, signer) {
         if (this.lastActions[signalType] && this.lastActions[signalType] === slotNumber) {
             this.log.debug(`Skipping duplicate vote cast signal ${signalType} for slot ${slotNumber}`);
             return false;
@@ -880,10 +1304,28 @@ export class SequencerPublisher {
         if (roundInfo.lastSignalSlot >= slotNumber) {
             return false;
         }
-        if (await this.isPayloadEmpty(payload)) {
+        if (await base.isPayloadEmpty(payload)) {
             this.log.warn(`Skipping vote cast for payload with empty code`);
             return false;
         }
+        // Skip signaling if there is already a live (non-terminal) Governance proposal for this
+        // payload. This is intentionally not cached: a previously-live proposal may transition to
+        // a terminal state (Dropped/Rejected/Expired/Executed), at which point we may want to re-signal
+        // the same payload in a future round.
+        let proposed = false;
+        try {
+            proposed = await base.hasActiveProposalWithPayload(payload.toString());
+        } catch (err) {
+            // We deliberately swallow the error and proceed to signal. Failing closed (skipping the
+            // signal) on transient RPC errors would let a flaky L1 endpoint silence governance
+            // participation entirely; failing open at worst produces a duplicate signal that the
+            // contract will simply count alongside others in the round.
+            this.log.error(`Failed to check if payload ${payload} was already proposed (signalling anyway)`, err);
+        }
+        if (proposed) {
+            this.log.info(`Payload ${payload} has a live governance proposal, stopping signals`);
+            return false;
+        }
         const cachedLastVote = this.lastActions[signalType];
         this.lastActions[signalType] = slotNumber;
         const action = signalType;
@@ -894,27 +1336,17 @@ export class SequencerPublisher {
             signer: this.l1TxUtils.client.account?.address,
             lastValidL2Slot: slotNumber
         });
-        try {
-            await this.l1TxUtils.simulate(request, {
-                time: timestamp
-            }, [], ErrorsAbi);
-            this.log.debug(`Simulation for ${action} at slot ${slotNumber} succeeded`, {
-                request
-            });
-        } catch (err) {
-            this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, err);
-        // Yes, we enqueue the request anyway, in case there was a bug with the simulation itself
-        }
         // TODO(palla/slash): All votes (governance and slashing) should txTimeoutAt at the end of the slot.
         this.addRequest({
-            gasConfig: {
-                gasLimit: SequencerPublisher.VOTE_GAS_GUESS
-            },
             action,
             request,
             lastValidL2Slot: slotNumber,
             checkSuccess: (_request, result)=>{
-                const success = result && result.receipt && result.receipt.status === 'success' && tryExtractEvent(result.receipt.logs, base.address.toString(), EmpireBaseAbi, 'SignalCast');
+                const success = result && extractEventSuccess(result.receipt, {
+                    address: base.address.toString(),
+                    abi: EmpireBaseAbi,
+                    eventName: 'SignalCast'
+                });
                 const logData = {
                     ...result,
                     slotNumber,
@@ -933,68 +1365,70 @@ export class SequencerPublisher {
         });
         return true;
     }
-    async isPayloadEmpty(payload) {
-        const key = payload.toString();
-        const cached = this.isPayloadEmptyCache.get(key);
-        if (cached) {
-            return cached;
-        }
-        const isEmpty = !await this.l1TxUtils.getCode(payload);
-        this.isPayloadEmptyCache.set(key, isEmpty);
-        return isEmpty;
-    }
     /**
    * Enqueues a governance castSignal transaction to cast a signal for a given slot number.
    * @param slotNumber - The slot number to cast a signal for.
-   * @param timestamp - The timestamp of the slot to cast a signal for.
    * @returns True if the signal was successfully enqueued, false otherwise.
-   */ enqueueGovernanceCastSignal(governancePayload, slotNumber, timestamp, signerAddress, signer) {
-        return this.enqueueCastSignalHelper(slotNumber, timestamp, 'governance-signal', governancePayload, this.govProposerContract, signerAddress, signer);
+   */ enqueueGovernanceCastSignal(governancePayload, slotNumber, signerAddress, signer) {
+        return this.enqueueCastSignalHelper(slotNumber, 'governance-signal', governancePayload, this.govProposerContract, signerAddress, signer);
     }
-    /** Enqueues all slashing actions as returned by the slasher client. */ async enqueueSlashingActions(actions, slotNumber, timestamp, signerAddress, signer) {
+    /**
+   * Enqueues a `prune()` transaction if the rollup is prunable at the given slot's L1 timestamp.
+   * `prune()` is permissionless and idempotent — if the chain is no longer prunable by send time the
+   * bundle simulation usually drops the entry; on a node without `eth_simulateV1` the bundle is sent
+   * as-is and the prune reverts `Rollup__NothingToPrune` inside `aggregate3(allowFailure: true)`
+   * (a failed action, never a whole-tx revert). Used by the failed-sync fallback so a stuck pending
+   * chain (e.g. bad data blocking sync) can be wound back to recover.
+   * @returns true if a prune request was enqueued, false otherwise.
+   */ async enqueuePruneIfPrunable(slotNumber) {
+        if (this.lastActions['prune'] === slotNumber) {
+            this.log.debug(`Skipping duplicate prune for slot ${slotNumber}`, {
+                slotNumber
+            });
+            return false;
+        }
+        // Use the SAME timestamp the bundle simulator overrides block.timestamp with at send time
+        // (sequencer-bundle-simulator.ts) so this upfront check and the send-time sim agree. Slot-start
+        // and last-L1-slot both fall within the same L2 slot (and epoch, which is what `canPruneAtTime`
+        // derives), so they agree today; matching the simulator keeps it robust if the contract ever uses
+        // the timestamp more granularly.
+        const ts = getLastL1SlotTimestampForL2Slot(slotNumber, this.epochCache.getL1Constants());
+        const canPrune = await this.rollupContract.canPruneAtTime(ts).catch((err)=>{
+            this.log.error(`Failed to check canPruneAtTime for slot ${slotNumber}`, err, {
+                slotNumber
+            });
+            return false;
+        });
+        if (!canPrune) {
+            this.log.debug(`Rollup not prunable at slot ${slotNumber}`, {
+                slotNumber
+            });
+            return false;
+        }
+        const request = {
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'prune',
+                args: []
+            })
+        };
+        this.log.info(`Enqueuing rollup prune for slot ${slotNumber}`, {
+            slotNumber
+        });
+        return this.enqueueRequest('prune', request, {
+            address: this.rollupContract.address,
+            abi: RollupAbi,
+            eventName: 'PrunedPending'
+        }, slotNumber);
+    }
+    /** Enqueues all slashing actions as returned by the slasher client. */ async enqueueSlashingActions(actions, slotNumber, signerAddress, signer) {
         if (actions.length === 0) {
             this.log.debug(`No slashing actions to enqueue for slot ${slotNumber}`);
             return false;
         }
         for (const action of actions){
             switch(action.type){
-                case 'vote-empire-payload':
-                    {
-                        if (this.slashingProposerContract?.type !== 'empire') {
-                            this.log.error('Cannot vote for empire payload on non-empire slashing contract');
-                            break;
-                        }
-                        this.log.debug(`Enqueuing slashing vote for payload ${action.payload} at slot ${slotNumber}`, {
-                            signerAddress
-                        });
-                        await this.enqueueCastSignalHelper(slotNumber, timestamp, 'empire-slashing-signal', action.payload, this.slashingProposerContract, signerAddress, signer);
-                        break;
-                    }
-                case 'create-empire-payload':
-                    {
-                        this.log.debug(`Enqueuing slashing create payload at slot ${slotNumber}`, {
-                            slotNumber,
-                            signerAddress
-                        });
-                        const request = this.slashFactoryContract.buildCreatePayloadRequest(action.data);
-                        await this.simulateAndEnqueueRequest('create-empire-payload', request, (receipt)=>!!this.slashFactoryContract.tryExtractSlashPayloadCreatedEvent(receipt.logs), slotNumber, timestamp);
-                        break;
-                    }
-                case 'execute-empire-payload':
-                    {
-                        this.log.debug(`Enqueuing slashing execute payload at slot ${slotNumber}`, {
-                            slotNumber,
-                            signerAddress
-                        });
-                        if (this.slashingProposerContract?.type !== 'empire') {
-                            this.log.error('Cannot execute slashing payload on non-empire slashing contract');
-                            return false;
-                        }
-                        const empireSlashingProposer = this.slashingProposerContract;
-                        const request = empireSlashingProposer.buildExecuteRoundRequest(action.round);
-                        await this.simulateAndEnqueueRequest('execute-empire-payload', request, (receipt)=>!!empireSlashingProposer.tryExtractPayloadSubmittedEvent(receipt.logs), slotNumber, timestamp);
-                        break;
-                    }
                 case 'vote-offenses':
                     {
                         this.log.debug(`Enqueuing slashing vote for ${action.votes.length} votes at slot ${slotNumber}`, {
@@ -1003,14 +1437,17 @@ export class SequencerPublisher {
                             votesCount: action.votes.length,
                             signerAddress
                         });
-                        if (this.slashingProposerContract?.type !== 'tally') {
-                            this.log.error('Cannot vote for slashing offenses on non-tally slashing contract');
+                        if (!this.slashingProposerContract) {
+                            this.log.error('No slashing proposer contract available');
                             return false;
                         }
-                        const tallySlashingProposer = this.slashingProposerContract;
                         const votes = bufferToHex(encodeSlashConsensusVotes(action.votes));
-                        const request = await tallySlashingProposer.buildVoteRequestFromSigner(votes, slotNumber, signer);
-                        await this.simulateAndEnqueueRequest('vote-offenses', request, (receipt)=>!!tallySlashingProposer.tryExtractVoteCastEvent(receipt.logs), slotNumber, timestamp);
+                        const request = await this.slashingProposerContract.buildVoteRequestFromSigner(votes, slotNumber, signer);
+                        this.enqueueRequest('vote-offenses', request, {
+                            address: this.slashingProposerContract.address.toString(),
+                            abi: SlashingProposerAbi,
+                            eventName: 'VoteCast'
+                        }, slotNumber);
                         break;
                     }
                 case 'execute-slash':
@@ -1020,13 +1457,16 @@ export class SequencerPublisher {
                             round: action.round,
                             signerAddress
                         });
-                        if (this.slashingProposerContract?.type !== 'tally') {
-                            this.log.error('Cannot execute slashing offenses on non-tally slashing contract');
+                        if (!this.slashingProposerContract) {
+                            this.log.error('No slashing proposer contract available');
                             return false;
                         }
-                        const tallySlashingProposer = this.slashingProposerContract;
-                        const request = tallySlashingProposer.buildExecuteRoundRequest(action.round, action.committees);
-                        await this.simulateAndEnqueueRequest('execute-slash', request, (receipt)=>!!tallySlashingProposer.tryExtractRoundExecutedEvent(receipt.logs), slotNumber, timestamp);
+                        const executeRequest = this.slashingProposerContract.buildExecuteRoundRequest(action.round, action.committees);
+                        this.enqueueRequest('execute-slash', executeRequest, {
+                            address: this.slashingProposerContract.address.toString(),
+                            abi: SlashingProposerAbi,
+                            eventName: 'RoundExecuted'
+                        }, slotNumber);
                         break;
                     }
                 default:
@@ -1038,63 +1478,50 @@ export class SequencerPublisher {
         }
         return true;
     }
-    /** Simulates and enqueues a proposal for a checkpoint on L1 */ async enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, opts = {}) {
+    /** Enqueues a proposal for a checkpoint on L1 */ async enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, opts = {}) {
         const checkpointHeader = checkpoint.header;
         const blobFields = checkpoint.toBlobFields();
-        const blobs = getBlobsPerL1Block(blobFields);
+        const blobs = await getBlobsPerL1Block(blobFields);
         const proposeTxArgs = {
             header: checkpointHeader,
             archive: checkpoint.archive.root.toBuffer(),
             blobs,
             attestationsAndSigners,
-            attestationsAndSignersSignature
+            attestationsAndSignersSignature,
+            feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
         };
-        let ts;
-        try {
-            // @note  This will make sure that we are passing the checks for our header ASSUMING that the data is also made available
-            //        This means that we can avoid the simulation issues in later checks.
-            //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
-            //        make time consistency checks break.
-            // TODO(palla): Check whether we're validating twice, once here and once within addProposeTx, since we call simulateProposeTx in both places.
-            ts = await this.validateCheckpointForSubmission(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, opts);
-        } catch (err) {
-            this.log.error(`Checkpoint validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
-                ...checkpoint.getStats(),
-                slotNumber: checkpoint.header.slotNumber,
-                forcePendingCheckpointNumber: opts.forcePendingCheckpointNumber
-            });
-            throw err;
-        }
         this.log.verbose(`Enqueuing checkpoint propose transaction`, {
             ...checkpoint.toCheckpointInfo(),
-            ...opts
+            txTimeoutAt: opts.txTimeoutAt
+        });
+        await this.addProposeTx(checkpoint, proposeTxArgs, {
+            txTimeoutAt: opts.txTimeoutAt
         });
-        await this.addProposeTx(checkpoint, proposeTxArgs, opts, ts);
     }
     enqueueInvalidateCheckpoint(request, opts = {}) {
         if (!request) {
             return;
         }
-        // We issued the simulation against the rollup contract, so we need to account for the overhead of the multicall3
-        const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil(Number(request.gasUsed) * 64 / 63)));
         const { gasUsed, checkpointNumber } = request;
         const logData = {
             gasUsed,
             checkpointNumber,
-            gasLimit,
             opts
         };
         this.log.verbose(`Enqueuing invalidate checkpoint request`, logData);
         this.addRequest({
             action: `invalidate-by-${request.reason}`,
             request: request.request,
-            gasConfig: {
-                gasLimit,
+            gasConfig: opts.txTimeoutAt ? {
                 txTimeoutAt: opts.txTimeoutAt
-            },
+            } : undefined,
             lastValidL2Slot: SlotNumber(this.getCurrentL2Slot() + 2),
             checkSuccess: (_req, result)=>{
-                const success = result && result.receipt && result.receipt.status === 'success' && tryExtractEvent(result.receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointInvalidated');
+                const success = result && extractEventSuccess(result.receipt, {
+                    address: this.rollupContract.address,
+                    abi: RollupAbi,
+                    eventName: 'CheckpointInvalidated'
+                });
                 if (!success) {
                     this.log.warn(`Invalidate checkpoint ${request.checkpointNumber} failed`, {
                         ...result,
@@ -1110,57 +1537,36 @@ export class SequencerPublisher {
             }
         });
     }
-    async simulateAndEnqueueRequest(action, request, checkSuccess, slotNumber, timestamp) {
-        const logData = {
-            slotNumber,
-            timestamp,
-            gasLimit: undefined
-        };
+    /**
+   * Dedup-checked enqueue helper for actions that are simulated at bundle-send time rather
+   * than at enqueue time. Validates the (action, slot) dedup key, sets `lastActions`, and
+   * enqueues without a gasLimit so the bundle simulate sets the only gasLimit that matters.
+   */ enqueueRequest(action, request, eventOpts, slotNumber) {
         if (this.lastActions[action] && this.lastActions[action] === slotNumber) {
             this.log.debug(`Skipping duplicate action ${action} for slot ${slotNumber}`);
             return false;
         }
         const cachedLastActionSlot = this.lastActions[action];
         this.lastActions[action] = slotNumber;
-        this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
-        let gasUsed;
-        try {
-            ({ gasUsed } = await this.l1TxUtils.simulate(request, {
-                time: timestamp
-            }, [], ErrorsAbi)); // TODO(palla/slash): Check the timestamp logic
-            this.log.verbose(`Simulation for ${action} succeeded`, {
-                ...logData,
-                request,
-                gasUsed
-            });
-        } catch (err) {
-            const viemError = formatViemError(err);
-            this.log.error(`Simulation for ${action} at ${slotNumber} failed`, viemError, logData);
-            return false;
-        }
-        // We issued the simulation against the rollup contract, so we need to account for the overhead of the multicall3
-        const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil(Number(gasUsed) * 64 / 63)));
-        logData.gasLimit = gasLimit;
-        this.log.debug(`Enqueuing ${action}`, logData);
+        this.log.debug(`Enqueuing ${action}`, {
+            slotNumber
+        });
         this.addRequest({
             action,
             request,
-            gasConfig: {
-                gasLimit
-            },
             lastValidL2Slot: slotNumber,
-            checkSuccess: (_req, result)=>{
-                const success = result && result.receipt && result.receipt.status === 'success' && checkSuccess(result.receipt);
+            checkSuccess: (_request, result)=>{
+                const success = result && extractEventSuccess(result.receipt, eventOpts);
                 if (!success) {
                     this.log.warn(`Action ${action} at ${slotNumber} failed`, {
                         ...result,
-                        ...logData
+                        slotNumber
                     });
                     this.lastActions[action] = cachedLastActionSlot;
                 } else {
                     this.log.info(`Action ${action} at ${slotNumber} succeeded`, {
                         ...result,
-                        ...logData
+                        slotNumber
                     });
                 }
                 return !!success;
@@ -1175,13 +1581,14 @@ export class SequencerPublisher {
    * A call to `restart` is required before you can continue publishing.
    */ interrupt() {
         this.interrupted = true;
+        this.interruptibleSleep.interrupt();
         this.l1TxUtils.interrupt();
     }
     /** Restarts the publisher after calling `interrupt`. */ restart() {
         this.interrupted = false;
         this.l1TxUtils.restart();
     }
-    async prepareProposeTx(encodedData, timestamp, options) {
+    async prepareProposeTx(encodedData) {
         const kzg = Blob.getViemKzgInstance();
         const blobInput = getPrefixedEthBlobCommitments(encodedData.blobs);
         this.log.debug('Validating blob input', {
@@ -1195,7 +1602,11 @@ export class SequencerPublisher {
             blobEvaluationGas = BigInt(encodedData.blobs.length) * 21_000n;
             this.log.debug(`Using fixed blob evaluation gas estimate in fisherman mode: ${blobEvaluationGas}`);
         } else {
-            // Normal mode - use estimateGas with blob inputs
+            // We call validateBlobs via estimateGas with real blob+kzg sidecars as a consistency check
+            // that our locally-built blob commitments match the blob data. The bundle simulate at send
+            // time uses eth_simulateV1, which cannot carry blob inputs, so the rollup's on-chain blob
+            // check is forced off there — making this the only pre-flight detector of a commitment/data
+            // mismatch. The returned gas estimate is stashed on the request for the bundle path to read.
             blobEvaluationGas = await this.l1TxUtils.estimateGas(this.getSenderAddress().toString(), {
                 to: this.rollupContract.address,
                 data: encodeFunctionData({
@@ -1208,10 +1619,42 @@ export class SequencerPublisher {
             }, {}, {
                 blobs: encodedData.blobs.map((b)=>b.data),
                 kzg
-            }).catch((err)=>{
-                const { message, metaMessages } = formatViemError(err);
-                this.log.error(`Failed to validate blobs`, message, {
-                    metaMessages
+            }).catch(async (err)=>{
+                const viemError = formatViemError(err);
+                this.log.error(`Failed to validate blobs`, viemError.message, {
+                    metaMessages: viemError.metaMessages
+                });
+                const validateBlobsData = encodeFunctionData({
+                    abi: RollupAbi,
+                    functionName: 'validateBlobs',
+                    args: [
+                        blobInput
+                    ]
+                });
+                const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+                this.backupFailedTx({
+                    id: keccak256(validateBlobsData),
+                    failureType: 'simulation',
+                    request: {
+                        to: this.rollupContract.address,
+                        data: validateBlobsData
+                    },
+                    blobData: encodedData.blobs.map((b)=>toHex(b.data)),
+                    l1BlockNumber,
+                    error: {
+                        message: viemError.message,
+                        name: viemError.name
+                    },
+                    context: {
+                        actions: [
+                            'validate-blobs'
+                        ],
+                        sender: this.getSenderAddress().toString()
+                    },
+                    timing: this.computeTimingInfo(this.getCurrentL2Slot())
+                }, {
+                    captureFeeSummary: true,
+                    targetSlot: this.getCurrentL2Slot()
                 });
                 throw new Error('Failed to validate blobs');
             });
@@ -1222,8 +1665,7 @@ export class SequencerPublisher {
                 header: encodedData.header.toViem(),
                 archive: toHex(encodedData.archive),
                 oracleInput: {
-                    // We are currently not modifying these. See #9963
-                    feeAssetPriceModifier: 0n
+                    feeAssetPriceModifier: encodedData.feeAssetPriceModifier
                 }
             },
             encodedData.attestationsAndSigners.getPackedAttestations(),
@@ -1231,88 +1673,23 @@ export class SequencerPublisher {
             encodedData.attestationsAndSignersSignature.toViemSignature(),
             blobInput
         ];
-        const { rollupData, simulationResult } = await this.simulateProposeTx(args, timestamp, options);
-        return {
-            args,
-            blobEvaluationGas,
-            rollupData,
-            simulationResult
-        };
-    }
-    /**
-   * Simulates the propose tx with eth_simulateV1
-   * @param args - The propose tx args
-   * @param timestamp - The timestamp to simulate proposal at
-   * @returns The simulation result
-   */ async simulateProposeTx(args, timestamp, options) {
         const rollupData = encodeFunctionData({
             abi: RollupAbi,
             functionName: 'propose',
             args
         });
-        // override the pending checkpoint number if requested
-        const forcePendingCheckpointNumberStateDiff = (options.forcePendingCheckpointNumber !== undefined ? await this.rollupContract.makePendingCheckpointNumberOverride(options.forcePendingCheckpointNumber) : []).flatMap((override)=>override.stateDiff ?? []);
-        const stateOverrides = [
-            {
-                address: this.rollupContract.address,
-                // @note we override checkBlob to false since blobs are not part simulate()
-                stateDiff: [
-                    {
-                        slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true),
-                        value: toPaddedHex(0n, true)
-                    },
-                    ...forcePendingCheckpointNumberStateDiff
-                ]
-            }
-        ];
-        // In fisherman mode, simulate as the proposer but with sufficient balance
-        if (this.proposerAddressForSimulation) {
-            stateOverrides.push({
-                address: this.proposerAddressForSimulation.toString(),
-                balance: 10n * WEI_CONST * WEI_CONST
-            });
-        }
-        const simulationResult = await this.l1TxUtils.simulate({
-            to: this.rollupContract.address,
-            data: rollupData,
-            gas: SequencerPublisher.PROPOSE_GAS_GUESS,
-            ...this.proposerAddressForSimulation && {
-                from: this.proposerAddressForSimulation.toString()
-            }
-        }, {
-            // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
-            time: timestamp + 1n,
-            // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit so we increase here
-            gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n
-        }, stateOverrides, RollupAbi, {
-            // @note fallback gas estimate to use if the node doesn't support simulation API
-            fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS
-        }).catch((err)=>{
-            // In fisherman mode, we expect ValidatorSelection__MissingProposerSignature since fisherman doesn't have proposer signature
-            const viemError = formatViemError(err);
-            if (this.config.fishermanMode && viemError.message?.includes('ValidatorSelection__MissingProposerSignature')) {
-                this.log.debug(`Ignoring expected ValidatorSelection__MissingProposerSignature error in fisherman mode`);
-                // Return a minimal simulation result with the fallback gas estimate
-                return {
-                    gasUsed: SequencerPublisher.PROPOSE_GAS_GUESS,
-                    logs: []
-                };
-            }
-            this.log.error(`Failed to simulate propose tx`, viemError);
-            throw err;
-        });
         return {
-            rollupData,
-            simulationResult
+            args,
+            blobEvaluationGas,
+            rollupData
         };
     }
-    async addProposeTx(checkpoint, encodedData, opts = {}, timestamp) {
+    async addProposeTx(checkpoint, encodedData, opts = {}) {
         const slot = checkpoint.header.slotNumber;
         const timer = new Timer();
         const kzg = Blob.getViemKzgInstance();
-        const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp, opts);
+        const { rollupData, blobEvaluationGas } = await this.prepareProposeTx(encodedData);
         const startBlock = await this.l1TxUtils.getBlockNumber();
-        const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil(Number(simulationResult.gasUsed) * 64 / 63)) + blobEvaluationGas + SequencerPublisher.MULTICALL_OVERHEAD_GAS_GUESS);
         // Send the blobs to the blob client preemptively. This helps in tests where the sequencer mistakingly thinks that the propose
         // tx fails but it does get mined. We make sure that the blobs are sent to the blob client regardless of the tx outcome.
         void Promise.resolve().then(()=>this.blobClient.sendBlobsToFilestore(encodedData.blobs).catch((_err)=>{
@@ -1326,9 +1703,10 @@ export class SequencerPublisher {
             },
             lastValidL2Slot: checkpoint.header.slotNumber,
             gasConfig: {
-                ...opts,
-                gasLimit
+                txTimeoutAt: opts.txTimeoutAt,
+                gasLimit: undefined
             },
+            blobEvaluationGas,
             blobConfig: {
                 blobs: encodedData.blobs.map((b)=>b.data),
                 kzg
@@ -1338,7 +1716,11 @@ export class SequencerPublisher {
                     return false;
                 }
                 const { receipt, stats, errorMsg } = result;
-                const success = receipt && receipt.status === 'success' && tryExtractEvent(receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointProposed');
+                const success = extractEventSuccess(receipt, {
+                    address: this.rollupContract.address,
+                    abi: RollupAbi,
+                    eventName: 'CheckpointProposed'
+                });
                 if (success) {
                     const endBlock = receipt.blockNumber;
                     const inclusionBlocks = Number(endBlock - startBlock);
@@ -1375,4 +1757,8 @@ export class SequencerPublisher {
             }
         });
     }
+    /** Returns the timestamp of the next L1 slot boundary after now. */ getNextL1SlotTimestamp() {
+        const l1Constants = this.epochCache.getL1Constants();
+        return getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), l1Constants);
+    }
 }