@aztec/sequencer-client 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

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';
@@ -408,6 +408,7 @@ import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 export const Actions = [
     'invalidate-by-invalid-attestation',
     'invalidate-by-insufficient-attestations',
+    'prune',
     'propose',
     'governance-signal',
     'vote-offenses',
@@ -446,6 +447,8 @@ export class SequencerPublisher {
     log;
     ethereumSlotDuration;
     aztecSlotDuration;
+    previousL1BlockWaitTimeoutMs;
+    previousL1BlockWaitPollIntervalMs;
     /** Date provider for wall-clock time. */ dateProvider;
     blobClient;
     /** Optional callback to obtain a replacement publisher when the current one fails to send. */ getNextPublisher;
@@ -473,6 +476,8 @@ export class SequencerPublisher {
         this.log = deps.log ?? createLogger('sequencer:publisher');
         this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
         this.aztecSlotDuration = BigInt(config.aztecSlotDuration);
+        this.previousL1BlockWaitTimeoutMs = config.sequencerPublisherPreviousL1BlockWaitTimeoutMs;
+        this.previousL1BlockWaitPollIntervalMs = config.sequencerPublisherPreviousL1BlockWaitPollIntervalMs;
         this.dateProvider = deps.dateProvider;
         this.epochCache = deps.epochCache;
         this.lastActions = deps.lastActions;
@@ -507,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;
@@ -648,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);
+                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' ? {
@@ -668,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;
             }
@@ -687,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 {
@@ -707,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');
         }
@@ -766,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);
@@ -781,39 +909,153 @@ 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.
-   * Sleeps until one L1 slot before the L2 slot boundary so the tx has a chance of being
-   * picked up by the first L1 block of the L2 slot.
-   * NB: there is a known correctness risk — being included in the L1 block right before the
-   * L2 slot starts would revert propose with HeaderLib__InvalidSlotNumber.
-   * Uses InterruptibleSleep so it can be cancelled via interrupt().
    */ async sendRequestsAt(targetSlot) {
-        const l1Constants = this.epochCache.getL1Constants();
-        // Start of the target L2 slot, in ms (getTimestampForSlot returns seconds).
-        const startOfTargetSlotMs = Number(getTimestampForSlot(targetSlot, l1Constants)) * 1000;
-        // Aim to be in the mempool one L1 slot before the L2 slot starts, so we have a chance of
-        // being picked up by the first L1 block of the L2 slot.
-        const submitAfterMs = startOfTargetSlotMs - Number(this.ethereumSlotDuration) * 1000;
-        const sleepMs = submitAfterMs - this.dateProvider.now();
-        if (sleepMs > 0) {
-            this.log.debug(`Sleeping ${sleepMs}ms before sending requests`, {
-                targetSlot,
-                submitAfterMs
-            });
-            await this.interruptibleSleep.sleep(sleepMs);
-        }
+        await this.waitForTargetSlot(targetSlot);
         if (this.interrupted) {
             return undefined;
         }
         return this.sendRequests(targetSlot);
     }
+    /**
+   * Sleeps until one L1 slot before the L2 slot boundary, and then waits for that L1 block
+   * to be mined, so we don't risk being included in it. If that block never gets mined after
+   * a timeout, we assume it got skipped on L1, so we send the tx anyway.
+   */ async waitForTargetSlot(targetSlot) {
+        const l1Constants = this.epochCache.getL1Constants();
+        const nowInSeconds = this.dateProvider.nowInSeconds();
+        const startOfTargetSlotTs = getTimestampForSlot(targetSlot, l1Constants);
+        const previousL1BlockTs = startOfTargetSlotTs - this.ethereumSlotDuration;
+        const waitDeadlineTs = previousL1BlockTs + BigInt(this.previousL1BlockWaitTimeoutMs / 1000);
+        const logCtx = {
+            targetSlot,
+            startOfTargetSlotTs,
+            nowInSeconds,
+            previousL1BlockTs,
+            waitDeadlineTs
+        };
+        // Check if we are already past time
+        if (nowInSeconds >= startOfTargetSlotTs) {
+            this.log.verbose(`Target slot ${targetSlot} already started, sending requests immediately`, logCtx);
+            return;
+        }
+        // Otherwise we wait
+        this.log.debug(`Waiting for slot ${targetSlot} before sending requests`, logCtx);
+        // Wait until previous L1 block timestamp first
+        const sleepMs = (Number(previousL1BlockTs) - nowInSeconds) * 1000;
+        if (sleepMs > 0 && !this.interrupted) {
+            this.log.trace(`Sleeping ${sleepMs}ms before waiting for previous L1 block`, logCtx);
+            await this.interruptibleSleep.sleep(sleepMs);
+        }
+        // Then loop until we see the previous L1 block, so we know that we cannot be included in it.
+        // We time out after a while, once we are sure that that block is skipped in L1.
+        while(!this.interrupted){
+            try {
+                const nowInSeconds = this.dateProvider.nowInSeconds();
+                logCtx.nowInSeconds = nowInSeconds;
+                if (nowInSeconds >= waitDeadlineTs) {
+                    this.log.warn(`Timed out waiting for previous L1 block before sending requests, proceeding`, logCtx);
+                    return;
+                }
+                const latestBlockTs = await this.l1TxUtils.getBlock().then((b)=>b.timestamp);
+                if (latestBlockTs >= previousL1BlockTs) {
+                    this.log.debug(`Previous L1 block mined, proceeding to send requests`, {
+                        ...logCtx,
+                        latestBlockTs
+                    });
+                    return;
+                }
+                this.log.trace(`Previous L1 block not mined yet, continuing to wait`, {
+                    ...logCtx,
+                    latestBlockTs
+                });
+            } catch (err) {
+                this.log.error(`Error while waiting for previous L1 block before sending requests; retrying`, err, logCtx);
+            } finally{
+                await this.interruptibleSleep.sleep(this.previousL1BlockWaitPollIntervalMs);
+            }
+        }
+    }
     callbackBundledTransactions(requests, result) {
         const actionsListStr = requests.map((r)=>r.action).join(', ');
         this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
@@ -994,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
@@ -1007,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
@@ -1024,7 +1270,11 @@ export class SequencerPublisher {
             reason
         };
         this.log.debug(`Building invalidate checkpoint ${checkpoint.checkpointNumber} request`, logData);
-        const attestationsAndSigners = CommitteeAttestationsAndSigners.packAttestations(validationResult.attestations);
+        // Use the exact packed tuple posted to L1 verbatim. A repack via `packAttestations` is not a
+        // byte-faithful inverse of `fromPacked` (a canonicalized yParity byte or an all-zero signature slot
+        // round-trips differently), so it would diverge from the stored `attestationsHash` and revert the
+        // invalidation.
+        const attestationsAndSigners = validationResult.verbatimAttestations;
         if (reason === 'invalid-attestation') {
             return this.rollupContract.buildInvalidateBadAttestationRequest(checkpoint.checkpointNumber, attestationsAndSigners, committee, validationResult.invalidIndex);
         } else if (reason === 'insufficient-attestations') {
@@ -1122,6 +1372,56 @@ export class SequencerPublisher {
    */ enqueueGovernanceCastSignal(governancePayload, slotNumber, signerAddress, signer) {
         return this.enqueueCastSignalHelper(slotNumber, 'governance-signal', governancePayload, this.govProposerContract, signerAddress, signer);
     }
+    /**
+   * Enqueues a `prune()` transaction if the rollup is prunable at the given slot's L1 timestamp.
+   * `prune()` is permissionless and idempotent — if the chain is no longer prunable by send time the
+   * bundle simulation usually drops the entry; on a node without `eth_simulateV1` the bundle is sent
+   * as-is and the prune reverts `Rollup__NothingToPrune` inside `aggregate3(allowFailure: true)`
+   * (a failed action, never a whole-tx revert). Used by the failed-sync fallback so a stuck pending
+   * chain (e.g. bad data blocking sync) can be wound back to recover.
+   * @returns true if a prune request was enqueued, false otherwise.
+   */ async enqueuePruneIfPrunable(slotNumber) {
+        if (this.lastActions['prune'] === slotNumber) {
+            this.log.debug(`Skipping duplicate prune for slot ${slotNumber}`, {
+                slotNumber
+            });
+            return false;
+        }
+        // Use the SAME timestamp the bundle simulator overrides block.timestamp with at send time
+        // (sequencer-bundle-simulator.ts) so this upfront check and the send-time sim agree. Slot-start
+        // and last-L1-slot both fall within the same L2 slot (and epoch, which is what `canPruneAtTime`
+        // derives), so they agree today; matching the simulator keeps it robust if the contract ever uses
+        // the timestamp more granularly.
+        const ts = getLastL1SlotTimestampForL2Slot(slotNumber, this.epochCache.getL1Constants());
+        const canPrune = await this.rollupContract.canPruneAtTime(ts).catch((err)=>{
+            this.log.error(`Failed to check canPruneAtTime for slot ${slotNumber}`, err, {
+                slotNumber
+            });
+            return false;
+        });
+        if (!canPrune) {
+            this.log.debug(`Rollup not prunable at slot ${slotNumber}`, {
+                slotNumber
+            });
+            return false;
+        }
+        const request = {
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'prune',
+                args: []
+            })
+        };
+        this.log.info(`Enqueuing rollup prune for slot ${slotNumber}`, {
+            slotNumber
+        });
+        return this.enqueueRequest('prune', request, {
+            address: this.rollupContract.address,
+            abi: RollupAbi,
+            eventName: 'PrunedPending'
+        }, slotNumber);
+    }
     /** Enqueues all slashing actions as returned by the slasher client. */ async enqueueSlashingActions(actions, slotNumber, signerAddress, signer) {
         if (actions.length === 0) {
             this.log.debug(`No slashing actions to enqueue for slot ${slotNumber}`);
@@ -1340,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
@@ -1350,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/publisher/write_json.d.ts

@@ -0,0 +1,11 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { BatchedBlob, Blob } from '@aztec/blob-lib';
+import { L2Block } from '@aztec/stdlib/block';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+/**
+ * Creates a json object that can be used to test the solidity contract.
+ * The json object must be put into
+ */
+export declare function writeJson(fileName: string, checkpointHeader: CheckpointHeader, block: L2Block, l1ToL2Content: Fr[], blobs: Blob[], batchedBlob: BatchedBlob, recipientAddress: AztecAddress, deployerAddress: `0x${string}`): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JpdGVfanNvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1Ymxpc2hlci93cml0ZV9qc29uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUMsT0FBTyxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQTZELE1BQU0saUJBQWlCLENBQUM7QUFFL0csT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBTXhEOzs7R0FHRztBQUNILHdCQUFzQixTQUFTLENBQzdCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLGdCQUFnQixFQUFFLGdCQUFnQixFQUNsQyxLQUFLLEVBQUUsT0FBTyxFQUNkLGFBQWEsRUFBRSxFQUFFLEVBQUUsRUFDbkIsS0FBSyxFQUFFLElBQUksRUFBRSxFQUNiLFdBQVcsRUFBRSxXQUFXLEVBQ3hCLGdCQUFnQixFQUFFLFlBQVksRUFDOUIsZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFFLEdBQzdCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxRGYifQ==

package/dest/publisher/write_json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_json.d.ts","sourceRoot":"","sources":["../../src/publisher/write_json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,IAAI,EAA6D,MAAM,iBAAiB,CAAC;AAE/G,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAMxD;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,gBAAgB,EAClC,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,EAAE,EAAE,EACnB,KAAK,EAAE,IAAI,EAAE,EACb,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE,YAAY,EAC9B,eAAe,EAAE,KAAK,MAAM,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CAqDf"}

package/dest/publisher/write_json.js

@@ -0,0 +1,57 @@
+import { getEthBlobEvaluationInputs, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { writeFile } from 'fs/promises';
+const AZTEC_GENERATE_TEST_DATA = !!process.env.AZTEC_GENERATE_TEST_DATA;
+/**
+ * Creates a json object that can be used to test the solidity contract.
+ * The json object must be put into
+ */ export async function writeJson(fileName, checkpointHeader, block, l1ToL2Content, blobs, batchedBlob, recipientAddress, deployerAddress) {
+    if (!AZTEC_GENERATE_TEST_DATA) {
+        return;
+    }
+    // Path relative to the package.json in the end-to-end folder
+    const path = `../../l1-contracts/test/fixtures/${fileName}.json`;
+    const asHex = (value, size = 64)=>{
+        const buffer = Buffer.isBuffer(value) ? value : value.toBuffer();
+        return `0x${buffer.toString('hex').padStart(size, '0')}`;
+    };
+    const jsonObject = {
+        populate: {
+            l1ToL2Content: l1ToL2Content.map((value)=>asHex(value)),
+            recipient: asHex(recipientAddress.toField()),
+            sender: deployerAddress
+        },
+        messages: {
+            l2ToL1Messages: block.body.txEffects.flatMap((txEffect)=>txEffect.l2ToL1Msgs).map((value)=>asHex(value))
+        },
+        checkpoint: {
+            // The json formatting in forge is a bit brittle, so we convert Fr to a number in the few values below.
+            // This should not be a problem for testing as long as the values are not larger than u32.
+            archive: asHex(block.archive.root),
+            blobCommitments: getPrefixedEthBlobCommitments(blobs),
+            batchedBlobInputs: getEthBlobEvaluationInputs(batchedBlob),
+            checkpointNumber: block.number,
+            body: `0x${block.body.toBuffer().toString('hex')}`,
+            header: {
+                lastArchiveRoot: asHex(checkpointHeader.lastArchiveRoot),
+                blockHeadersHash: asHex(checkpointHeader.blockHeadersHash),
+                blobsHash: asHex(checkpointHeader.blobsHash),
+                inHash: asHex(checkpointHeader.inHash),
+                outHash: asHex(checkpointHeader.epochOutHash),
+                slotNumber: Number(checkpointHeader.slotNumber),
+                timestamp: Number(checkpointHeader.timestamp),
+                coinbase: asHex(checkpointHeader.coinbase, 40),
+                feeRecipient: asHex(checkpointHeader.feeRecipient),
+                gasFees: {
+                    feePerDaGas: Number(checkpointHeader.gasFees.feePerDaGas),
+                    feePerL2Gas: Number(checkpointHeader.gasFees.feePerL2Gas)
+                },
+                totalManaUsed: checkpointHeader.totalManaUsed.toNumber(),
+                accumulatedFees: checkpointHeader.accumulatedFees.toNumber()
+            },
+            headerHash: asHex(checkpointHeader.hash()),
+            numTxs: block.body.txEffects.length
+        }
+    };
+    const output = JSON.stringify(jsonObject, null, 2);
+    await writeFile(path, output, 'utf8');
+}