@aztec/sequencer-client 0.0.1-commit.9593d84 → 0.0.1-commit.967fc6998

package/dest/publisher/sequencer-publisher.js

@@ -1,19 +1,397 @@
+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, _dec2, _initProto;
 import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { FormattedViemError, MULTI_CALL_3_ADDRESS, Multicall3, RollupContract, WEI_CONST, formatViemError, tryExtractEvent } from '@aztec/ethereum';
+import { FeeAssetPriceOracle, MULTI_CALL_3_ADDRESS, Multicall3, RollupContract } 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, tryExtractEvent } from '@aztec/ethereum/utils';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
-import { SlotNumber } from '@aztec/foundation/branded-types';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { bufferToHex } from '@aztec/foundation/string';
 import { Timer } from '@aztec/foundation/timer';
 import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { encodeSlashConsensusVotes } from '@aztec/slasher';
-import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { encodeFunctionData, toHex } from 'viem';
+import { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { encodeFunctionData, keccak256, multicall3Abi, toHex } from 'viem';
+import { createL1TxFailedStore } from './l1_tx_failed_store/index.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 export const Actions = [
     'invalidate-by-invalid-attestation',
@@ -28,22 +406,43 @@ export const Actions = [
 ];
 // 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');
 export class SequencerPublisher {
     config;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "sendRequests"
+            ],
+            [
+                _dec1,
+                2,
+                "validateBlockHeader"
+            ],
+            [
+                _dec2,
+                2,
+                "validateCheckpointForSubmission"
+            ]
+        ], []));
+    }
     interrupted;
     metrics;
     epochCache;
+    failedTxStore;
     governanceLog;
     slashingLog;
     lastActions;
+    isPayloadEmptyCache;
+    payloadProposedCache;
     log;
     ethereumSlotDuration;
-    blobSinkClient;
+    blobClient;
     /** Address to use for simulations in fisherman mode (actual proposer's address) */ proposerAddressForSimulation;
-    // @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;
+    /** L1 fee analyzer for fisherman mode */ l1FeeAnalyzer;
+    /** Fee asset price oracle for computing price modifiers from Uniswap V4 */ feeAssetPriceOracle;
     // 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
@@ -53,23 +452,25 @@ export class SequencerPublisher {
     govProposerContract;
     slashingProposerContract;
     slashFactoryContract;
+    tracer;
     requests;
     constructor(config, deps){
         this.config = config;
-        this.interrupted = false;
+        this.interrupted = (_initProto(this), false);
         this.governanceLog = createLogger('sequencer:publisher:governance');
         this.slashingLog = createLogger('sequencer:publisher:slashing');
         this.lastActions = {};
+        this.isPayloadEmptyCache = new Map();
+        this.payloadProposedCache = new Set();
         this.requests = [];
         this.log = deps.log ?? createLogger('sequencer:publisher');
         this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
         this.epochCache = deps.epochCache;
         this.lastActions = deps.lastActions;
-        this.blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config, {
-            logger: createLogger('sequencer:blob-sink:client')
-        });
+        this.blobClient = deps.blobClient;
         const telemetry = deps.telemetry ?? getTelemetryClient();
         this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
+        this.tracer = telemetry.getTracer('SequencerPublisher');
         this.l1TxUtils = deps.l1TxUtils;
         this.rollupContract = deps.rollupContract;
         this.govProposerContract = deps.governanceProposerContract;
@@ -80,14 +481,49 @@ export class SequencerPublisher {
             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'));
+        }
+        // Initialize fee asset price oracle
+        this.feeAssetPriceOracle = new FeeAssetPriceOracle(this.l1TxUtils.client, this.rollupContract, createLogger('sequencer:publisher:price-oracle'));
+        // Initialize failed L1 tx store (optional, for test networks)
+        this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
+    }
+    /**
+   * 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);
+        });
     }
     getRollupContract() {
         return this.rollupContract;
     }
+    /**
+   * Gets the fee asset price modifier from the oracle.
+   * Returns 0n if the oracle query fails.
+   */ getFeeAssetPriceModifier() {
+        return this.feeAssetPriceOracle.computePriceModifier();
+    }
     getSenderAddress() {
         return this.l1TxUtils.getSenderAddress();
     }
     /**
+   * Gets the L1 fee analyzer instance (only available in fisherman mode)
+   */ 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) {
@@ -109,6 +545,46 @@ export class SequencerPublisher {
         }
     }
     /**
+   * 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.
    * @returns one of:
    * - A receipt and stats if the tx succeeded
@@ -119,7 +595,7 @@ export class SequencerPublisher {
             ...this.requests
         ];
         this.requests = [];
-        if (this.interrupted) {
+        if (this.interrupted || requestsToProcess.length === 0) {
             return undefined;
         }
         const currentL2Slot = this.getCurrentL2Slot();
@@ -154,7 +630,16 @@ export class SequencerPublisher {
         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
+        let gasLimit = gasLimits.length > 0 ? sumBigint(gasLimits) : undefined; // sum
+        // Cap at L1 block gas limit so the node accepts the tx ("gas limit too high" otherwise).
+        const maxGas = MAX_L1_TX_LIMIT;
+        if (gasLimit !== undefined && gasLimit > maxGas) {
+            this.log.debug('Capping bundled tx gas limit to L1 max', {
+                requested: gasLimit,
+                capped: maxGas
+            });
+            gasLimit = maxGas;
+        }
         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 = {
@@ -165,12 +650,31 @@ export class SequencerPublisher {
         // This ensures the committee gets precomputed correctly
         validRequests.sort((a, b)=>compareActions(a.action, b.action));
         try {
+            // Capture context for failed tx backup before sending
+            const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+            const multicallData = encodeFunctionData({
+                abi: multicall3Abi,
+                functionName: 'aggregate3',
+                args: [
+                    validRequests.map((r)=>({
+                            target: r.request.to,
+                            callData: r.request.data,
+                            allowFailure: true
+                        }))
+                ]
+            });
+            const blobDataHex = blobConfig?.blobs?.map((b)=>toHex(b));
             this.log.debug('Forwarding transactions', {
                 validRequests: validRequests.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 txContext = {
+                multicallData,
+                blobData: blobDataHex,
+                l1BlockNumber
+            };
+            const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result, txContext);
             return {
                 result,
                 expiredActions,
@@ -190,10 +694,33 @@ export class SequencerPublisher {
             }
         }
     }
-    callbackBundledTransactions(requests, result) {
+    callbackBundledTransactions(requests, result, txContext) {
         const actionsListStr = requests.map((r)=>r.action).join(', ');
         if (result instanceof FormattedViemError) {
             this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
+            this.backupFailedTx({
+                id: keccak256(txContext.multicallData),
+                failureType: 'send-error',
+                request: {
+                    to: MULTI_CALL_3_ADDRESS,
+                    data: txContext.multicallData
+                },
+                blobData: txContext.blobData,
+                l1BlockNumber: txContext.l1BlockNumber.toString(),
+                error: {
+                    message: result.message,
+                    name: result.name
+                },
+                context: {
+                    actions: requests.map((r)=>r.action),
+                    requests: requests.map((r)=>({
+                            action: r.action,
+                            to: r.request.to,
+                            data: r.request.data
+                        })),
+                    sender: this.getSenderAddress().toString()
+                }
+            });
             return {
                 failedActions: requests.map((r)=>r.action)
             };
@@ -211,6 +738,37 @@ export class SequencerPublisher {
                     failedActions.push(request.action);
                 }
             }
+            // Single backup for the whole reverted tx
+            if (failedActions.length > 0 && result?.receipt?.status === 'reverted') {
+                this.backupFailedTx({
+                    id: result.receipt.transactionHash,
+                    failureType: 'revert',
+                    request: {
+                        to: MULTI_CALL_3_ADDRESS,
+                        data: txContext.multicallData
+                    },
+                    blobData: txContext.blobData,
+                    l1BlockNumber: result.receipt.blockNumber.toString(),
+                    receipt: {
+                        transactionHash: result.receipt.transactionHash,
+                        blockNumber: result.receipt.blockNumber.toString(),
+                        gasUsed: (result.receipt.gasUsed ?? 0n).toString(),
+                        status: 'reverted'
+                    },
+                    error: {
+                        message: result.errorMsg ?? 'Transaction reverted'
+                    },
+                    context: {
+                        actions: failedActions,
+                        requests: requests.filter((r)=>failedActions.includes(r.action)).map((r)=>({
+                                action: r.action,
+                                to: r.request.to,
+                                data: r.request.data
+                            })),
+                        sender: this.getSenderAddress().toString()
+                    }
+                });
+            }
             return {
                 successfulActions,
                 failedActions
@@ -229,7 +787,7 @@ export class SequencerPublisher {
             'InvalidArchive'
         ];
         return this.rollupContract.canProposeAtNextEthBlock(tipArchive.toBuffer(), msgSender.toString(), Number(this.ethereumSlotDuration), {
-            forcePendingCheckpointNumber: opts.forcePendingBlockNumber
+            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))}`, {
@@ -257,11 +815,11 @@ export class SequencerPublisher {
             [],
             Signature.empty().toViemSignature(),
             `0x${'0'.repeat(64)}`,
-            header.contentCommitment.blobsHash.toString(),
+            header.blobsHash.toString(),
             flags
         ];
         const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-        const stateOverrides = await this.rollupContract.makePendingCheckpointNumberOverride(opts?.forcePendingBlockNumber);
+        const stateOverrides = await this.rollupContract.makePendingCheckpointNumberOverride(opts?.forcePendingCheckpointNumber);
         let balance = 0n;
         if (this.config.fishermanMode) {
             // In fisherman mode, we can't know where the proposer is publishing from
@@ -288,34 +846,38 @@ export class SequencerPublisher {
         this.log.debug(`Simulated validateHeader`);
     }
     /**
-   * Simulate making a call to invalidate a block with invalid attestations. Returns undefined if no need to invalidate.
-   * @param block - The block to invalidate and the criteria for invalidation (as returned by the archiver)
-   */ async simulateInvalidateBlock(validationResult) {
+   * 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, block } = validationResult;
-        const blockNumber = block.blockNumber;
+        const { reason, checkpoint } = validationResult;
+        const checkpointNumber = checkpoint.checkpointNumber;
         const logData = {
-            ...block,
+            ...checkpoint,
             reason
         };
-        const currentBlockNumber = await this.rollupContract.getCheckpointNumber();
-        if (currentBlockNumber < validationResult.block.blockNumber) {
-            this.log.verbose(`Skipping block ${blockNumber} invalidation since it has already been removed from the pending chain`, {
-                currentBlockNumber,
+        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.buildInvalidateBlockRequest(validationResult);
-        this.log.debug(`Simulating invalidate block ${blockNumber}`, {
+        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, ErrorsAbi);
-            this.log.verbose(`Simulation for invalidate block ${blockNumber} succeeded`, {
+            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
@@ -323,90 +885,92 @@ export class SequencerPublisher {
             return {
                 request,
                 gasUsed,
-                blockNumber,
-                forcePendingBlockNumber: blockNumber - 1,
+                checkpointNumber,
+                forcePendingCheckpointNumber: CheckpointNumber(checkpointNumber - 1),
                 reason
             };
         } catch (err) {
             const viemError = formatViemError(err);
-            // If the error is due to the block 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 block building.
-            if (viemError.message?.includes('Rollup__BlockNotInPendingChain')) {
-                this.log.verbose(`Simulation for invalidate block ${blockNumber} failed due to block not being in pending chain`, {
+            // 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 latestPendingBlockNumber = await this.rollupContract.getCheckpointNumber();
-                if (latestPendingBlockNumber < blockNumber) {
-                    this.log.verbose(`Block number ${blockNumber} has already been invalidated`, {
+                const latestPendingCheckpointNumber = await this.rollupContract.getCheckpointNumber();
+                if (latestPendingCheckpointNumber < checkpointNumber) {
+                    this.log.verbose(`Checkpoint ${checkpointNumber} has already been invalidated`, {
                         ...logData
                     });
                     return undefined;
                 } else {
-                    this.log.error(`Simulation for invalidate ${blockNumber} failed and it is still in pending chain`, viemError, logData);
-                    throw new Error(`Failed to simulate invalidate block ${blockNumber} while it is still in pending chain`, {
+                    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 block if we cannot invalidate the previous one.
-            this.log.error(`Simulation for invalidate block ${blockNumber} failed`, viemError, logData);
-            throw new Error(`Failed to simulate invalidate block ${blockNumber}`, {
+            // 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
             });
         }
     }
-    buildInvalidateBlockRequest(validationResult) {
+    buildInvalidateCheckpointRequest(validationResult) {
         if (validationResult.valid) {
-            throw new Error('Cannot invalidate a valid block');
+            throw new Error('Cannot invalidate a valid checkpoint');
         }
-        const { block, committee, reason } = validationResult;
+        const { checkpoint, committee, reason } = validationResult;
         const logData = {
-            ...block,
+            ...checkpoint,
             reason
         };
-        this.log.debug(`Simulating invalidate block ${block.blockNumber}`, logData);
+        this.log.debug(`Building invalidate checkpoint ${checkpoint.checkpointNumber} request`, logData);
         const attestationsAndSigners = new CommitteeAttestationsAndSigners(validationResult.attestations).getPackedAttestations();
         if (reason === 'invalid-attestation') {
-            return this.rollupContract.buildInvalidateBadAttestationRequest(block.blockNumber, attestationsAndSigners, committee, validationResult.invalidIndex);
+            return this.rollupContract.buildInvalidateBadAttestationRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee, validationResult.invalidIndex);
         } else if (reason === 'insufficient-attestations') {
-            return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(block.blockNumber, attestationsAndSigners, committee);
+            return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee);
         } else {
             const _ = reason;
             throw new Error(`Unknown reason for invalidation`);
         }
     }
-    /**
-   * @notice  Will simulate `propose` to make sure that the block is valid for submission
-   *
-   * @dev     Throws if unable to propose
-   *
-   * @param block - The block to propose
-   * @param attestationData - The block's attestation data
-   *
-   */ async validateBlockForSubmission(block, attestationsAndSigners, attestationsAndSignersSignature, options) {
+    /** 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);
-        // 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 = block.getCheckpointBlobFields();
-        const blobs = getBlobsPerL1Block(blobFields);
+        const blobFields = checkpoint.toBlobFields();
+        const blobs = await getBlobsPerL1Block(blobFields);
         const blobInput = getPrefixedEthBlobCommitments(blobs);
         const args = [
             {
-                header: block.getCheckpointHeader().toViem(),
-                archive: toHex(block.archive.root.toBuffer()),
+                header: checkpoint.header.toViem(),
+                archive: toHex(checkpoint.archive.root.toBuffer()),
                 oracleInput: {
-                    feeAssetPriceModifier: 0n
+                    feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
                 }
             },
             attestationsAndSigners.getPackedAttestations(),
@@ -431,9 +995,38 @@ export class SequencerPublisher {
         }
         const round = await base.computeRound(slotNumber);
         const roundInfo = await base.getRoundInfo(this.rollupContract.address, round);
+        if (roundInfo.quorumReached) {
+            return false;
+        }
         if (roundInfo.lastSignalSlot >= slotNumber) {
             return false;
         }
+        if (await this.isPayloadEmpty(payload)) {
+            this.log.warn(`Skipping vote cast for payload with empty code`);
+            return false;
+        }
+        // Check if payload was already submitted to governance
+        const cacheKey = payload.toString();
+        if (!this.payloadProposedCache.has(cacheKey)) {
+            try {
+                const l1StartBlock = await this.rollupContract.getL1StartBlock();
+                const proposed = await retry(()=>base.hasPayloadBeenProposed(payload.toString(), l1StartBlock), 'Check if payload was proposed', makeBackoff([
+                    0,
+                    1,
+                    2
+                ]), this.log, true);
+                if (proposed) {
+                    this.payloadProposedCache.add(cacheKey);
+                }
+            } catch (err) {
+                this.log.warn(`Failed to check if payload ${payload} was proposed after retries, skipping signal`, err);
+                return false;
+            }
+        }
+        if (this.payloadProposedCache.has(cacheKey)) {
+            this.log.info(`Payload ${payload} was already proposed to governance, stopping signals`);
+            return false;
+        }
         const cachedLastVote = this.lastActions[signalType];
         this.lastActions[signalType] = slotNumber;
         const action = signalType;
@@ -444,15 +1037,41 @@ export class SequencerPublisher {
             signer: this.l1TxUtils.client.account?.address,
             lastValidL2Slot: slotNumber
         });
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
         try {
             await this.l1TxUtils.simulate(request, {
                 time: timestamp
-            }, [], ErrorsAbi);
+            }, [], mergeAbis([
+                request.abi ?? [],
+                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);
+            const viemError = formatViemError(err);
+            this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, viemError);
+            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: [
+                        action
+                    ],
+                    slot: slotNumber,
+                    sender: this.getSenderAddress().toString()
+                }
+            });
         // 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.
@@ -472,17 +1091,27 @@ export class SequencerPublisher {
                     payload: payload.toString()
                 };
                 if (!success) {
-                    this.log.error(`Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} failed`, logData);
+                    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(`Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} succeeded`, logData);
+                    this.log.info(`Signaling in ${action} for ${payload} at slot ${slotNumber} in round ${round} succeeded`, logData);
                     return true;
                 }
             }
         });
         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.
@@ -578,22 +1207,17 @@ export class SequencerPublisher {
         }
         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, attestationsAndSigners, attestationsAndSignersSignature, opts = {}) {
-        const checkpointHeader = block.getCheckpointHeader();
-        const blobFields = block.getCheckpointBlobFields();
-        const blobs = getBlobsPerL1Block(blobFields);
+    /** Simulates and 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: checkpointHeader,
-            archive: block.archive.root.toBuffer(),
-            body: block.body.toBuffer(),
+            archive: checkpoint.archive.root.toBuffer(),
             blobs,
             attestationsAndSigners,
-            attestationsAndSignersSignature
+            attestationsAndSignersSignature,
+            feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
         };
         let ts;
         try {
@@ -602,36 +1226,35 @@ export class SequencerPublisher {
             //        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.validateBlockForSubmission(block, attestationsAndSigners, attestationsAndSignersSignature, opts);
+            ts = await this.validateCheckpointForSubmission(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, opts);
         } catch (err) {
-            this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
-                ...block.getStats(),
-                slotNumber: block.header.globalVariables.slotNumber,
-                forcePendingBlockNumber: opts.forcePendingBlockNumber
+            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 block propose transaction`, {
-            ...block.toBlockInfo(),
+        this.log.verbose(`Enqueuing checkpoint propose transaction`, {
+            ...checkpoint.toCheckpointInfo(),
             ...opts
         });
-        await this.addProposeTx(block, proposeTxArgs, opts, ts);
-        return true;
+        await this.addProposeTx(checkpoint, proposeTxArgs, opts, ts);
     }
-    enqueueInvalidateBlock(request, opts = {}) {
+    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, blockNumber } = request;
+        const { gasUsed, checkpointNumber } = request;
         const logData = {
             gasUsed,
-            blockNumber,
+            checkpointNumber,
             gasLimit,
             opts
         };
-        this.log.verbose(`Enqueuing invalidate block request`, logData);
+        this.log.verbose(`Enqueuing invalidate checkpoint request`, logData);
         this.addRequest({
             action: `invalidate-by-${request.reason}`,
             request: request.request,
@@ -643,12 +1266,12 @@ export class SequencerPublisher {
             checkSuccess: (_req, result)=>{
                 const success = result && result.receipt && result.receipt.status === 'success' && tryExtractEvent(result.receipt.logs, this.rollupContract.address, RollupAbi, 'CheckpointInvalidated');
                 if (!success) {
-                    this.log.warn(`Invalidate block ${request.blockNumber} failed`, {
+                    this.log.warn(`Invalidate checkpoint ${request.checkpointNumber} failed`, {
                         ...result,
                         ...logData
                     });
                 } else {
-                    this.log.info(`Invalidate block ${request.blockNumber} succeeded`, {
+                    this.log.info(`Invalidate checkpoint ${request.checkpointNumber} succeeded`, {
                         ...result,
                         ...logData
                     });
@@ -670,28 +1293,60 @@ export class SequencerPublisher {
         const cachedLastActionSlot = this.lastActions[action];
         this.lastActions[action] = slotNumber;
         this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
         let gasUsed;
+        const simulateAbi = mergeAbis([
+            request.abi ?? [],
+            ErrorsAbi
+        ]);
         try {
             ({ gasUsed } = await this.l1TxUtils.simulate(request, {
                 time: timestamp
-            }, [], ErrorsAbi)); // TODO(palla/slash): Check the timestamp logic
+            }, [], simulateAbi)); // TODO(palla/slash): Check the timestamp logic
             this.log.verbose(`Simulation for ${action} succeeded`, {
                 ...logData,
                 request,
                 gasUsed
             });
         } catch (err) {
-            const viemError = formatViemError(err);
+            const viemError = formatViemError(err, simulateAbi);
             this.log.error(`Simulation for ${action} at ${slotNumber} 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: [
+                        action
+                    ],
+                    slot: slotNumber,
+                    sender: this.getSenderAddress().toString()
+                }
+            });
             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;
+        // Store the ABI used for simulation on the request so Multicall3.forward can decode errors
+        // when the tx is sent and a revert is diagnosed via simulation.
+        const requestWithAbi = {
+            ...request,
+            abi: simulateAbi
+        };
         this.log.debug(`Enqueuing ${action}`, logData);
         this.addRequest({
             action,
-            request,
+            request: requestWithAbi,
             gasConfig: {
                 gasLimit
             },
@@ -755,10 +1410,38 @@ 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: l1BlockNumber.toString(),
+                    error: {
+                        message: viemError.message,
+                        name: viemError.name
+                    },
+                    context: {
+                        actions: [
+                            'validate-blobs'
+                        ],
+                        sender: this.getSenderAddress().toString()
+                    }
                 });
                 throw new Error('Failed to validate blobs');
             });
@@ -769,8 +1452,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(),
@@ -797,8 +1479,8 @@ export class SequencerPublisher {
             functionName: 'propose',
             args
         });
-        // override the pending block number if requested
-        const forcePendingBlockNumberStateDiff = (options.forcePendingBlockNumber !== undefined ? await this.rollupContract.makePendingCheckpointNumberOverride(options.forcePendingBlockNumber) : []).flatMap((override)=>override.stateDiff ?? []);
+        // 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,
@@ -808,7 +1490,7 @@ export class SequencerPublisher {
                         slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true),
                         value: toPaddedHex(0n, true)
                     },
-                    ...forcePendingBlockNumberStateDiff
+                    ...forcePendingCheckpointNumberStateDiff
                 ]
             }
         ];
@@ -819,10 +1501,11 @@ export class SequencerPublisher {
                 balance: 10n * WEI_CONST * WEI_CONST
             });
         }
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
         const simulationResult = await this.l1TxUtils.simulate({
             to: this.rollupContract.address,
             data: rollupData,
-            gas: SequencerPublisher.PROPOSE_GAS_GUESS,
+            gas: MAX_L1_TX_LIMIT,
             ...this.proposerAddressForSimulation && {
                 from: this.proposerAddressForSimulation.toString()
             }
@@ -830,10 +1513,10 @@ export class SequencerPublisher {
             // @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
+            gasLimit: MAX_L1_TX_LIMIT * 2n
         }, stateOverrides, RollupAbi, {
             // @note fallback gas estimate to use if the node doesn't support simulation API
-            fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS
+            fallbackGasEstimate: MAX_L1_TX_LIMIT
         }).catch((err)=>{
             // In fisherman mode, we expect ValidatorSelection__MissingProposerSignature since fisherman doesn't have proposer signature
             const viemError = formatViemError(err);
@@ -841,11 +1524,31 @@ export class SequencerPublisher {
                 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,
+                    gasUsed: MAX_L1_TX_LIMIT,
                     logs: []
                 };
             }
             this.log.error(`Failed to simulate propose tx`, viemError);
+            this.backupFailedTx({
+                id: keccak256(rollupData),
+                failureType: 'simulation',
+                request: {
+                    to: this.rollupContract.address,
+                    data: rollupData
+                },
+                l1BlockNumber: l1BlockNumber.toString(),
+                error: {
+                    message: viemError.message,
+                    name: viemError.name
+                },
+                context: {
+                    actions: [
+                        'propose'
+                    ],
+                    slot: Number(args[0].header.slotNumber),
+                    sender: this.getSenderAddress().toString()
+                }
+            });
             throw err;
         });
         return {
@@ -853,24 +1556,25 @@ export class SequencerPublisher {
             simulationResult
         };
     }
-    async addProposeTx(block, encodedData, opts = {}, timestamp) {
+    async addProposeTx(checkpoint, encodedData, opts = {}, timestamp) {
+        const slot = checkpoint.header.slotNumber;
         const timer = new Timer();
         const kzg = Blob.getViemKzgInstance();
         const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp, opts);
         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 sink 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 sink regardless of the tx outcome.
-        void this.blobSinkClient.sendBlobsToBlobSink(encodedData.blobs).catch((_err)=>{
-            this.log.error('Failed to send blobs to blob sink');
-        });
+        // 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,
+            lastValidL2Slot: checkpoint.header.slotNumber,
             gasConfig: {
                 ...opts,
                 gasLimit
@@ -898,25 +1602,23 @@ export class SequencerPublisher {
                         calldataGas,
                         calldataSize,
                         sender,
-                        ...block.getStats(),
+                        ...checkpoint.getStats(),
                         eventName: 'rollup-published-to-l1',
                         blobCount: encodedData.blobs.length,
                         inclusionBlocks
                     };
-                    this.log.info(`Published L2 block to L1 rollup contract`, {
+                    this.log.info(`Published checkpoint ${checkpoint.number} at slot ${slot} to rollup contract`, {
                         ...stats,
-                        ...block.getStats(),
-                        ...receipt
+                        ...checkpoint.getStats(),
+                        ...pick(receipt, 'transactionHash', 'blockHash')
                     });
                     this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
                     return true;
                 } else {
                     this.metrics.recordFailedTx('process');
-                    this.log.error(`Rollup process tx failed: ${errorMsg ?? 'no error message'}`, undefined, {
-                        ...block.getStats(),
-                        receipt,
-                        txHash: receipt.transactionHash,
-                        slotNumber: block.header.globalVariables.slotNumber
+                    this.log.error(`Publishing checkpoint at slot ${slot} failed with ${errorMsg ?? 'no error message'}`, undefined, {
+                        ...checkpoint.getStats(),
+                        ...receipt
                     });
                     return false;
                 }