@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/dest/sequencer/automine/automine_sequencer.js

@@ -0,0 +1,509 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { isErrorClass } from '@aztec/foundation/types';
+import { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { getPreviousCheckpointOutHashes } from '@aztec/stdlib/checkpoint';
+import { getEpochAtSlot, getSlotAtTimestamp, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { InsufficientValidTxsError } from '@aztec/stdlib/interfaces/server';
+/**
+ * Minimal, deterministic, queue-driven sequencer for e2e tests that don't exercise
+ * block-building or consensus (e.g. e2e_token, e2e_amm, e2e_authwit).
+ *
+ * Differences from the production `Sequencer`:
+ *   - No proposer-turn check (single sequencer).
+ *   - No sync check, no pipelining, no validator orchestration, no attestations,
+ *     no slashing, no votes, no P2P proposal gossip, no timetable enforcement.
+ *   - No event emission — consumers (archiver, world-state, `EpochTestSettler`) observe
+ *     L1 and the archiver tip rather than sequencer events.
+ *   - All test-driven time control (warp / mine empty block) goes through a single
+ *     serial queue alongside mempool-driven builds; the three never interleave.
+ *
+ * Requires `aztecTargetCommitteeSize == 0` on the deployed rollup so that the
+ * L1 `verifyProposer` / `verifyAttestations` short-circuits accept an empty
+ * `CommitteeAttestationsAndSigners` (see
+ * `l1-contracts/src/core/libraries/rollup/ValidatorSelectionLib.sol:244`).
+ */ export class AutomineSequencer {
+    log;
+    queue;
+    pollIntervalMs;
+    deps;
+    running = false;
+    stopped = false;
+    paused = false;
+    mempoolPoller;
+    publisher;
+    attestorAddress;
+    /** Set while a mempool-driven build is queued but not yet run; used to coalesce. */ buildQueued = undefined;
+    /** Last L2 slot we published a checkpoint for (-1 means none yet). */ lastBuiltSlot = -1;
+    constructor(deps){
+        this.deps = deps;
+        this.log = deps.log ?? createLogger('sequencer:automine');
+        this.queue = new SerialQueue();
+        this.pollIntervalMs = deps.pollIntervalMs ?? 50;
+    }
+    /**
+   * Starts the sequencer. Switches anvil into automine mode (no interval mining),
+   * acquires a publisher, and begins polling the mempool for pending txs.
+   */ async start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        await this.deps.ethCheatCodes.setIntervalMining(0, {
+            silent: true
+        });
+        await this.deps.ethCheatCodes.setAutomine(true, {
+            silent: true
+        });
+        const { publisher, attestorAddress } = await this.deps.publisherFactory.create();
+        this.publisher = publisher;
+        this.attestorAddress = attestorAddress;
+        this.log.info(`AutomineSequencer started`, {
+            publisher: this.publisher.getSenderAddress().toString(),
+            attestor: this.attestorAddress.toString()
+        });
+        this.queue.start();
+        // Fallback poller that triggers a build if we discover pending txs without an explicit
+        // notification. Tests can also call `buildIfPending()` directly to skip the poll wait.
+        this.mempoolPoller = new RunningPromise(()=>this.maybeEnqueueBuild(), this.log, this.pollIntervalMs);
+        this.mempoolPoller.start();
+    }
+    /**
+   * Stops the sequencer. Drains the queue, unsubscribes the mempool poller, and runs any
+   * registered {@link AutomineSequencerDeps.stopExtras} hook (e.g. the PublisherManager's
+   * funding loop). Idempotent: subsequent calls return without re-running cleanup.
+   */ async stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.running = false;
+        await this.mempoolPoller?.stop();
+        await this.queue.end();
+        await this.deps.stopExtras?.();
+        this.log.info('AutomineSequencer stopped');
+    }
+    /**
+   * Enqueues a mempool-driven build. Coalesces consecutive calls so a burst of new txs
+   * collapses into one build job. Returns the built block (or undefined if nothing was built
+   * or the sequencer is paused).
+   */ buildIfPending() {
+        if (!this.running || this.paused) {
+            return Promise.resolve(undefined);
+        }
+        if (this.buildQueued) {
+            // A build is already queued; coalesce. The pending build will pick up the new txs.
+            return this.buildQueued;
+        }
+        this.buildQueued = this.queue.put(async ()=>{
+            try {
+                return await this.runBuild({
+                    allowEmpty: false
+                });
+            } finally{
+                this.buildQueued = undefined;
+            }
+        });
+        return this.buildQueued;
+    }
+    /**
+   * Pauses mempool-driven block production. Pending txs accumulate in the pool without being
+   * mined. Explicit test-harness operations (`buildEmptyBlock`, `warpTo`, `revertToCheckpoint`)
+   * continue to work; this only gates the mempool poller and `buildIfPending`.
+   */ pause() {
+        if (this.paused) {
+            return;
+        }
+        this.paused = true;
+        this.log.info('AutomineSequencer paused');
+    }
+    /** Resumes mempool-driven block production after a previous {@link pause}. */ resume() {
+        if (!this.paused) {
+            return;
+        }
+        this.paused = false;
+        this.log.info('AutomineSequencer resumed');
+    }
+    /**
+   * Updates the in-memory sequencer config. Mirrors {@link SequencerClient.updateConfig} so that
+   * `AztecNode.setConfig` (e.g. tests bumping `minTxsPerBlock` to bundle multiple txs into one
+   * block) propagates to the AutomineSequencer's gating logic in {@link runBuild}.
+   */ updateConfig(config) {
+        Object.assign(this.deps.config, config);
+    }
+    /** Returns a snapshot of the current sequencer config (used by pause/resume bookkeeping). */ getConfig() {
+        return this.deps.config;
+    }
+    /** Enqueues an empty-block build. Resolves to the built block. */ buildEmptyBlock() {
+        return this.queue.put(async ()=>{
+            const block = await this.runBuild({
+                allowEmpty: true
+            });
+            if (!block) {
+                throw new Error('buildEmptyBlock: runBuild returned undefined');
+            }
+            return block;
+        });
+    }
+    /**
+   * Warps L1 timestamp to `targetTimestampSec`. Rounded up to the next aztec-slot
+   * boundary so the next build lands on a fresh slot. Atomic with respect to builds —
+   * the queue ensures no build is in flight while the warp executes.
+   */ warpTo(targetTimestampSec) {
+        return this.queue.put(()=>this.runWarp(targetTimestampSec));
+    }
+    /** Warps L1 timestamp forward by `deltaSec` seconds from the current L1 time. */ warpBy(deltaSec) {
+        return this.queue.put(async ()=>{
+            const current = await this.deps.ethCheatCodes.lastBlockTimestamp();
+            await this.runWarp(current + deltaSec);
+        });
+    }
+    /**
+   * Reorgs L1 so that every L1 block strictly after the one that published
+   * `targetCheckpoint` is removed. The archiver, world-state, and date provider
+   * are all brought back in sync before the promise resolves.
+   *
+   * Runs inside the serial queue so it never interleaves with a build or warp.
+   */ revertToCheckpoint(targetCheckpoint) {
+        return this.queue.put(()=>this.runRevert(targetCheckpoint));
+    }
+    /** Awaits the queue draining to a fully idle state. */ syncPoint() {
+        return this.queue.syncPoint();
+    }
+    /** Called from the mempool poller. Enqueues a build if there are pending txs. */ async maybeEnqueueBuild() {
+        if (!this.running || this.paused || this.buildQueued) {
+            return;
+        }
+        try {
+            const pending = await this.deps.p2pClient.getPendingTxCount();
+            if (pending > 0) {
+                // Fire-and-forget; the build result is delivered via `buildIfPending()` callers,
+                // not via the poller.
+                void this.buildIfPending().catch((err)=>{
+                    this.log.error('Mempool-driven build failed', err);
+                });
+            }
+        } catch (err) {
+            this.log.warn('Failed to poll mempool', {
+                err: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    /** Builds one checkpoint with a single block, publishes it, syncs the date provider. */ async runBuild({ allowEmpty }) {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            if (!this.running || !this.publisher || !this.attestorAddress) {
+                return undefined;
+            }
+            const txCount = await this.deps.p2pClient.getPendingTxCount();
+            // For mempool-driven builds, wait for at least `minTxsPerBlock` pending txs (or 1 if not set)
+            // before building. This mirrors the production sequencer's `waitForMinTxs` behavior, and is
+            // required for tests that bundle multiple txs into one block via `setConfig({ minTxsPerBlock })`.
+            // Explicit empty-block / warp paths pass `allowEmpty: true` and bypass this gate.
+            const minRequired = allowEmpty ? 0 : Math.max(this.deps.config.minTxsPerBlock ?? 1, 1);
+            if (txCount < minRequired) {
+                return undefined;
+            }
+            // Decide target slot from the pending block's timestamp — picks up any prior
+            // `setNextBlockTimestamp` call (e.g. queued by runWarp) instead of assuming +1 over
+            // the last mined block.
+            const pendingBlockTs = await this.deps.ethCheatCodes.nextBlockTimestamp();
+            let targetSlot = Number(getSlotAtTimestamp(BigInt(pendingBlockTs), this.deps.l1Constants));
+            if (targetSlot <= this.lastBuiltSlot) {
+                // Pending block doesn't reach a new slot yet; advance to the next slot we own.
+                targetSlot = this.lastBuiltSlot + 1;
+            }
+            const slotBoundaryTs = Number(getTimestampForSlot(SlotNumber(targetSlot), this.deps.l1Constants));
+            // Pre-set anvil's next block timestamp only if the slot boundary is past what's already
+            // scheduled. setNextBlockTimestamp rejects values not strictly greater than the last block's
+            // timestamp, and pendingBlockTs is always > lastBlockTimestamp, so this guard is sufficient.
+            if (slotBoundaryTs > pendingBlockTs) {
+                await this.deps.ethCheatCodes.setNextBlockTimestamp(slotBoundaryTs);
+            }
+            const tips = await this.deps.l2BlockSource.getL2Tips();
+            const syncedToBlockNumber = tips.proposed.number;
+            // Ensure world state has processed the archiver's tip before forking. Without this,
+            // world state may still be at the previous block (since it syncs asynchronously from
+            // the archiver), and `fork(syncedToBlockNumber)` would fail with
+            // "Unable to initialize from future block".
+            await this.deps.worldState.syncImmediate(BlockNumber(syncedToBlockNumber));
+            const nextBlockNumber = BlockNumber(syncedToBlockNumber + 1);
+            const checkpointNumber = CheckpointNumber(tips.proposedCheckpoint.checkpoint.number + 1);
+            const targetEpoch = getEpochAtSlot(SlotNumber(targetSlot), this.deps.l1Constants);
+            this.log.verbose(`Building automine checkpoint`, {
+                checkpointNumber,
+                blockNumber: nextBlockNumber,
+                slot: targetSlot,
+                slotTimestamp: slotBoundaryTs,
+                txCount,
+                allowEmpty
+            });
+            const checkpointGlobals = await this.deps.globalsBuilder.buildCheckpointGlobalVariables(this.deps.coinbase, this.deps.feeRecipient, SlotNumber(targetSlot));
+            const l1ToL2Messages = await this.deps.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+            const previousCheckpointOutHashes = await getPreviousCheckpointOutHashes({
+                blockSource: this.deps.l2BlockSource,
+                epoch: targetEpoch,
+                checkpointNumber,
+                l1Constants: this.deps.l1Constants,
+                pipeliningEnabled: false,
+                log: this.log
+            });
+            const feeAssetPriceModifier = await this.publisher.getFeeAssetPriceModifier();
+            const fork = _ts_add_disposable_resource(env, await this.deps.worldState.fork(syncedToBlockNumber, {
+                closeDelayMs: 0
+            }), true);
+            const checkpointBuilder = await this.deps.checkpointsBuilder.startCheckpoint(checkpointNumber, checkpointGlobals, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, this.log.getBindings());
+            const pendingTxs = this.deps.p2pClient.iterateEligiblePendingTxs();
+            const buildResult = await this.tryBuildBlock(checkpointBuilder, pendingTxs, nextBlockNumber, checkpointGlobals.timestamp, allowEmpty, checkpointNumber);
+            if (!buildResult) {
+                return undefined;
+            }
+            const checkpoint = await checkpointBuilder.completeCheckpoint();
+            // Empty CommitteeAttestationsAndSigners is accepted on-chain when committee size is 0.
+            const emptyAttestations = CommitteeAttestationsAndSigners.empty(this.deps.signatureContext);
+            const emptyAttestationsSignature = Signature.empty();
+            // Push the block and proposed checkpoint into the archiver locally BEFORE publishing to L1.
+            // This avoids racing the archiver's L1 polling: if the L1 publish happened first, polling
+            // could surface the checkpoint and reject our subsequent local push as duplicate. Pushing
+            // first means the archiver already has the proposed entry when L1 polling fires; the L1
+            // sync path then promotes the existing proposed checkpoint via promoteProposedToCheckpointed
+            // rather than re-adding it.
+            await this.deps.archiver.addBlock(buildResult.block);
+            await this.deps.archiver.addProposedCheckpoint({
+                header: checkpoint.header,
+                checkpointNumber,
+                startBlock: BlockNumber(buildResult.block.number),
+                blockCount: 1,
+                totalManaUsed: checkpoint.header.totalManaUsed.toBigInt(),
+                feeAssetPriceModifier
+            });
+            await this.publisher.enqueueProposeCheckpoint(checkpoint, emptyAttestations, emptyAttestationsSignature);
+            // Automine publishes synchronously in the current slot via `sendRequests`. It must NOT use the
+            // production `sendRequestsAt` (or `canProposeAt`), which always apply the one-slot pipelining
+            // offset — automine is the deliberate non-pipelined exception and builds/publishes in place.
+            const result = await this.publisher.sendRequests(SlotNumber(targetSlot));
+            const successful = result?.successfulActions?.find((a)=>a === 'propose');
+            if (!successful) {
+                this.log.error('Propose action did not succeed under automine', {
+                    slot: targetSlot,
+                    checkpointNumber,
+                    successful: result?.successfulActions,
+                    failed: result?.failedActions
+                });
+                throw new Error(`AutomineSequencer: propose did not succeed for slot ${targetSlot}`);
+            }
+            // Force one full L1-sync cycle synchronously. The local addBlock/addProposedCheckpoint
+            // above advances the proposed tip, but tips.checkpointed and the L1->L2 inbox tree state
+            // only advance when the archiver observes the L1-confirmed checkpoint via its sync loop.
+            await this.deps.archiver.syncImmediate();
+            // Sync the date provider to the L1 block timestamp we just mined.
+            const newL1Ts = await this.deps.ethCheatCodes.lastBlockTimestamp();
+            this.deps.dateProvider.setTime(newL1Ts * 1000);
+            this.lastBuiltSlot = targetSlot;
+            this.log.verbose(`Automine checkpoint published`, {
+                checkpointNumber,
+                blockNumber: nextBlockNumber,
+                slot: targetSlot,
+                l1Timestamp: newL1Ts,
+                txCount: buildResult.numTxs
+            });
+            return buildResult.block;
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    }
+    /**
+   * Warps L1 timestamp to (or past) `targetTimestampSec`, rounded up to the next aztec-slot
+   * boundary, by queuing an empty-checkpoint build at that slot. Mines exactly one L1 block
+   * (the propose tx auto-mined under anvil's automine mode), with the timestamp pre-set so
+   * the mined block lands on the slot boundary.
+   */ async runWarp(targetTimestampSec) {
+        const currentL1Ts = await this.deps.ethCheatCodes.lastBlockTimestamp();
+        if (targetTimestampSec <= currentL1Ts) {
+            this.log.debug(`Warp target ${targetTimestampSec} is not in the future of current L1 ts ${currentL1Ts}`);
+            return;
+        }
+        // Round up to the next aztec-slot boundary so the next build naturally lands on a new slot.
+        const targetSlot = Number(getSlotAtTimestamp(BigInt(targetTimestampSec), this.deps.l1Constants));
+        const slotBoundaryTs = Number(getTimestampForSlot(SlotNumber(targetSlot + 1), this.deps.l1Constants));
+        // Queue the next L1 block at the slot boundary timestamp, then build (and publish) an
+        // empty L2 checkpoint. The propose tx auto-mines a single L1 block at slotBoundaryTs,
+        // and `runBuild` syncs the date provider to the new L1 timestamp.
+        await this.deps.ethCheatCodes.setNextBlockTimestamp(slotBoundaryTs);
+        await this.runBuild({
+            allowEmpty: true
+        });
+        this.log.verbose(`Warped L1 to slot boundary`, {
+            slot: targetSlot + 1,
+            timestamp: slotBoundaryTs
+        });
+    }
+    /**
+   * Rolls L1 back to the block that published `targetCheckpoint`, drops the archiver's
+   * in-memory state to match, and resets internal slot bookkeeping.
+   */ async runRevert(targetCheckpoint) {
+        const checkpointData = await this.deps.l2BlockSource.getCheckpointData({
+            number: CheckpointNumber(targetCheckpoint)
+        });
+        if (!checkpointData) {
+            throw new Error(`AutomineSequencer: checkpoint ${targetCheckpoint} not found in archiver`);
+        }
+        const targetL1Block = Number(checkpointData.l1.blockNumber);
+        this.log.verbose(`Reverting to checkpoint ${targetCheckpoint}`, {
+            targetCheckpoint,
+            targetL1Block,
+            checkpointSlot: checkpointData.header.slotNumber
+        });
+        // Roll the archiver back to the last block of targetCheckpoint before the L1 reorg,
+        // since the archiver needs to fetch the target checkpoint's L1 block hash during rollback.
+        const lastBlockInCheckpoint = BlockNumber(checkpointData.startBlock + checkpointData.blockCount - 1);
+        await this.deps.archiver.rollbackTo(lastBlockInCheckpoint);
+        // Force the P2P block stream to run one cycle immediately so it processes the
+        // chain-pruned event triggered by the archiver rollback above. Without this, the
+        // P2P pool may not have restored rolled-back txs to pending by the time the next
+        // build runs.
+        await this.deps.p2pClient.sync();
+        // Force world-state to process the archiver's prune event immediately, so the next build
+        // doesn't try to insert nullifiers that were already in the pruned checkpoints.
+        await this.deps.worldState.syncImmediate();
+        // Remove all L1 blocks strictly after the target checkpoint's publish block so that
+        // the propose txs for later checkpoints are gone from L1. We use reorg(depth) directly
+        // to keep targetL1Block itself as the new chain tip.
+        const currentL1Block = await this.deps.ethCheatCodes.publicClient.getBlockNumber();
+        const depth = Number(currentL1Block) - targetL1Block;
+        if (depth > 0) {
+            await this.deps.ethCheatCodes.reorg(depth);
+        }
+        // anvil_rollback re-queues the rolled-back txs into the mempool. Clear them so they
+        // don't get re-mined, then reset the publisher nonce tracker so the next propose tx
+        // uses the correct nonce for the post-reorg chain state.
+        await this.deps.ethCheatCodes.rpcCall('anvil_dropAllTransactions', []);
+        this.deps.l1TxUtils.forEach((utils)=>utils.resetNonce());
+        // Reset slot bookkeeping so the next build picks up at the correct slot.
+        this.lastBuiltSlot = Number(checkpointData.header.slotNumber);
+        this.log.verbose(`Reverted to checkpoint ${targetCheckpoint}`, {
+            targetCheckpoint,
+            targetL1Block
+        });
+    }
+    /**
+   * Wraps `checkpointBuilder.buildBlock` with the failed-tx handling shared by both error
+   * and success paths: drops the failed txs from the P2P mempool, and returns `undefined`
+   * when `InsufficientValidTxsError` aborts the build (so the caller skips publishing).
+   */ async tryBuildBlock(checkpointBuilder, pendingTxs, nextBlockNumber, timestamp, allowEmpty, checkpointNumber) {
+        let buildResult;
+        try {
+            buildResult = await checkpointBuilder.buildBlock(pendingTxs, nextBlockNumber, timestamp, {
+                maxTransactions: this.deps.config.maxTxsPerBlock,
+                // Allow empty for explicit-empty builds; require at least 1 valid tx otherwise.
+                minValidTxs: allowEmpty ? 0 : 1,
+                isBuildingProposal: true,
+                maxBlocksPerCheckpoint: 1,
+                perBlockAllocationMultiplier: 1
+            });
+        } catch (err) {
+            // Mirrors production's checkpoint_proposal_job: if every pending tx failed execution and
+            // we didn't reach minValidTxs, drop the failed txs from the mempool so they don't block
+            // the poller forever, then abort this build with no checkpoint published.
+            if (isErrorClass(err, InsufficientValidTxsError)) {
+                await this.dropFailedTxsFromP2P(err.failedTxs);
+                this.log.verbose(`AutomineSequencer: insufficient valid txs, skipping build`, {
+                    checkpointNumber,
+                    processedCount: err.processedCount,
+                    minRequired: err.minRequired,
+                    failedCount: err.failedTxs.length
+                });
+                return undefined;
+            }
+            throw err;
+        }
+        // Drop any txs that failed execution but didn't trigger InsufficientValidTxsError, so we
+        // don't re-pick them up on the next build.
+        await this.dropFailedTxsFromP2P(buildResult.failedTxs);
+        return buildResult;
+    }
+    /** Removes txs that failed execution from the P2P mempool so they don't get retried. */ async dropFailedTxsFromP2P(failedTxs) {
+        if (failedTxs.length === 0) {
+            return;
+        }
+        const failedTxHashes = failedTxs.map((fail)=>fail.tx.getTxHash());
+        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+        await this.deps.p2pClient.handleFailedExecution(failedTxHashes);
+    }
+}

package/dest/sequencer/chain_state_overrides.d.ts

@@ -0,0 +1,61 @@
+import { RollupContract, type SimulationOverridesPlan } from '@aztec/ethereum/contracts';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import { type ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
+import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+type CheckpointSimulationOverridesPlanInput = {
+    /** Target rollup contract. */
+    rollup: RollupContract;
+    /** Checkpoint number to be proposed. */
+    checkpointNumber: CheckpointNumber;
+    /** Logger instance. */
+    log: Logger;
+    /**
+     * The proposed parent checkpoint when pipelining. Its `checkpointNumber` must equal
+     * `checkpointNumber - 1`; the helper enforces this. Mutually exclusive with
+     * `invalidateToPendingCheckpointNumber`.
+     */
+    proposedCheckpointData?: ProposedCheckpointData;
+    /**
+     * The pending checkpoint number we'll end up at after invalidation lands. Mutually exclusive
+     * with `proposedCheckpointData`.
+     */
+    invalidateToPendingCheckpointNumber?: CheckpointNumber;
+    /**
+     * The real on-chain pending checkpoint number (typically `syncedTo.checkpointedCheckpointNumber`).
+     * Used as the snapshot we pin both `pending` and `proven` to avoid prunes in simulation.
+     */
+    checkpointedCheckpointNumber: CheckpointNumber;
+    /**
+     * Chain-level consensus signature context. Used to recompute the parent's `payloadDigest` for the
+     * pipelined simulation override so it matches what `propose` will write into `tempCheckpointLogs[parent]`
+     * once the parent lands.
+     */
+    signatureContext: CoordinationSignatureContext;
+};
+/**
+ * Builds the SimulationOverridesPlan describing the simulated L1 rollup state for a checkpoint's
+ * enqueue-time simulations: `canProposeAt` (in Sequencer.doWork) and the propose-related sims
+ * (validateBlockHeader, simulateProposeTx). The plan reflects "as if our pipelined parent
+ * checkpoint has landed and any required invalidation has executed" — the gap that needs to be
+ * bridged at enqueue time.
+ *
+ * Pipelining (`proposedCheckpointData`) and invalidation (`invalidateToPendingCheckpointNumber`)
+ * are mutually exclusive; passing both throws.
+ */
+export declare function buildCheckpointSimulationOverridesPlan(input: CheckpointSimulationOverridesPlanInput): Promise<SimulationOverridesPlan | undefined>;
+type PipelinedParentFeeHeaderInput = {
+    checkpointNumber: CheckpointNumber;
+    proposedCheckpointData: ProposedCheckpointData;
+    rollup: RollupContract;
+    log: Logger;
+};
+/**
+ * Derives the pending parent fee header used during pipelined proposal simulation. Returns
+ * `undefined` only when no grandparent exists (i.e. the proposed parent is the genesis
+ * checkpoint); all other failure modes (missing grandparent state, missing fee header, RPC
+ * errors) throw so callers don't silently desync the fee-header override.
+ */
+export declare function computePipelinedParentFeeHeader(input: PipelinedParentFeeHeaderInput): Promise<import("@aztec/ethereum/contracts").FeeHeader | undefined>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fc3RhdGVfb3ZlcnJpZGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL2NoYWluX3N0YXRlX292ZXJyaWRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUE4QixLQUFLLHVCQUF1QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckgsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssc0JBQXNCLEVBQWtDLE1BQU0sMEJBQTBCLENBQUM7QUFDdkcsT0FBTyxLQUFLLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUV0RSxLQUFLLHNDQUFzQyxHQUFHO0lBQzVDLDhCQUE4QjtJQUM5QixNQUFNLEVBQUUsY0FBYyxDQUFDO0lBQ3ZCLHdDQUF3QztJQUN4QyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztJQUNuQyx1QkFBdUI7SUFDdkIsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUNaOzs7O09BSUc7SUFDSCxzQkFBc0IsQ0FBQyxFQUFFLHNCQUFzQixDQUFDO0lBQ2hEOzs7T0FHRztJQUNILG1DQUFtQyxDQUFDLEVBQUUsZ0JBQWdCLENBQUM7SUFDdkQ7OztPQUdHO0lBQ0gsNEJBQTRCLEVBQUUsZ0JBQWdCLENBQUM7SUFDL0M7Ozs7T0FJRztJQUNILGdCQUFnQixFQUFFLDRCQUE0QixDQUFDO0NBQ2hELENBQUM7QUFFRjs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0Isc0NBQXNDLENBQzFELEtBQUssRUFBRSxzQ0FBc0MsR0FDNUMsT0FBTyxDQUFDLHVCQUF1QixHQUFHLFNBQVMsQ0FBQyxDQXNEOUM7QUFxQkQsS0FBSyw2QkFBNkIsR0FBRztJQUNuQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztJQUNuQyxzQkFBc0IsRUFBRSxzQkFBc0IsQ0FBQztJQUMvQyxNQUFNLEVBQUUsY0FBYyxDQUFDO0lBQ3ZCLEdBQUcsRUFBRSxNQUFNLENBQUM7Q0FDYixDQUFDO0FBRUY7Ozs7O0dBS0c7QUFDSCx3QkFBc0IsK0JBQStCLENBQUMsS0FBSyxFQUFFLDZCQUE2QixzRUF3QnpGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain_state_overrides.d.ts","sourceRoot":"","sources":["../../src/sequencer/chain_state_overrides.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA8B,KAAK,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACrH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,sBAAsB,EAAkC,MAAM,0BAA0B,CAAC;AACvG,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAEtE,KAAK,sCAAsC,GAAG;IAC5C,8BAA8B;IAC9B,MAAM,EAAE,cAAc,CAAC;IACvB,wCAAwC;IACxC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,mCAAmC,CAAC,EAAE,gBAAgB,CAAC;IACvD;;;OAGG;IACH,4BAA4B,EAAE,gBAAgB,CAAC;IAC/C;;;;OAIG;IACH,gBAAgB,EAAE,4BAA4B,CAAC;CAChD,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,sCAAsC,CAC1D,KAAK,EAAE,sCAAsC,GAC5C,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAsD9C;AAqBD,KAAK,6BAA6B,GAAG;IACnC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,+BAA+B,CAAC,KAAK,EAAE,6BAA6B,sEAwBzF"}