@aztec/sequencer-client 0.0.1-commit.a5db02d → 0.0.1-commit.aa0c64f

package/dest/publisher/sequencer-publisher.js

@@ -373,8 +373,8 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 var _dec, _dec1, _initProto;
 import { Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
 import { FeeAssetPriceOracle, MULTI_CALL_3_ADDRESS, Multicall3, MulticallForwarderRevertedError, buildSimulationOverridesStateOverride } from '@aztec/ethereum/contracts';
-import { L1FeeAnalyzer } from '@aztec/ethereum/l1-fee-analysis';
-import { MAX_L1_TX_LIMIT, WEI_CONST } from '@aztec/ethereum/l1-tx-utils';
+import { L1FeeAnalyzer, captureWindowBlockFees } from '@aztec/ethereum/l1-fee-analysis';
+import { L1TxTimeoutError, MAX_L1_TX_LIMIT, WEI_CONST } from '@aztec/ethereum/l1-tx-utils';
 import { FormattedViemError, formatViemError, mergeAbis, tryDecodeRevertReason, tryExtractEvent } from '@aztec/ethereum/utils';
 import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { trimmedBytesLength } from '@aztec/foundation/buffer';
@@ -512,20 +512,87 @@ export class SequencerPublisher {
         });
     }
     /**
-   * 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;
-        }
+   * Logs the gas-pricing data of a failed L1 transaction at warn — so underpricing is diagnosable
+   * from logs even with no failed-tx store configured — and backs the record up to the store when
+   * one is. When captureFeeSummary is true, also records the fee data of the already-mined L1
+   * blocks in the target slot's inclusion window.
+   */ backupFailedTx(failedTx, opts) {
         const tx = {
             ...failedTx,
             timestamp: Date.now()
         };
         // Fire and forget - don't block on backup
-        void this.failedTxStore.then((store)=>store?.saveFailedTx(tx)).catch((err)=>{
-            this.log.warn(`Failed to backup failed L1 tx to store`, err);
-        });
+        void (async ()=>{
+            try {
+                // Prefer a pre-captured summary (shared across a batch of failures in the same slot) so we
+                // don't re-read the fee window per record. A capture error must not lose the record itself.
+                const feeSummary = opts?.sharedFeeSummary ?? (opts?.captureFeeSummary ? await this.captureFeeEnvironment(opts.targetSlot).catch(()=>undefined) : undefined);
+                if (feeSummary) {
+                    tx.gasInfo = {
+                        ...tx.gasInfo,
+                        ...feeSummary
+                    };
+                }
+                if (tx.gasInfo) {
+                    this.log.warn(`Gas pricing data for failed L1 tx (${tx.failureType})`, {
+                        failureType: tx.failureType,
+                        actions: tx.context.actions,
+                        slot: tx.context.slot,
+                        ...tx.gasInfo,
+                        ...tx.timing
+                    });
+                }
+                const store = await this.failedTxStore;
+                if (store) {
+                    await store.saveFailedTx(tx);
+                }
+            } catch (err) {
+                this.log.warn(`Failed to backup failed L1 tx to store`, err);
+            }
+        })();
+    }
+    /**
+   * Captures per-block fee data for the L1 blocks in the target slot's inclusion window (the blocks the
+   * tx could have landed in) for underpricing diagnostics. Reads only already-mined blocks, so it never
+   * waits on the chain. Safe to call off the critical path: the underlying capture never throws, and this
+   * returns undefined when there is no target slot or the window is not yet mined (e.g. an early send
+   * failure), in which case the record simply carries no window data.
+   */ async captureFeeEnvironment(targetL2Slot) {
+        if (targetL2Slot === undefined) {
+            return undefined;
+        }
+        const l1Constants = this.epochCache.getL1Constants();
+        // The inclusion window is [start of slot N, start of slot N+1): all L1 blocks that can include a tx
+        // for this L2 slot. getTimestampForSlot returns seconds, matching block.timestamp.
+        const windowStartS = getTimestampForSlot(targetL2Slot, l1Constants);
+        const windowEndS = getTimestampForSlot(SlotNumber(Number(targetL2Slot) + 1), l1Constants);
+        const windowBlocks = await captureWindowBlockFees(this.l1TxUtils.client, windowStartS, windowEndS);
+        if (windowBlocks.length === 0) {
+            return undefined;
+        }
+        return {
+            windowBlocks
+        };
+    }
+    /** Computes timing info relative to the L2 slot deadline. */ computeTimingInfo(targetL2Slot) {
+        if (targetL2Slot === undefined) {
+            return undefined;
+        }
+        const l1Constants = this.epochCache.getL1Constants();
+        const slotDeadlineS = getTimestampForSlot(SlotNumber(Number(targetL2Slot) + 1), l1Constants);
+        const slotDeadlineMs = Number(slotDeadlineS) * 1000;
+        return {
+            targetL2Slot: Number(targetL2Slot),
+            slotDeadlineTimestampS: slotDeadlineS,
+            msUntilSlotDeadline: slotDeadlineMs - this.dateProvider.now()
+        };
+    }
+    /**
+   * Builds an id for a synthetic failure record (send-error/timeout) that has no on-chain tx hash.
+   * Includes the failure time so each attempt — including retries of the same slot — is stored as its
+   * own record rather than overwriting the previous one.
+   */ failureRecordId(actions, targetSlot) {
+        return keccak256(toHex(`${actions.join(',')}:${targetSlot ?? ''}:${Date.now()}`));
     }
     getRollupContract() {
         return this.rollupContract;
@@ -653,7 +720,7 @@ export class SequencerPublisher {
             const bundleResult = await this.bundleSimulator.simulate(validRequests, currentL2Slot);
             if (bundleResult.kind === 'aborted') {
                 this.logDroppedInSim(bundleResult.droppedRequests);
-                void this.backupDroppedInSim(bundleResult.droppedRequests).catch((err)=>this.log.error(`Failed to backup requests dropped in simulation`, err));
+                void this.backupDroppedInSim(bundleResult.droppedRequests, currentL2Slot).catch((err)=>this.log.error(`Failed to backup requests dropped in simulation`, err));
                 return undefined;
             }
             const { requests, droppedRequests, gasLimit } = bundleResult.kind === 'fallback' ? {
@@ -673,7 +740,7 @@ export class SequencerPublisher {
                 requests: requests.map((request)=>request.action),
                 txConfig
             });
-            const result = await this.forwardWithPublisherRotation(requests, txConfig, blobConfig);
+            const result = await this.forwardWithPublisherRotation(requests, txConfig, blobConfig, currentL2Slot);
             if (result === undefined) {
                 return undefined;
             }
@@ -692,6 +759,47 @@ export class SequencerPublisher {
         } catch (err) {
             const viemError = formatViemError(err);
             this.log.error(`Failed to publish bundled transactions`, viemError);
+            if (err instanceof TimeoutError) {
+                const timeoutState = err instanceof L1TxTimeoutError ? err.txState : undefined;
+                void (async ()=>{
+                    // The RPC is likely degraded right after a timeout, so back up without the block number
+                    // rather than leaking an unhandled rejection.
+                    const l1BlockNumber = await this.l1TxUtils.getBlockNumber().catch(()=>0n);
+                    this.backupFailedTx({
+                        id: this.failureRecordId(validRequests.map((r)=>r.action), currentL2Slot),
+                        failureType: 'timeout',
+                        request: {
+                            to: MULTI_CALL_3_ADDRESS,
+                            data: '0x'
+                        },
+                        l1BlockNumber,
+                        error: {
+                            message: viemError.message,
+                            name: 'TimeoutError'
+                        },
+                        context: {
+                            actions: validRequests.map((r)=>r.action),
+                            requests: validRequests.filter((r)=>r.request.to !== null).map((r)=>({
+                                    action: r.action,
+                                    to: r.request.to,
+                                    data: r.request.data
+                                })),
+                            sender: this.getSenderAddress().toString(),
+                            slot: Number(currentL2Slot)
+                        },
+                        timing: this.computeTimingInfo(currentL2Slot),
+                        gasInfo: timeoutState ? {
+                            sentGasPriceLadder: timeoutState.gasPriceHistory,
+                            attempts: timeoutState.attempts,
+                            gasLimit: timeoutState.gasLimit,
+                            nonce: timeoutState.nonce
+                        } : undefined
+                    }, {
+                        captureFeeSummary: true,
+                        targetSlot: currentL2Slot
+                    });
+                })();
+            }
             return undefined;
         } finally{
             try {
@@ -712,37 +820,50 @@ export class SequencerPublisher {
             });
         }
     }
-    /** Backs up entries dropped by bundle simulation, one record per dropped action. */ async backupDroppedInSim(dropped) {
+    /** Backs up entries dropped by bundle simulation, one record per dropped action. */ async backupDroppedInSim(dropped, targetSlot) {
         if (dropped.length === 0) {
             return;
         }
-        const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-        for (const { request: req } of dropped){
-            this.backupFailedTx({
-                id: keccak256(req.request.data),
-                failureType: 'simulation',
-                request: {
-                    to: req.request.to,
-                    data: req.request.data
-                },
-                l1BlockNumber: l1BlockNumber.toString(),
-                error: {
-                    message: 'Bundle entry dropped: action reverted in sim'
-                },
-                context: {
-                    actions: [
-                        req.action
-                    ],
-                    sender: this.getSenderAddress().toString()
-                }
-            });
+        // Invoked as `void backupDroppedInSim(...)` on the publish path, so it must not throw.
+        try {
+            const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
+            // Every dropped entry failed in the same slot against the same L1 fee conditions, so capture
+            // the fee environment once and share it rather than re-reading the window per entry.
+            const sharedFeeSummary = await this.captureFeeEnvironment(targetSlot).catch(()=>undefined);
+            const timing = this.computeTimingInfo(targetSlot);
+            for (const { request: req } of dropped){
+                this.backupFailedTx({
+                    id: keccak256(req.request.data),
+                    failureType: 'simulation',
+                    request: {
+                        to: req.request.to,
+                        data: req.request.data
+                    },
+                    l1BlockNumber,
+                    error: {
+                        message: 'Bundle entry dropped: action reverted in sim'
+                    },
+                    context: {
+                        actions: [
+                            req.action
+                        ],
+                        sender: this.getSenderAddress().toString(),
+                        slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+                    },
+                    timing
+                }, {
+                    sharedFeeSummary
+                });
+            }
+        } catch (err) {
+            this.log.warn(`Failed to back up dropped-in-sim entries`, err);
         }
     }
     /**
    * Forwards transactions via Multicall3, rotating to the next available publisher if a send
    * failure occurs (i.e. the tx never reached the chain).
    * On-chain reverts and simulation errors are returned as-is without rotation.
-   */ async forwardWithPublisherRotation(validRequests, txConfig, blobConfig) {
+   */ async forwardWithPublisherRotation(validRequests, txConfig, blobConfig, targetSlot) {
         if (!txConfig?.gasLimit) {
             throw new Error('gasLimit is required for bundled transactions');
         }
@@ -771,11 +892,13 @@ export class SequencerPublisher {
                     this.log.error('Forwarder transaction reverted on-chain; not rotating publisher', err, {
                         transactionHash: err.receipt.transactionHash
                     });
+                    this.backupRevertFailure(validRequests, err, currentPublisher, targetSlot);
                     return undefined;
                 }
                 const viemError = formatViemError(err);
                 if (!this.getNextPublisher) {
                     this.log.error('Failed to publish bundled transactions', viemError);
+                    this.backupSendFailure(validRequests, viemError, currentPublisher, targetSlot);
                     return undefined;
                 }
                 this.log.warn(`Publisher ${currentPublisher.getSenderAddress()} failed to send, rotating to next publisher`, viemError);
@@ -786,12 +909,85 @@ export class SequencerPublisher {
                     this.log.error(`All available publishers exhausted (tried ${triedAddresses.length}), failed to publish bundled transactions`, viemError, {
                         triedAddresses: triedAddresses.map((a)=>a.toString())
                     });
+                    this.backupSendFailure(validRequests, viemError, currentPublisher, targetSlot);
                     return undefined;
                 }
                 currentPublisher = nextPublisher;
             }
         }
     }
+    /** Backs up an on-chain revert failure to the failed tx store. */ backupRevertFailure(requests, err, publisher, targetSlot) {
+        this.backupFailedTx({
+            id: err.receipt.transactionHash,
+            failureType: 'revert',
+            request: {
+                to: MULTI_CALL_3_ADDRESS,
+                data: '0x'
+            },
+            l1BlockNumber: err.receipt.blockNumber,
+            receipt: {
+                transactionHash: err.receipt.transactionHash,
+                blockNumber: err.receipt.blockNumber,
+                gasUsed: err.receipt.gasUsed,
+                status: 'reverted'
+            },
+            error: {
+                message: err.message,
+                name: err.name
+            },
+            context: {
+                actions: requests.map((r)=>r.action),
+                requests: requests.filter((r)=>r.request.to !== null).map((r)=>({
+                        action: r.action,
+                        to: r.request.to,
+                        data: r.request.data
+                    })),
+                sender: publisher.getSenderAddress().toString(),
+                slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+            },
+            gasInfo: err.txState ? {
+                sentGasPrice: err.txState.gasPrice,
+                gasLimit: err.txState.gasLimit,
+                nonce: err.txState.nonce
+            } : undefined,
+            timing: this.computeTimingInfo(targetSlot)
+        }, {
+            captureFeeSummary: true,
+            targetSlot
+        });
+    }
+    /** Backs up a send failure (tx never reached chain) to the failed tx store. */ backupSendFailure(requests, error, publisher, targetSlot) {
+        // If we can't get the block number, still back up without it.
+        void this.l1TxUtils.getBlockNumber().catch(()=>0n).then((l1BlockNumber)=>{
+            this.backupFailedTx({
+                id: this.failureRecordId(requests.map((r)=>r.action), targetSlot),
+                failureType: 'send-error',
+                request: {
+                    to: MULTI_CALL_3_ADDRESS,
+                    data: '0x'
+                },
+                l1BlockNumber,
+                error: {
+                    message: error.message,
+                    name: 'name' in error ? error.name : undefined
+                },
+                context: {
+                    actions: requests.map((r)=>r.action),
+                    requests: requests.filter((r)=>r.request.to !== null).map((r)=>({
+                            action: r.action,
+                            to: r.request.to,
+                            data: r.request.data
+                        })),
+                    sender: publisher.getSenderAddress().toString(),
+                    slot: targetSlot !== undefined ? Number(targetSlot) : undefined
+                },
+                timing: this.computeTimingInfo(targetSlot)
+            }, {
+                captureFeeSummary: true,
+                targetSlot
+            });
+        });
+    }
     /*
    * Schedules sending all enqueued requests at (or after) the start of the given L2 slot.
    */ async sendRequestsAt(targetSlot) {
@@ -1040,9 +1236,9 @@ export class SequencerPublisher {
                 request: {
                     to: request.to,
                     data: request.data,
-                    value: request.value?.toString()
+                    value: request.value
                 },
-                l1BlockNumber: l1BlockNumber.toString(),
+                l1BlockNumber,
                 error: {
                     message: viemError.message,
                     name: viemError.name
@@ -1053,7 +1249,11 @@ export class SequencerPublisher {
                     ],
                     checkpointNumber,
                     sender: this.getSenderAddress().toString()
-                }
+                },
+                timing: this.computeTimingInfo(this.getCurrentL2Slot())
+            }, {
+                captureFeeSummary: true,
+                targetSlot: this.getCurrentL2Slot()
             });
             throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, {
                 cause: viemError
@@ -1440,7 +1640,7 @@ export class SequencerPublisher {
                         data: validateBlobsData
                     },
                     blobData: encodedData.blobs.map((b)=>toHex(b.data)),
-                    l1BlockNumber: l1BlockNumber.toString(),
+                    l1BlockNumber,
                     error: {
                         message: viemError.message,
                         name: viemError.name
@@ -1450,7 +1650,11 @@ export class SequencerPublisher {
                             'validate-blobs'
                         ],
                         sender: this.getSenderAddress().toString()
-                    }
+                    },
+                    timing: this.computeTimingInfo(this.getCurrentL2Slot())
+                }, {
+                    captureFeeSummary: true,
+                    targetSlot: this.getCurrentL2Slot()
                 });
                 throw new Error('Failed to validate blobs');
             });

package/dest/sequencer/errors.d.ts

@@ -1,4 +1,11 @@
+import type { SequencerState } from './utils.js';
+export declare class SequencerTooSlowError extends Error {
+    readonly proposedState: SequencerState;
+    readonly maxAllowedTime: number;
+    readonly currentTime: number;
+    constructor(proposedState: SequencerState, maxAllowedTime: number, currentTime: number);
+}
 export declare class SequencerInterruptedError extends Error {
     constructor();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxQkFBYSx5QkFBMEIsU0FBUSxLQUFLO0lBQ2xELGNBR0M7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFakQscUJBQWEscUJBQXNCLFNBQVEsS0FBSzthQUU1QixhQUFhLEVBQUUsY0FBYzthQUM3QixjQUFjLEVBQUUsTUFBTTthQUN0QixXQUFXLEVBQUUsTUFBTTtJQUhyQyxZQUNrQixhQUFhLEVBQUUsY0FBYyxFQUM3QixjQUFjLEVBQUUsTUFBTSxFQUN0QixXQUFXLEVBQUUsTUFBTSxFQU1wQztDQUNGO0FBRUQscUJBQWEseUJBQTBCLFNBQVEsS0FBSztJQUNsRCxjQUdDO0NBQ0YifQ==

package/dest/sequencer/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sequencer/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,cAGC;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sequencer/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,aAAa,EAAE,cAAc;aAC7B,cAAc,EAAE,MAAM;aACtB,WAAW,EAAE,MAAM;IAHrC,YACkB,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EAMpC;CACF;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,cAGC;CACF"}

package/dest/sequencer/errors.js

@@ -1,3 +1,12 @@
+export class SequencerTooSlowError extends Error {
+    proposedState;
+    maxAllowedTime;
+    currentTime;
+    constructor(proposedState, maxAllowedTime, currentTime){
+        super(`Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`), this.proposedState = proposedState, this.maxAllowedTime = maxAllowedTime, this.currentTime = currentTime;
+        this.name = 'SequencerTooSlowError';
+    }
+}
 export class SequencerInterruptedError extends Error {
     constructor(){
         super(`Sequencer was interrupted`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/sequencer-client",
-  "version": "0.0.1-commit.a5db02d",
+  "version": "0.0.1-commit.aa0c64f",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -27,37 +27,38 @@
     "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.a5db02d",
-    "@aztec/bb-prover": "0.0.1-commit.a5db02d",
-    "@aztec/blob-client": "0.0.1-commit.a5db02d",
-    "@aztec/blob-lib": "0.0.1-commit.a5db02d",
-    "@aztec/constants": "0.0.1-commit.a5db02d",
-    "@aztec/epoch-cache": "0.0.1-commit.a5db02d",
-    "@aztec/ethereum": "0.0.1-commit.a5db02d",
-    "@aztec/foundation": "0.0.1-commit.a5db02d",
-    "@aztec/l1-artifacts": "0.0.1-commit.a5db02d",
-    "@aztec/node-keystore": "0.0.1-commit.a5db02d",
-    "@aztec/noir-acvm_js": "0.0.1-commit.a5db02d",
-    "@aztec/noir-contracts.js": "0.0.1-commit.a5db02d",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.a5db02d",
-    "@aztec/noir-types": "0.0.1-commit.a5db02d",
-    "@aztec/p2p": "0.0.1-commit.a5db02d",
-    "@aztec/protocol-contracts": "0.0.1-commit.a5db02d",
-    "@aztec/prover-client": "0.0.1-commit.a5db02d",
-    "@aztec/simulator": "0.0.1-commit.a5db02d",
-    "@aztec/slasher": "0.0.1-commit.a5db02d",
-    "@aztec/stdlib": "0.0.1-commit.a5db02d",
-    "@aztec/telemetry-client": "0.0.1-commit.a5db02d",
-    "@aztec/validator-client": "0.0.1-commit.a5db02d",
-    "@aztec/validator-ha-signer": "0.0.1-commit.a5db02d",
-    "@aztec/world-state": "0.0.1-commit.a5db02d",
+    "@aztec/aztec.js": "0.0.1-commit.aa0c64f",
+    "@aztec/bb-prover": "0.0.1-commit.aa0c64f",
+    "@aztec/blob-client": "0.0.1-commit.aa0c64f",
+    "@aztec/blob-lib": "0.0.1-commit.aa0c64f",
+    "@aztec/constants": "0.0.1-commit.aa0c64f",
+    "@aztec/epoch-cache": "0.0.1-commit.aa0c64f",
+    "@aztec/ethereum": "0.0.1-commit.aa0c64f",
+    "@aztec/foundation": "0.0.1-commit.aa0c64f",
+    "@aztec/l1-artifacts": "0.0.1-commit.aa0c64f",
+    "@aztec/node-keystore": "0.0.1-commit.aa0c64f",
+    "@aztec/noir-acvm_js": "0.0.1-commit.aa0c64f",
+    "@aztec/noir-contracts.js": "0.0.1-commit.aa0c64f",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.aa0c64f",
+    "@aztec/noir-types": "0.0.1-commit.aa0c64f",
+    "@aztec/p2p": "0.0.1-commit.aa0c64f",
+    "@aztec/protocol-contracts": "0.0.1-commit.aa0c64f",
+    "@aztec/prover-client": "0.0.1-commit.aa0c64f",
+    "@aztec/simulator": "0.0.1-commit.aa0c64f",
+    "@aztec/slasher": "0.0.1-commit.aa0c64f",
+    "@aztec/stdlib": "0.0.1-commit.aa0c64f",
+    "@aztec/telemetry-client": "0.0.1-commit.aa0c64f",
+    "@aztec/validator-client": "0.0.1-commit.aa0c64f",
+    "@aztec/validator-ha-signer": "0.0.1-commit.aa0c64f",
+    "@aztec/world-state": "0.0.1-commit.aa0c64f",
     "lodash.chunk": "^4.2.0",
     "tslib": "^2.4.0",
-    "viem": "npm:@aztec/viem@2.38.2"
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^4"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.a5db02d",
-    "@aztec/kv-store": "0.0.1-commit.a5db02d",
+    "@aztec/archiver": "0.0.1-commit.aa0c64f",
+    "@aztec/kv-store": "0.0.1-commit.aa0c64f",
     "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -1,33 +1,40 @@
+import type { WindowBlockFees } from '@aztec/ethereum/l1-fee-analysis';
+import type { GasPrice } from '@aztec/ethereum/l1-tx-utils';
 import type { Branded } from '@aztec/foundation/branded-types';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 
 import type { Hex } from 'viem';
+import { z } from 'zod';
 
 /** URI pointing to a stored failed L1 transaction. */
 export type FailedL1TxUri = Branded<string, 'FailedL1TxUri'>;
 
-/** A failed L1 transaction captured for debugging and replay. */
+/**
+ * A failed L1 transaction captured for debugging and replay. Serialized with jsonStringify (bigints
+ * become decimal strings on disk) and parsed back via FailedL1TxSchema.
+ */
 export type FailedL1Tx = {
   /** Tx hash (for reverts) or keccak256(request.data) (for simulation/send failures). */
   id: Hex;
   /** Unix timestamp (ms) when failure occurred. */
   timestamp: number;
-  /** Whether the failure was during simulation or after sending. */
-  failureType: 'simulation' | 'revert' | 'send-error';
+  /** How the failure occurred. */
+  failureType: 'simulation' | 'revert' | 'send-error' | 'timeout';
   /** The actual L1 transaction for replay (multicall-encoded for bundled txs). */
   request: {
     to: Hex;
     data: Hex;
-    value?: string; // bigint as string
+    value?: bigint;
   };
   /** Raw blob data as hex for replay. */
   blobData?: Hex[];
   /** L1 block number at time of failure (simulation target or receipt block). */
-  l1BlockNumber: string; // bigint as string
+  l1BlockNumber: bigint;
   /** Receipt info (present only for on-chain reverts). */
   receipt?: {
     transactionHash: Hex;
-    blockNumber: string; // bigint as string
-    gasUsed: string; // bigint as string
+    blockNumber: bigint;
+    gasUsed: bigint;
     status: 'reverted';
   };
   /** Error information. */
@@ -46,8 +53,108 @@ export type FailedL1Tx = {
     slot?: number;
     sender: Hex;
   };
+  /** Gas pricing info at time of failure for underpricing diagnosis. */
+  gasInfo?: {
+    /** Gas prices the tx was sent with (present for revert/send-error/timeout, not simulation). */
+    sentGasPrice?: GasPrice;
+    /** Gas limit used or estimated. */
+    gasLimit?: bigint;
+    /** Nonce used for the sent tx. */
+    nonce?: number;
+    /**
+     * For timeouts: the escalating gas prices used across the initial send and each speed-up retry,
+     * in order. Compare against windowBlocks[].minIncludedPriorityFee to see if any attempt cleared the bar.
+     */
+    sentGasPriceLadder?: GasPrice[];
+    /** Number of send attempts (initial send + speed-ups). */
+    attempts?: number;
+    /**
+     * Per-block fee data for the L1 blocks the tx could have been included in (the target L2 slot's
+     * inclusion window), in chronological order. Compare sentGasPrice against these to see whether
+     * the tx was underpriced for each block it competed for. May be a partial or empty list if the
+     * window was not yet mined when the failure was recorded (e.g. an early send failure).
+     */
+    windowBlocks?: WindowBlockFees[];
+  };
+  /** Timing info relative to the L2 slot. */
+  timing?: {
+    /** The target L2 slot this tx was for. */
+    targetL2Slot?: number;
+    /** Unix timestamp (seconds) when the target slot ends. */
+    slotDeadlineTimestampS?: bigint;
+    /** Milliseconds remaining until the slot deadline. Negative = past deadline. */
+    msUntilSlotDeadline?: number;
+  };
 };
 
+const hexSchema = schemas.HexStringWith0x;
+
+const gasPriceSchema = z.object({
+  maxFeePerGas: schemas.BigInt,
+  maxPriorityFeePerGas: schemas.BigInt,
+  maxFeePerBlobGas: schemas.BigInt.optional(),
+}) satisfies ZodFor<GasPrice>;
+
+const windowBlockFeesSchema = z.object({
+  blockNumber: schemas.BigInt,
+  timestamp: schemas.BigInt,
+  baseFeePerGas: schemas.BigInt,
+  p75PriorityFee: schemas.BigInt,
+  minIncludedPriorityFee: schemas.BigInt,
+  blockBlobsFull: z.boolean(),
+  includedBlobCount: z.number(),
+}) satisfies ZodFor<WindowBlockFees>;
+
+/** Parses a stored failed-tx record, coercing the on-disk decimal strings back to bigints. */
+export const FailedL1TxSchema: ZodFor<FailedL1Tx> = z.object({
+  id: hexSchema,
+  timestamp: z.number(),
+  failureType: z.enum(['simulation', 'revert', 'send-error', 'timeout']),
+  request: z.object({
+    to: hexSchema,
+    data: hexSchema,
+    value: schemas.BigInt.optional(),
+  }),
+  blobData: z.array(hexSchema).optional(),
+  l1BlockNumber: schemas.BigInt,
+  receipt: z
+    .object({
+      transactionHash: hexSchema,
+      blockNumber: schemas.BigInt,
+      gasUsed: schemas.BigInt,
+      status: z.literal('reverted'),
+    })
+    .optional(),
+  error: z.object({
+    message: z.string(),
+    name: z.string().optional(),
+  }),
+  context: z.object({
+    actions: z.array(z.string()),
+    requests: z.array(z.object({ action: z.string(), to: hexSchema, data: hexSchema })).optional(),
+    checkpointNumber: z.number().optional(),
+    slot: z.number().optional(),
+    sender: hexSchema,
+  }),
+  gasInfo: z
+    .object({
+      sentGasPrice: gasPriceSchema.optional(),
+      gasLimit: schemas.BigInt.optional(),
+      nonce: z.number().optional(),
+      sentGasPriceLadder: z.array(gasPriceSchema).optional(),
+      attempts: z.number().optional(),
+      windowBlocks: z.array(windowBlockFeesSchema).optional(),
+    })
+    .optional(),
+  timing: z
+    .object({
+      targetL2Slot: z.number().optional(),
+      slotDeadlineTimestampS: schemas.BigInt.optional(),
+      msUntilSlotDeadline: z.number().optional(),
+    })
+    .optional(),
+});
+
 /** Store for failed L1 transactions for debugging purposes. */
 export interface L1TxFailedStore {
   /** Saves a failed transaction and returns its URI. */