@aztec/sequencer-client 0.0.1-commit.e6bd8901 → 0.0.1-commit.ec5f612

package/dest/publisher/sequencer-publisher.js

@@ -372,10 +372,10 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 }
 var _dec, _dec1, _dec2, _initProto;
 import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
-import { MULTI_CALL_3_ADDRESS, Multicall3, RollupContract } from '@aztec/ethereum/contracts';
+import { FeeAssetPriceOracle, MULTI_CALL_3_ADDRESS, Multicall3, RollupContract } from '@aztec/ethereum/contracts';
 import { L1FeeAnalyzer } from '@aztec/ethereum/l1-fee-analysis';
-import { WEI_CONST } from '@aztec/ethereum/l1-tx-utils';
-import { FormattedViemError, formatViemError, tryExtractEvent } from '@aztec/ethereum/utils';
+import { 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 { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
@@ -383,13 +383,15 @@ 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 { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
 import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { encodeFunctionData, toHex } from 'viem';
+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',
@@ -429,19 +431,18 @@ export class SequencerPublisher {
     interrupted;
     metrics;
     epochCache;
+    failedTxStore;
     governanceLog;
     slashingLog;
     lastActions;
     isPayloadEmptyCache;
+    payloadProposedCache;
     log;
     ethereumSlotDuration;
     blobClient;
     /** Address to use for simulations in fisherman mode (actual proposer's address) */ proposerAddressForSimulation;
     /** L1 fee analyzer for fisherman mode */ l1FeeAnalyzer;
-    // @note - with blobs, the below estimate seems too large.
-    // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
-    // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
-    static PROPOSE_GAS_GUESS = 12_000_000n;
+    /** 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
@@ -460,6 +461,7 @@ export class SequencerPublisher {
         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);
@@ -483,10 +485,36 @@ export class SequencerPublisher {
         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();
     }
@@ -544,7 +572,7 @@ export class SequencerPublisher {
         // Get the transaction requests
         const l1Requests = requestsToAnalyze.map((r)=>r.request);
         // Start the analysis
-        const analysisId = await this.l1FeeAnalyzer.startAnalysis(l2SlotNumber, gasLimit > 0n ? gasLimit : SequencerPublisher.PROPOSE_GAS_GUESS, l1Requests, blobConfig, onComplete);
+        const analysisId = await this.l1FeeAnalyzer.startAnalysis(l2SlotNumber, gasLimit > 0n ? gasLimit : MAX_L1_TX_LIMIT, l1Requests, blobConfig, onComplete);
         this.log.info('Started L1 fee analysis', {
             analysisId,
             l2SlotNumber: l2SlotNumber.toString(),
@@ -602,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 = {
@@ -613,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,
@@ -638,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)
             };
@@ -659,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
@@ -761,8 +871,12 @@ export class SequencerPublisher {
             ...logData,
             request
         });
+        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
         try {
-            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, ErrorsAbi);
+            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, mergeAbis([
+                request.abi ?? [],
+                ErrorsAbi
+            ]));
             this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} succeeded`, {
                 ...logData,
                 request,
@@ -779,7 +893,7 @@ export class SequencerPublisher {
             const viemError = formatViemError(err);
             // If the error is due to the checkpoint not being in the pending chain, and it was indeed removed by someone else,
             // we can safely ignore it and return undefined so we go ahead with checkpoint building.
-            if (viemError.message?.includes('Rollup__BlockNotInPendingChain')) {
+            if (viemError.message?.includes('Rollup__CheckpointNotInPendingChain')) {
                 this.log.verbose(`Simulation for invalidate checkpoint ${checkpointNumber} failed due to checkpoint not being in pending chain`, {
                     ...logData,
                     request,
@@ -800,6 +914,27 @@ export class SequencerPublisher {
             }
             // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
             this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
+            this.backupFailedTx({
+                id: keccak256(request.data),
+                failureType: 'simulation',
+                request: {
+                    to: request.to,
+                    data: request.data,
+                    value: request.value?.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
             });
@@ -827,29 +962,15 @@ export class SequencerPublisher {
     }
     /** Simulates `propose` to make sure that the checkpoint is valid for submission */ async validateCheckpointForSubmission(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, options) {
         const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
-        // TODO(palla/mbps): This should not be needed, there's no flow where we propose with zero attestations. Or is there?
-        // If we have no attestations, we still need to provide the empty attestations
-        // so that the committee is recalculated correctly
-        // const ignoreSignatures = attestationsAndSigners.attestations.length === 0;
-        // if (ignoreSignatures) {
-        //   const { committee } = await this.epochCache.getCommittee(block.header.globalVariables.slotNumber);
-        //   if (!committee) {
-        //     this.log.warn(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-        //     throw new Error(`No committee found for slot ${block.header.globalVariables.slotNumber}`);
-        //   }
-        //   attestationsAndSigners.attestations = committee.map(committeeMember =>
-        //     CommitteeAttestation.fromAddress(committeeMember),
-        //   );
-        // }
         const blobFields = checkpoint.toBlobFields();
-        const blobs = getBlobsPerL1Block(blobFields);
+        const blobs = await getBlobsPerL1Block(blobFields);
         const blobInput = getPrefixedEthBlobCommitments(blobs);
         const args = [
             {
                 header: checkpoint.header.toViem(),
                 archive: toHex(checkpoint.archive.root.toBuffer()),
                 oracleInput: {
-                    feeAssetPriceModifier: 0n
+                    feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
                 }
             },
             attestationsAndSigners.getPackedAttestations(),
@@ -884,6 +1005,28 @@ export class SequencerPublisher {
             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;
@@ -894,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.
@@ -1041,13 +1210,14 @@ export class SequencerPublisher {
     /** 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 = getBlobsPerL1Block(blobFields);
+        const blobs = await getBlobsPerL1Block(blobFields);
         const proposeTxArgs = {
             header: checkpointHeader,
             archive: checkpoint.archive.root.toBuffer(),
             blobs,
             attestationsAndSigners,
-            attestationsAndSignersSignature
+            attestationsAndSignersSignature,
+            feeAssetPriceModifier: checkpoint.feeAssetPriceModifier
         };
         let ts;
         try {
@@ -1123,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
             },
@@ -1208,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');
             });
@@ -1222,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(),
@@ -1272,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()
             }
@@ -1283,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);
@@ -1294,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 {