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

package/dest/publisher/sequencer-publisher.js

@@ -1,98 +1,625 @@
-import { Blob } from '@aztec/blob-lib';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { FormattedViemError, RollupContract, formatViemError } from '@aztec/ethereum';
-import { toHex } from '@aztec/foundation/bigint-buffer';
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            if (kind === 1 || kind === 3) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 || kind === 4) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0) {
+                hint = "field";
+            } else if (kind === 10) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 || kind === 1) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2) {
+            value = desc.value;
+        } else if (kind === 3) {
+            value = desc.get;
+        } else if (kind === 4) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0) {
+                    init = newValue;
+                } else if (kind === 1) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0) {
+                        newInit = newValue;
+                    } else if (kind === 1) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 || kind === 1) {
+            if (init === void 0) {
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++){
+                        value = ownInitializers[i].call(instance, value);
+                    }
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0) {
+            if (kind === 1) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2) {
+                desc.value = value;
+            } else if (kind === 3) {
+                desc.get = value;
+            } else if (kind === 4) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5;
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5;
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++){
+                    initializers[i].call(instance);
+                }
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++){
+                        initializers[i].call(newClass);
+                    }
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _dec1, _initProto;
+import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { FeeAssetPriceOracle, MULTI_CALL_3_ADDRESS, Multicall3, MulticallForwarderRevertedError, buildSimulationOverridesStateOverride } from '@aztec/ethereum/contracts';
+import { L1FeeAnalyzer } from '@aztec/ethereum/l1-fee-analysis';
+import { 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 { ForwarderAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import pick from 'lodash.pick';
-import { encodeFunctionData } from 'viem';
+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, 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';
-export var VoteType = /*#__PURE__*/ function(VoteType) {
-    VoteType[VoteType["GOVERNANCE"] = 0] = "GOVERNANCE";
-    VoteType[VoteType["SLASHING"] = 1] = "SLASHING";
-    return VoteType;
-}({});
+/**
+ * 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',
+    'propose',
+    'governance-signal',
+    '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');
 export class SequencerPublisher {
-    interrupted = false;
+    config;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "sendRequests"
+            ],
+            [
+                _dec1,
+                2,
+                "validateBlockHeader"
+            ]
+        ], []));
+    }
+    interrupted;
     metrics;
+    bundleSimulator;
     epochCache;
-    forwarderContract;
-    governanceLog = createLogger('sequencer:publisher:governance');
-    governanceProposerAddress;
-    governancePayload = EthAddress.ZERO;
-    slashingLog = createLogger('sequencer:publisher:slashing');
-    slashingProposerAddress;
-    getSlashPayload = undefined;
-    myLastVotes = {
-        [0]: 0n,
-        [1]: 0n
-    };
-    log = createLogger('sequencer:publisher');
+    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;
+    log;
     ethereumSlotDuration;
-    blobSinkClient;
-    // @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;
+    aztecSlotDuration;
+    /** Date provider for wall-clock time. */ dateProvider;
+    blobClient;
+    /** Optional callback to obtain a replacement publisher when the current one fails to send. */ getNextPublisher;
+    /** L1 fee analyzer for fisherman mode */ l1FeeAnalyzer;
+    /** 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;
-    requests = [];
+    tracer;
+    requests;
     constructor(config, deps){
+        this.config = config;
+        this.interrupted = (_initProto(this), false);
+        this.revertDecoderAbi = mergeAbis([
+            RollupAbi,
+            SlashingProposerAbi,
+            EmpireBaseAbi,
+            ErrorsAbi
+        ]);
+        this.lastActions = {};
+        this.interruptibleSleep = new InterruptibleSleep();
+        this.requests = [];
+        this.log = deps.log ?? createLogger('sequencer:publisher');
         this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+        this.aztecSlotDuration = BigInt(config.aztecSlotDuration);
+        this.dateProvider = deps.dateProvider;
         this.epochCache = deps.epochCache;
-        this.blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+        this.lastActions = deps.lastActions;
+        this.blobClient = deps.blobClient;
+        this.dateProvider = deps.dateProvider;
         const telemetry = deps.telemetry ?? getTelemetryClient();
-        this.metrics = new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
+        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.forwarderContract = deps.forwarderContract;
         this.govProposerContract = deps.governanceProposerContract;
         this.slashingProposerContract = deps.slashingProposerContract;
+        this.rollupContract.listenToSlasherChanged(async ()=>{
+            this.log.info('Slashing proposer changed');
+            const newSlashingProposer = await this.rollupContract.getSlashingProposer();
+            this.slashingProposerContract = newSlashingProposer;
+        });
+        // Initialize L1 fee analyzer for fisherman mode
+        if (config.fishermanMode) {
+            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')
+        });
     }
-    registerSlashPayloadGetter(callback) {
-        this.getSlashPayload = callback;
+    /**
+   * Backs up a failed L1 transaction to the configured store for debugging.
+   * Does nothing if no store is configured.
+   */ backupFailedTx(failedTx) {
+        if (!this.failedTxStore) {
+            return;
+        }
+        const tx = {
+            ...failedTx,
+            timestamp: Date.now()
+        };
+        // Fire and forget - don't block on backup
+        void this.failedTxStore.then((store)=>store?.saveFailedTx(tx)).catch((err)=>{
+            this.log.warn(`Failed to backup failed L1 tx to store`, err);
+        });
     }
-    getForwarderAddress() {
-        return EthAddress.fromString(this.forwarderContract.getAddress());
+    getRollupContract() {
+        return this.rollupContract;
     }
-    getSenderAddress() {
-        return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+    /**
+   * 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);
     }
-    getGovernancePayload() {
-        return this.governancePayload;
+    getSenderAddress() {
+        return this.l1TxUtils.getSenderAddress();
     }
-    setGovernancePayload(payload) {
-        this.governancePayload = payload;
+    /**
+   * Gets the L1 fee analyzer instance (only available in fisherman mode)
+   */ getL1FeeAnalyzer() {
+        return this.l1FeeAnalyzer;
     }
     addRequest(request) {
         this.requests.push(request);
     }
     getCurrentL2Slot() {
-        return this.epochCache.getEpochAndSlotNow().slot;
+        return this.epochCache.getSlotNow();
+    }
+    /**
+   * Clears all pending requests without sending them.
+   */ clearPendingRequests() {
+        const count = this.requests.length;
+        this.requests = [];
+        if (count > 0) {
+            this.log.debug(`Cleared ${count} pending request(s)`);
+        }
+    }
+    /**
+   * Analyzes L1 fees for the pending requests without sending them.
+   * This is used in fisherman mode to validate fee calculations.
+   * @param l2SlotNumber - The L2 slot number for this analysis
+   * @param onComplete - Optional callback to invoke when analysis completes (after block is mined)
+   * @returns The analysis result (incomplete until block mines), or undefined if no requests
+   */ async analyzeL1Fees(l2SlotNumber, onComplete) {
+        if (!this.l1FeeAnalyzer) {
+            this.log.warn('L1 fee analyzer not available (not in fisherman mode)');
+            return undefined;
+        }
+        const requestsToAnalyze = [
+            ...this.requests
+        ];
+        if (requestsToAnalyze.length === 0) {
+            this.log.debug('No requests to analyze for L1 fees');
+            return undefined;
+        }
+        // Extract blob config from requests (if any)
+        const blobConfigs = requestsToAnalyze.filter((request)=>request.blobConfig).map((request)=>request.blobConfig);
+        const blobConfig = blobConfigs[0];
+        // Get gas configs
+        const gasConfigs = requestsToAnalyze.filter((request)=>request.gasConfig).map((request)=>request.gasConfig);
+        const gasLimits = gasConfigs.map((g)=>g?.gasLimit).filter((g)=>g !== undefined);
+        const gasLimit = gasLimits.length > 0 ? gasLimits.reduce((sum, g)=>sum + g, 0n) : 0n;
+        // Get the transaction requests
+        const l1Requests = requestsToAnalyze.map((r)=>r.request);
+        // Start the analysis
+        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(),
+            requestCount: requestsToAnalyze.length,
+            hasBlobConfig: !!blobConfig,
+            gasLimit: gasLimit.toString(),
+            actions: requestsToAnalyze.map((r)=>r.action)
+        });
+        // Return the analysis result (will be incomplete until block mines)
+        return this.l1FeeAnalyzer.getAnalysis(analysisId);
     }
     /**
    * 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
         ];
         this.requests = [];
-        if (this.interrupted) {
+        if (this.interrupted || requestsToProcess.length === 0) {
             return undefined;
         }
-        const currentL2Slot = this.getCurrentL2Slot();
-        this.log.debug(`Current L2 slot: ${currentL2Slot}`);
+        const currentL2Slot = targetSlot ?? this.getCurrentL2Slot();
+        this.log.debug(`Sending requests on L2 slot ${currentL2Slot}`);
         const validRequests = requestsToProcess.filter((request)=>request.lastValidL2Slot >= currentL2Slot);
+        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}`, {
                 validRequests: validRequests.map((request)=>({
@@ -109,56 +636,235 @@ export class SequencerPublisher {
             this.log.debug(`No valid requests to send`);
             return undefined;
         }
-        // @note - we can only have one gas config and 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);
-        const blobConfigs = requestsToProcess.filter((request)=>request.blobConfig);
-        if (gasConfigs.length > 1 || blobConfigs.length > 1) {
-            throw new Error('Multiple gas or blob configs found');
-        }
-        const gasConfig = gasConfigs[0]?.gasConfig;
-        const blobConfig = blobConfigs[0]?.blobConfig;
+        // 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;
+        // 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);
+                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 this.forwarderContract.forward(validRequests.map((request)=>request.request), this.l1TxUtils, gasConfig, blobConfig, this.log);
-            this.callbackBundledTransactions(validRequests, result);
-            return result;
+            const result = await this.forwardWithPublisherRotation(requests, txConfig, blobConfig);
+            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: requests.map((x)=>x.action),
+                successfulActions,
+                failedActions: allFailedActions
+            };
         } catch (err) {
             const viemError = formatViemError(err);
             this.log.error(`Failed to publish bundled transactions`, viemError);
             return undefined;
         } finally{
             try {
-                this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress());
+                this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress().toString());
             } catch (err) {
                 this.log.warn(`Failed to record balance after sending tx: ${err}`);
             }
         }
     }
+    /** 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
+            });
+        }
+    }
+    /** Backs up entries dropped by bundle simulation, one record per dropped action. */ async backupDroppedInSim(dropped) {
+        if (dropped.length === 0) {
+            return;
+        }
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+        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: l1BlockNumber.toString(),
+                error: {
+                    message: 'Bundle entry dropped: action reverted in sim'
+                },
+                context: {
+                    actions: [
+                        req.action
+                    ],
+                    sender: this.getSenderAddress().toString()
+                }
+            });
+        }
+    }
+    /**
+   * 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) {
+        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
+                    });
+                    return undefined;
+                }
+                const viemError = formatViemError(err);
+                if (!this.getNextPublisher) {
+                    this.log.error('Failed to publish bundled transactions', viemError);
+                    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())
+                    });
+                    return undefined;
+                }
+                currentPublisher = nextPublisher;
+            }
+        }
+    }
+    /*
+   * Schedules sending all enqueued requests at (or after) the start of the given L2 slot.
+   * Sleeps until one L1 slot before the L2 slot boundary so the tx has a chance of being
+   * picked up by the first L1 block of the L2 slot.
+   * NB: there is a known correctness risk — being included in the L1 block right before the
+   * L2 slot starts would revert propose with HeaderLib__InvalidSlotNumber.
+   * Uses InterruptibleSleep so it can be cancelled via interrupt().
+   */ async sendRequestsAt(targetSlot) {
+        const l1Constants = this.epochCache.getL1Constants();
+        // Start of the target L2 slot, in ms (getTimestampForSlot returns seconds).
+        const startOfTargetSlotMs = Number(getTimestampForSlot(targetSlot, l1Constants)) * 1000;
+        // Aim to be in the mempool one L1 slot before the L2 slot starts, so we have a chance of
+        // being picked up by the first L1 block of the L2 slot.
+        const submitAfterMs = startOfTargetSlotMs - Number(this.ethereumSlotDuration) * 1000;
+        const sleepMs = submitAfterMs - this.dateProvider.now();
+        if (sleepMs > 0) {
+            this.log.debug(`Sleeping ${sleepMs}ms before sending requests`, {
+                targetSlot,
+                submitAfterMs
+            });
+            await this.interruptibleSleep.sleep(sleepMs);
+        }
+        if (this.interrupted) {
+            return undefined;
+        }
+        return this.sendRequests(targetSlot);
+    }
     callbackBundledTransactions(requests, result) {
-        const success = result?.receipt.status === 'success';
-        const logger = success ? this.log.info : this.log.error;
+        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){
-            logger(`Bundled [${request.action}] transaction [${success ? 'succeeded' : 'failed'}]`);
-            request.onResult?.(request.request, result);
+            if (request.checkSuccess(request.request, result)) {
+                successfulActions.push(request.action);
+            } else {
+                failedActions.push(request.action);
+            }
         }
+        return {
+            successfulActions,
+            failedActions
+        };
     }
     /**
-   * @notice  Will call `canProposeAtNextEthBlock` to make sure that it is possible to propose
+   * @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) {
-        const ignoredErrors = [
+   */ async canProposeAt(tipArchive, msgSender, simulationOverridesPlan) {
+        // TODO: #14291 - should loop through multiple keys to check if any of them can propose
+        // 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, this.getForwarderAddress().toString(), this.ethereumSlotDuration).catch((err)=>{
-            if (err instanceof FormattedViemError && ignoredErrors.find((e)=>err.message.includes(e))) {
-                this.log.debug(err.message);
+        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 {
                 this.log.error(err.name, err);
             }
@@ -166,135 +872,406 @@ export class SequencerPublisher {
         });
     }
     /**
-   * @notice  Will call `validateHeader` to make sure that it is possible to propose
-   *
-   * @dev     Throws if unable to propose
-   *
-   * @param header - The header to propose
-   * @param digest - The digest that attestations are signing over
-   *
-   */ async validateBlockForSubmission(header, attestationData = {
-        digest: Buffer.alloc(32),
-        signatures: []
-    }) {
-        const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-        const formattedSignatures = attestationData.signatures.map((attest)=>attest.toViemSignature());
+   * @notice  Will simulate `validateHeader` to make sure that the block header is valid
+   * @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, simulationOverridesPlan) {
         const flags = {
             ignoreDA: true,
-            ignoreSignatures: formattedSignatures.length == 0
+            ignoreSignatures: true
         };
         const args = [
-            `0x${header.toBuffer().toString('hex')}`,
-            formattedSignatures,
-            `0x${attestationData.digest.toString('hex')}`,
-            ts,
-            `0x${header.contentCommitment.blobsHash.toString('hex')}`,
+            header.toViem(),
+            CommitteeAttestationsAndSigners.packAttestations([]),
+            [],
+            Signature.empty().toViemSignature(),
+            `0x${'0'.repeat(64)}`,
+            header.blobsHash.toString(),
             flags
         ];
-        await this.rollupContract.validateHeader(args, this.getForwarderAddress().toString());
-        return ts;
+        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
+            // so we just add sufficient balance to the multicall3 address
+            balance = 10n * WEI_CONST * WEI_CONST; // 10 ETH
+        } else {
+            balance = await this.l1TxUtils.getSenderBalance();
+        }
+        stateOverrides.push({
+            address: MULTI_CALL_3_ADDRESS,
+            balance
+        });
+        await this.l1TxUtils.simulate({
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'validateHeaderWithAttestations',
+                args
+            }),
+            from: MULTI_CALL_3_ADDRESS
+        }, {
+            time: ts
+        }, stateOverrides);
+        this.log.debug(`Simulated validateHeader`);
     }
-    async getCurrentEpochCommittee() {
-        const committee = await this.rollupContract.getCurrentEpochCommittee();
-        return committee.map(EthAddress.fromString);
+    /**
+   * Simulate making a call to invalidate a checkpoint with invalid attestations. Returns undefined if no need to invalidate.
+   * @param validationResult - The validation result indicating which checkpoint to invalidate (as returned by the archiver)
+   */ async simulateInvalidateCheckpoint(validationResult) {
+        if (validationResult.valid) {
+            return undefined;
+        }
+        const { reason, checkpoint } = validationResult;
+        const checkpointNumber = checkpoint.checkpointNumber;
+        const logData = {
+            ...checkpoint,
+            reason
+        };
+        const currentCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+        if (currentCheckpointNumber < checkpointNumber) {
+            this.log.verbose(`Skipping checkpoint ${checkpointNumber} invalidation since it has already been removed from the pending chain`, {
+                currentCheckpointNumber,
+                ...logData
+            });
+            return undefined;
+        }
+        const request = this.buildInvalidateCheckpointRequest(validationResult);
+        this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, {
+            ...logData,
+            request
+        });
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+        try {
+            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, mergeAbis([
+                request.abi ?? [],
+                ErrorsAbi
+            ]));
+            this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} succeeded`, {
+                ...logData,
+                request,
+                gasUsed
+            });
+            return {
+                request,
+                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__CheckpointNotInPendingChain')) {
+                this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} failed due to checkpoint not being in pending chain`, {
+                    ...logData,
+                    request,
+                    error: viemError.message
+                });
+                const latestProposedCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+                if (latestProposedCheckpointNumber < checkpointNumber) {
+                    this.log.verbose(`Checkpoint ${checkpointNumber} has already been invalidated`, {
+                        ...logData
+                    });
+                    return undefined;
+                } else {
+                    this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed and it is still in pending chain`, viemError, logData);
+                    throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber} while it is still in pending chain`, {
+                        cause: viemError
+                    });
+                }
+            }
+            // 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?.toString()
+                },
+                l1BlockNumber: l1BlockNumber.toString(),
+                error: {
+                    message: viemError.message,
+                    name: viemError.name
+                },
+                context: {
+                    actions: [
+                        `invalidate-${reason}`
+                    ],
+                    checkpointNumber,
+                    sender: this.getSenderAddress().toString()
+                }
+            });
+            throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, {
+                cause: viemError
+            });
+        }
+    }
+    buildInvalidateCheckpointRequest(validationResult) {
+        if (validationResult.valid) {
+            throw new Error('Cannot invalidate a valid checkpoint');
+        }
+        const { checkpoint, committee, reason } = validationResult;
+        const logData = {
+            ...checkpoint,
+            reason
+        };
+        this.log.debug(`Building invalidate checkpoint ${checkpoint.checkpointNumber} request`, logData);
+        const attestationsAndSigners = CommitteeAttestationsAndSigners.packAttestations(validationResult.attestations);
+        if (reason === 'invalid-attestation') {
+            return this.rollupContract.buildInvalidateBadAttestationRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee, validationResult.invalidIndex);
+        } else if (reason === 'insufficient-attestations') {
+            return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee);
+        } else {
+            const _ = reason;
+            throw new Error(`Unknown reason for invalidation`);
+        }
     }
-    async enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base) {
-        if (this.myLastVotes[voteType] >= slotNumber) {
+    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;
         }
         if (payload.equals(EthAddress.ZERO)) {
             return false;
         }
+        if (signerAddress.equals(EthAddress.ZERO)) {
+            this.log.warn(`Cannot enqueue vote cast signal ${signalType} for address zero at slot ${slotNumber}`);
+            return false;
+        }
         const round = await base.computeRound(slotNumber);
-        const [proposer, roundInfo] = await Promise.all([
-            this.rollupContract.getProposerAt(timestamp),
-            base.getRoundInfo(this.rollupContract.address, round)
-        ]);
-        if (proposer.toLowerCase() !== this.getForwarderAddress().toString().toLowerCase()) {
+        const roundInfo = await base.getRoundInfo(this.rollupContract.address, round);
+        if (roundInfo.quorumReached) {
             return false;
         }
-        if (roundInfo.lastVote >= slotNumber) {
+        if (roundInfo.lastSignalSlot >= slotNumber) {
             return false;
         }
-        const cachedLastVote = this.myLastVotes[voteType];
-        this.myLastVotes[voteType] = slotNumber;
+        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;
+        const request = await base.createSignalRequestWithSignature(payload.toString(), slotNumber, this.config.l1ChainId, signerAddress.toString(), signer);
+        this.log.debug(`Created ${action} request with signature`, {
+            request,
+            round,
+            signer: this.l1TxUtils.client.account?.address,
+            lastValidL2Slot: slotNumber
+        });
+        // TODO(palla/slash): All votes (governance and slashing) should txTimeoutAt at the end of the slot.
         this.addRequest({
-            action: voteType === 0 ? 'governance-vote' : 'slashing-vote',
-            request: base.createVoteRequest(payload.toString()),
+            action,
+            request,
             lastValidL2Slot: slotNumber,
-            onResult: (_request, result)=>{
-                if (!result || result.receipt.status !== 'success') {
-                    this.myLastVotes[voteType] = cachedLastVote;
+            checkSuccess: (_request, result)=>{
+                const success = result && extractEventSuccess(result.receipt, {
+                    address: base.address.toString(),
+                    abi: EmpireBaseAbi,
+                    eventName: 'SignalCast'
+                });
+                const logData = {
+                    ...result,
+                    slotNumber,
+                    round,
+                    payload: payload.toString()
+                };
+                if (!success) {
+                    this.log.error(`Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} failed`, logData);
+                    this.lastActions[signalType] = cachedLastVote;
+                    return false;
                 } else {
-                    this.log.info(`Cast [${voteType}] vote for slot ${slotNumber}`);
+                    this.log.info(`Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} succeeded`, logData);
+                    return true;
                 }
             }
         });
         return true;
     }
-    async getVoteConfig(slotNumber, voteType) {
-        if (voteType === 0) {
-            return {
-                payload: this.governancePayload,
-                base: this.govProposerContract
-            };
-        } else if (voteType === 1) {
-            if (!this.getSlashPayload) {
-                return undefined;
-            }
-            const slashPayload = await this.getSlashPayload(slotNumber);
-            if (!slashPayload) {
-                return undefined;
-            }
-            return {
-                payload: slashPayload,
-                base: this.slashingProposerContract
-            };
-        }
-        throw new Error('Unreachable: Invalid vote type');
-    }
     /**
-   * Enqueues a castVote transaction to cast a vote for a given slot number.
-   * @param slotNumber - The slot number to cast a vote for.
-   * @param timestamp - The timestamp of the slot to cast a vote for.
-   * @param voteType - The type of vote to cast.
-   * @returns True if the vote was successfully enqueued, false otherwise.
-   */ async enqueueCastVote(slotNumber, timestamp, voteType) {
-        const voteConfig = await this.getVoteConfig(slotNumber, voteType);
-        if (!voteConfig) {
+   * Enqueues a governance castSignal transaction to cast a signal for a given slot number.
+   * @param slotNumber - The slot number to cast a signal for.
+   * @returns True if the signal was successfully enqueued, false otherwise.
+   */ 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, signerAddress, signer) {
+        if (actions.length === 0) {
+            this.log.debug(`No slashing actions to enqueue for slot ${slotNumber}`);
             return false;
         }
-        const { payload, base } = voteConfig;
-        return this.enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base);
+        for (const action of actions){
+            switch(action.type){
+                case 'vote-offenses':
+                    {
+                        this.log.debug(`Enqueuing slashing vote for ${action.votes.length} votes at slot ${slotNumber}`, {
+                            slotNumber,
+                            round: action.round,
+                            votesCount: action.votes.length,
+                            signerAddress
+                        });
+                        if (!this.slashingProposerContract) {
+                            this.log.error('No slashing proposer contract available');
+                            return false;
+                        }
+                        const votes = bufferToHex(encodeSlashConsensusVotes(action.votes));
+                        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':
+                    {
+                        this.log.debug(`Enqueuing slash execution for round ${action.round} at slot ${slotNumber}`, {
+                            slotNumber,
+                            round: action.round,
+                            signerAddress
+                        });
+                        if (!this.slashingProposerContract) {
+                            this.log.error('No slashing proposer contract available');
+                            return false;
+                        }
+                        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:
+                    {
+                        const _ = action;
+                        throw new Error(`Unknown slashing action type: ${action.type}`);
+                    }
+            }
+        }
+        return true;
     }
-    /**
-   * Proposes a L2 block on L1.
-   *
-   * @param block - L2 block to propose.
-   * @returns True if the tx has been enqueued, throws otherwise. See #9315
-   */ async enqueueProposeL2Block(block, attestations, txHashes, opts = {}) {
-        const consensusPayload = new ConsensusPayload(block.header, block.archive.root, txHashes ?? []);
-        const digest = await getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
-        const blobs = await Blob.getBlobs(block.body.toBlobFields());
+    /** Enqueues a proposal for a checkpoint on L1 */ async enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, opts = {}) {
+        const checkpointHeader = checkpoint.header;
+        const blobFields = checkpoint.toBlobFields();
+        const blobs = await getBlobsPerL1Block(blobFields);
         const proposeTxArgs = {
-            header: block.header.toBuffer(),
-            archive: block.archive.root.toBuffer(),
-            blockHash: (await block.header.hash()).toBuffer(),
-            body: block.body.toBuffer(),
+            header: checkpointHeader,
+            archive: checkpoint.archive.root.toBuffer(),
             blobs,
-            attestations,
-            txHashes: txHashes ?? []
+            attestationsAndSigners,
+            attestationsAndSignersSignature,
+            feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
+        };
+        this.log.verbose(`Enqueuing checkpoint propose transaction`, {
+            ...checkpoint.toCheckpointInfo(),
+            txTimeoutAt: opts.txTimeoutAt
+        });
+        await this.addProposeTx(checkpoint, proposeTxArgs, {
+            txTimeoutAt: opts.txTimeoutAt
+        });
+    }
+    enqueueInvalidateCheckpoint(request, opts = {}) {
+        if (!request) {
+            return;
+        }
+        const { gasUsed, checkpointNumber } = request;
+        const logData = {
+            gasUsed,
+            checkpointNumber,
+            opts
         };
-        // @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.
-        const ts = await this.validateBlockForSubmission(block.header, {
-            digest: digest.toBuffer(),
-            signatures: attestations ?? []
+        this.log.verbose(`Enqueuing invalidate checkpoint request`, logData);
+        this.addRequest({
+            action: `invalidate-by-${request.reason}`,
+            request: request.request,
+            gasConfig: opts.txTimeoutAt ? {
+                txTimeoutAt: opts.txTimeoutAt
+            } : undefined,
+            lastValidL2Slot: SlotNumber(this.getCurrentL2Slot() + 2),
+            checkSuccess: (_req, result)=>{
+                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,
+                        ...logData
+                    });
+                } else {
+                    this.log.info(`Invalidate checkpoint ${request.checkpointNumber} succeeded`, {
+                        ...result,
+                        ...logData
+                    });
+                }
+                return !!success;
+            }
+        });
+    }
+    /**
+   * 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(`Enqueuing ${action}`, {
+            slotNumber
+        });
+        this.addRequest({
+            action,
+            request,
+            lastValidL2Slot: slotNumber,
+            checkSuccess: (_request, result)=>{
+                const success = result && extractEventSuccess(result.receipt, eventOpts);
+                if (!success) {
+                    this.log.warn(`Action ${action} at ${slotNumber} failed`, {
+                        ...result,
+                        slotNumber
+                    });
+                    this.lastActions[action] = cachedLastActionSlot;
+                } else {
+                    this.log.info(`Action ${action} at ${slotNumber} succeeded`, {
+                        ...result,
+                        slotNumber
+                    });
+                }
+                return !!success;
+            }
         });
-        this.log.debug(`Submitting propose transaction`);
-        await this.addProposeTx(block, proposeTxArgs, opts, ts);
         return true;
     }
     /**
@@ -304,51 +1281,92 @@ 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) {
+    async prepareProposeTx(encodedData) {
         const kzg = Blob.getViemKzgInstance();
-        const blobInput = Blob.getEthBlobEvaluationInputs(encodedData.blobs);
+        const blobInput = getPrefixedEthBlobCommitments(encodedData.blobs);
         this.log.debug('Validating blob input', {
             blobInput
         });
-        const blobEvaluationGas = await this.l1TxUtils.estimateGas(this.l1TxUtils.walletClient.account, {
-            to: this.rollupContract.address,
-            data: encodeFunctionData({
-                abi: RollupAbi,
-                functionName: 'validateBlobs',
-                args: [
-                    blobInput
-                ]
-            })
-        }, {}, {
-            blobs: encodedData.blobs.map((b)=>b.data),
-            kzg
-        }).catch((err)=>{
-            const { message, metaMessages } = formatViemError(err);
-            this.log.error(`Failed to validate blobs`, message, {
-                metaMessages
+        // Get blob evaluation gas
+        let blobEvaluationGas;
+        if (this.config.fishermanMode) {
+            // In fisherman mode, we can't estimate blob gas because estimateGas doesn't support state overrides
+            // Use a fixed estimate.
+            blobEvaluationGas = BigInt(encodedData.blobs.length) * 21_000n;
+            this.log.debug(`Using fixed blob evaluation gas estimate in fisherman mode: ${blobEvaluationGas}`);
+        } else {
+            // 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({
+                    abi: RollupAbi,
+                    functionName: 'validateBlobs',
+                    args: [
+                        blobInput
+                    ]
+                })
+            }, {}, {
+                blobs: encodedData.blobs.map((b)=>b.data),
+                kzg
+            }).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: l1BlockNumber.toString(),
+                    error: {
+                        message: viemError.message,
+                        name: viemError.name
+                    },
+                    context: {
+                        actions: [
+                            'validate-blobs'
+                        ],
+                        sender: this.getSenderAddress().toString()
+                    }
+                });
+                throw new Error('Failed to validate blobs');
             });
-            throw new Error('Failed to validate blobs');
-        });
-        const attestations = encodedData.attestations ? encodedData.attestations.map((attest)=>attest.toViemSignature()) : [];
-        const txHashes = encodedData.txHashes ? encodedData.txHashes.map((txHash)=>txHash.toString()) : [];
+        }
+        const signers = encodedData.attestationsAndSigners.getSigners().map((signer)=>signer.toString());
         const args = [
             {
-                header: `0x${encodedData.header.toString('hex')}`,
-                archive: `0x${encodedData.archive.toString('hex')}`,
+                header: encodedData.header.toViem(),
+                archive: toHex(encodedData.archive),
                 oracleInput: {
-                    // We are currently not modifying these. See #9963
-                    feeAssetPriceModifier: 0n
-                },
-                blockHash: `0x${encodedData.blockHash.toString('hex')}`,
-                txHashes
+                    feeAssetPriceModifier: encodedData.feeAssetPriceModifier
+                }
             },
-            attestations,
+            encodedData.attestationsAndSigners.getPackedAttestations(),
+            signers,
+            encodedData.attestationsAndSignersSignature.toViemSignature(),
             blobInput
         ];
         const rollupData = encodeFunctionData({
@@ -356,126 +1374,87 @@ export class SequencerPublisher {
             functionName: 'propose',
             args
         });
-        const forwarderData = encodeFunctionData({
-            abi: ForwarderAbi,
-            functionName: 'forward',
-            args: [
-                [
-                    this.rollupContract.address
-                ],
-                [
-                    rollupData
-                ]
-            ]
-        });
-        const simulationResult = await this.l1TxUtils.simulateGasUsed({
-            to: this.getForwarderAddress().toString(),
-            data: forwarderData,
-            gas: SequencerPublisher.PROPOSE_GAS_GUESS
-        }, {
-            // @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
-            gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n
-        }, [
-            {
-                address: this.rollupContract.address,
-                // @note we override checkBlob to false since blobs are not part simulate()
-                stateDiff: [
-                    {
-                        slot: toHex(RollupContract.checkBlobStorageSlot, true),
-                        value: toHex(0n, true)
-                    }
-                ]
-            }
-        ], {
-            // @note fallback gas estimate to use if the node doesn't support simulation API
-            fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS
-        }).catch((err)=>{
-            const { message, metaMessages } = formatViemError(err);
-            this.log.error(`Failed to simulate gas used`, message, {
-                metaMessages
-            });
-            throw new Error('Failed to simulate gas used');
-        });
         return {
             args,
             blobEvaluationGas,
-            rollupData,
-            simulationResult
+            rollupData
         };
     }
-    async addProposeTx(block, 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);
+        const { rollupData, blobEvaluationGas } = await this.prepareProposeTx(encodedData);
         const startBlock = await this.l1TxUtils.getBlockNumber();
-        const blockHash = await block.hash();
+        // 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)=>{
+                this.log.error('Failed to send blobs to blob client');
+            }));
         return this.addRequest({
             action: 'propose',
             request: {
                 to: this.rollupContract.address,
                 data: rollupData
             },
-            lastValidL2Slot: block.header.globalVariables.slotNumber.toBigInt(),
+            lastValidL2Slot: checkpoint.header.slotNumber,
             gasConfig: {
-                ...opts,
-                gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult + blobEvaluationGas)
+                txTimeoutAt: opts.txTimeoutAt,
+                gasLimit: undefined
             },
+            blobEvaluationGas,
             blobConfig: {
                 blobs: encodedData.blobs.map((b)=>b.data),
                 kzg
             },
-            onResult: (request, result)=>{
+            checkSuccess: (_request, result)=>{
                 if (!result) {
-                    return;
+                    return false;
                 }
                 const { receipt, stats, errorMsg } = result;
-                if (receipt.status === 'success') {
+                const success = extractEventSuccess(receipt, {
+                    address: this.rollupContract.address,
+                    abi: RollupAbi,
+                    eventName: 'CheckpointProposed'
+                });
+                if (success) {
                     const endBlock = receipt.blockNumber;
                     const inclusionBlocks = Number(endBlock - startBlock);
+                    const { calldataGas, calldataSize, sender } = stats;
                     const publishStats = {
                         gasPrice: receipt.effectiveGasPrice,
                         gasUsed: receipt.gasUsed,
                         blobGasUsed: receipt.blobGasUsed ?? 0n,
                         blobDataGas: receipt.blobGasPrice ?? 0n,
                         transactionHash: receipt.transactionHash,
-                        ...pick(stats, 'calldataGas', 'calldataSize', 'sender'),
-                        ...block.getStats(),
+                        calldataGas,
+                        calldataSize,
+                        sender,
+                        ...checkpoint.getStats(),
                         eventName: 'rollup-published-to-l1',
                         blobCount: encodedData.blobs.length,
                         inclusionBlocks
                     };
-                    this.log.verbose(`Published L2 block to L1 rollup contract`, {
+                    this.log.info(`Published checkpoint ${checkpoint.number} at slot ${slot} to rollup contract`, {
                         ...stats,
-                        ...block.getStats()
+                        ...checkpoint.getStats(),
+                        ...pick(receipt, 'transactionHash', 'blockHash')
                     });
                     this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
-                    // Send the blobs to the blob sink
-                    this.sendBlobsToBlobSink(receipt.blockHash, encodedData.blobs).catch((_err)=>{
-                        this.log.error('Failed to send blobs to blob sink');
-                    });
                     return true;
                 } else {
                     this.metrics.recordFailedTx('process');
-                    this.log.error(`Rollup process tx reverted. ${errorMsg ?? 'No error message'}`, undefined, {
-                        ...block.getStats(),
-                        txHash: receipt.transactionHash,
-                        blockHash,
-                        slotNumber: block.header.globalVariables.slotNumber.toBigInt()
+                    this.log.error(`Publishing checkpoint at slot ${slot} failed with ${errorMsg ?? 'no error message'}`, undefined, {
+                        ...checkpoint.getStats(),
+                        ...receipt
                     });
+                    return false;
                 }
             }
         });
     }
-    /**
-   * Send blobs to the blob sink
-   *
-   * If a blob sink url is configured, then we send blobs to the blob sink
-   * - for now we use the blockHash as the identifier for the blobs;
-   *   In the future this will move to be the beacon block id - which takes a bit more work
-   *   to calculate and will need to be mocked in e2e tests
-   */ sendBlobsToBlobSink(blockHash, blobs) {
-        return this.blobSinkClient.sendBlobsToBlobSink(blockHash, blobs);
+    /** Returns the timestamp of the next L1 slot boundary after now. */ getNextL1SlotTimestamp() {
+        const l1Constants = this.epochCache.getL1Constants();
+        return getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), l1Constants);
     }
 }