@aztec/sequencer-client 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/src/publisher/l1_to_l2_messaging.ts

@@ -0,0 +1,85 @@
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { tryJsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { InboxAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { decodeEventLog, getContract } from 'viem';
+
+/**
+ * Sends an L1-to-L2 message via the Inbox contract and returns its hash and global leaf index.
+ * Test helper copied from the end-to-end fixtures so this integration test can live in sequencer-client.
+ */
+export async function sendL1ToL2Message(
+  message: { recipient: AztecAddress; content: Fr; secretHash: Fr },
+  ctx: {
+    l1Client: ExtendedViemWalletClient;
+    l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress' | 'rollupAddress'>;
+  },
+) {
+  const logger = createLogger('sequencer-client:l1_to_l2_messaging');
+  const inbox = getContract({
+    address: ctx.l1ContractAddresses.inboxAddress.toString(),
+    abi: InboxAbi,
+    client: ctx.l1Client,
+  });
+
+  const { recipient, content, secretHash } = message;
+
+  const version = await new RollupContract(ctx.l1Client, ctx.l1ContractAddresses.rollupAddress.toString()).getVersion();
+
+  // We inject the message to Inbox
+  const txHash = await inbox.write.sendL2Message(
+    [{ actor: recipient.toString(), version: BigInt(version) }, content.toString(), secretHash.toString()],
+    {
+      gas: 1_000_000n,
+    },
+  );
+  logger.info(`L1 to L2 message sent in tx ${txHash}`);
+
+  // We check that the message was correctly injected by checking the emitted event
+  const txReceipt = await ctx.l1Client.waitForTransactionReceipt({ hash: txHash });
+
+  if (txReceipt.status !== 'success') {
+    throw new Error(`L1 to L2 message failed to be sent in tx ${txHash}. Status: ${txReceipt.status}`);
+  }
+
+  logger.info(`L1 to L2 message receipt retrieved for tx ${txReceipt.transactionHash}`, txReceipt);
+
+  if (txReceipt.transactionHash !== txHash) {
+    throw new Error(`Receipt transaction hash mismatch: ${txReceipt.transactionHash} !== ${txHash}`);
+  }
+
+  // Filter for MessageSent events from the Inbox contract by trying to decode each log
+  const messageSentLogs = txReceipt.logs
+    .filter(log => log.address.toLowerCase() === ctx.l1ContractAddresses.inboxAddress.toString().toLowerCase())
+    .map(log => {
+      try {
+        const decoded = decodeEventLog({
+          abi: InboxAbi,
+          data: log.data,
+          topics: log.topics,
+        });
+        return { log, decoded };
+      } catch {
+        return null; // Not a decodable event from this ABI
+      }
+    })
+    .filter((item): item is { log: any; decoded: any } => item !== null && item.decoded.eventName === 'MessageSent');
+
+  if (messageSentLogs.length !== 1) {
+    throw new Error(
+      `Wrong number of MessageSent logs found in ${txHash} transaction (got ${messageSentLogs.length} expected 1)\n${tryJsonStringify(messageSentLogs.map(item => item.log))}`,
+    );
+  }
+
+  // We already have the decoded event
+  const topics = messageSentLogs[0].decoded;
+  const receivedMsgHash = topics.args.hash;
+  const receivedGlobalLeafIndex = topics.args.index;
+
+  return { msgHash: Fr.fromHexString(receivedMsgHash), globalLeafIndex: new Fr(receivedGlobalLeafIndex), txReceipt };
+}

package/src/publisher/sequencer-publisher.ts

@@ -117,6 +117,7 @@ type L1ProcessArgs = {
 export const Actions = [
   'invalidate-by-invalid-attestation',
   'invalidate-by-insufficient-attestations',
+  'prune',
   'propose',
   'governance-signal',
   'vote-offenses',
@@ -177,6 +178,8 @@ export class SequencerPublisher {
   protected log: Logger;
   protected ethereumSlotDuration: bigint;
   protected aztecSlotDuration: bigint;
+  private readonly previousL1BlockWaitTimeoutMs: number;
+  private readonly previousL1BlockWaitPollIntervalMs: number;
 
   /** Date provider for wall-clock time. */
   private readonly dateProvider: DateProvider;
@@ -205,7 +208,13 @@ export class SequencerPublisher {
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    private config: Pick<SequencerPublisherConfig, 'fishermanMode' | 'l1TxFailedStore'> &
+    private config: Pick<
+      SequencerPublisherConfig,
+      | 'fishermanMode'
+      | 'l1TxFailedStore'
+      | 'sequencerPublisherPreviousL1BlockWaitTimeoutMs'
+      | 'sequencerPublisherPreviousL1BlockWaitPollIntervalMs'
+    > &
       Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
@@ -225,6 +234,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;
@@ -458,7 +469,9 @@ export class SequencerPublisher {
 
       if (bundleResult.kind === 'aborted') {
         this.logDroppedInSim(bundleResult.droppedRequests);
-        void this.backupDroppedInSim(bundleResult.droppedRequests);
+        void this.backupDroppedInSim(bundleResult.droppedRequests).catch(err =>
+          this.log.error(`Failed to backup requests dropped in simulation`, err),
+        );
         return undefined;
       }
 
@@ -617,34 +630,69 @@ export class SequencerPublisher {
 
   /*
    * 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().
    */
   public async sendRequestsAt(targetSlot: SlotNumber): Promise<SendRequestsResult | undefined> {
-    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;
+    await this.waitForTargetSlot(targetSlot);
     if (this.interrupted) {
       return undefined;
     }
-    const sleepMs = submitAfterMs - this.dateProvider.now();
-    if (sleepMs > 0) {
-      this.log.debug(`Sleeping ${sleepMs}ms before sending requests`, {
-        targetSlot,
-        submitAfterMs,
-      });
+
+    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.
+   */
+  private async waitForTargetSlot(targetSlot: SlotNumber): Promise<void> {
+    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);
     }
-    if (this.interrupted) {
-      return undefined;
+
+    // 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);
+      }
     }
-    return this.sendRequests(targetSlot);
   }
 
   private callbackBundledTransactions(
@@ -866,7 +914,11 @@ export class SequencerPublisher {
     const logData = { ...checkpoint, 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(
@@ -1015,6 +1067,47 @@ export class SequencerPublisher {
     );
   }
 
+  /**
+   * 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.
+   */
+  public async enqueuePruneIfPrunable(slotNumber: SlotNumber): Promise<boolean> {
+    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: L1TxRequest = {
+      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. */
   public async enqueueSlashingActions(
     actions: ProposerSlashAction[],

package/src/publisher/write_json.ts

@@ -0,0 +1,78 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { BatchedBlob, Blob, getEthBlobEvaluationInputs, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L2Block } from '@aztec/stdlib/block';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+
+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: string,
+  checkpointHeader: CheckpointHeader,
+  block: L2Block,
+  l1ToL2Content: Fr[],
+  blobs: Blob[],
+  batchedBlob: BatchedBlob,
+  recipientAddress: AztecAddress,
+  deployerAddress: `0x${string}`,
+): Promise<void> {
+  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: Fr | Buffer | EthAddress | AztecAddress, 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');
+}

package/src/sequencer/automine/README.md

@@ -19,11 +19,11 @@ Compared to the production `Sequencer`:
 - No validator orchestration, attestation collection, or P2P proposal gossip.
 - No slashing, no governance votes, no `SequencerEvents`.
 
-Consumers (archiver, world-state, `EpochTestSettler`) observe L1 and the archiver tip directly rather than listening for sequencer events.
+Consumers (archiver, world-state) observe L1 and the archiver tip directly rather than listening for sequencer events.
 
 ## Serial-queue invariant
 
-Every operation — mempool-driven block builds, explicit empty-block builds, time warps, and reorgs — is serialized through a single `SerialQueue`. They never interleave.
+Every operation — mempool-driven block builds, explicit empty-block builds, time warps, reorgs, and synthetic epoch proving — is serialized through a single `SerialQueue`. They never interleave.
 
 Public entry points:
 
@@ -32,15 +32,29 @@ Public entry points:
 | `buildIfPending()` | Enqueues a mempool-driven build. Coalesces bursts into one job. |
 | `buildEmptyBlock()` | Enqueues a forced empty-block build. |
 | `warpTo(ts)` / `warpBy(delta)` | Advances L1 time to a slot boundary. |
+| `prove(upToCheckpoint?)` | Synthetically proves epochs up to a checkpoint (default: the latest checkpointed): writes the epoch out hashes into the L1 Outbox so L2-to-L1 messages become consumable, then advances the proven tip. No real proof. Clamps to the checkpointed tip and no-ops when already proven. |
 | `revertToCheckpoint(n)` | Rolls L1 back to the block that published checkpoint `n`, then resets archiver, world-state, and P2P pool. |
 | `syncPoint()` | Awaits the queue reaching idle. |
 
+## Time control
+
+The AutomineSequencer owns L1 time in the local network (replacing the deleted `AnvilTestWatcher`). It builds and publishes each checkpoint at the next aztec-slot boundary, and `warpTo` / `warpBy` advance the clock by publishing an empty checkpoint at the target slot. Before every build, warp, and prove it reconciles the injected `TestDateProvider` to the latest *mined* L1 timestamp, so node-side consumers of `dateProvider.now()` stay aligned with L1 even when an unrelated L1 tx mines a block between our builds. It never advances the clock to the pending, un-mined timestamp.
+
+## Publish-failure recovery
+
+A failed propose mines no checkpoint on L1 (it reverts inside the multicall or is never sent), so recovery is purely local — there is **no L1 reorg**. The optimistic archiver insert (the proposed block plus its proposed checkpoint) is rolled back via `archiver.removeUncheckpointedBlocksAfter`, which removes the uncheckpointed block and evicts the proposed checkpoint that referenced it. `p2pClient.sync()` then observes the lowered proposed tip and returns the block's txs to the pending pool, `worldState.syncImmediate()` drops any applied effects, and the L1 nonce is reset. The build is not retried inline; the mempool poller re-enqueues one once the txs are back in the pool.
+
 ## Entry points
 
 **Factory** — `createAutomineSequencer` in `automine_factory.ts` wires up all dependencies (publisher manager, keystore, cheat codes, etc.), starts the `PublisherManager`, and returns an unstarted `AutomineSequencer`. The caller (`AztecNodeService.createAndSync` in `aztec-node/src/aztec-node/server.ts`) invokes `AutomineSequencer.start()` separately. It is called by the full node when `aztecTargetCommitteeSize == 0`.
 
 **Test fixture** — `AUTOMINE_E2E_OPTS` in `end-to-end/src/fixtures/fixtures.ts` is the test-side entry point. Pass it to `setup()` to get a node + `AutomineSequencer` instead of the production sequencer stack.
 
-## Epoch proving caveat
+## Epoch proving
+
+There is no real prover in the automine setup, so epochs are settled synthetically: the epoch out hash is written into the L1 Outbox via cheat codes and the rollup's proven tip is advanced — the local-network equivalent of an epoch proof landing on L1. The grouping/out-hash logic lives in the shared `settleEpochOutbox` helper in `@aztec/prover-client/test`, used by both proving drivers below.
+
+Who drives proving depends on the `automineEnableProveEpoch` config flag:
 
-Epoch proving remains manual under `AUTOMINE_E2E_OPTS`. The e2e `setup()` fixture does NOT wire an `EpochTestSettler` — that observer is only attached in `local-network.ts`. Tests that cross epoch boundaries must therefore advance the proven anchor explicitly via `cheatCodes.rollup.markAsProven(...)`. See `e2e_lending_contract.test.ts` (which calls `progressSlots` in `simulators/lending_simulator.ts`) and `e2e_pruned_blocks.test.ts` for real examples.
+- **Local network / sandbox** (`automineEnableProveEpoch: true`): the AutomineSequencer runs an auto-prove loop that calls `prove()` as checkpoints land, through the same serial queue as its builds. This replaces the standalone `EpochTestSettler`, which used to race the build loop. The loop also reconciles the clock on each tick.
+- **e2e tests** (`AUTOMINE_E2E_OPTS`, flag off): proving is manual so tests stay deterministic. Cross-epoch tests advance the proven anchor explicitly via `node.prove(...)`, `cheatCodes.rollup.markAsProven(...)`, or a hand-driven `EpochTestSettler`. See `e2e_pruned_blocks.test.ts` and `e2e_epochs/epochs_partial_proof_multi_root.test.ts` for real examples.

package/src/sequencer/automine/automine_factory.ts

@@ -40,9 +40,14 @@ export type CreateAutomineSequencerArgs = {
   worldStateSynchronizer: WorldStateSynchronizer;
   archiver: L2BlockSource &
     L1ToL2MessageSource &
-    Pick<Archiver, 'rollbackTo' | 'addBlock' | 'addProposedCheckpoint' | 'syncImmediate'>;
+    Pick<
+      Archiver,
+      'rollbackTo' | 'addBlock' | 'addProposedCheckpoint' | 'syncImmediate' | 'removeUncheckpointedBlocksAfter'
+    >;
   p2pClient: P2P & Pick<ConcreteP2PClient, 'sync'>;
   l1Constants: { l1GenesisTime: bigint; slotDuration: number; ethereumSlotDuration: number; rollupManaLimit: number };
+  /** When true, run the auto-settle / clock-reconcile loop (local-network only). */
+  autoSettle?: boolean;
   log: Logger;
 };
 
@@ -71,6 +76,7 @@ export async function createAutomineSequencer({
   archiver,
   p2pClient,
   l1Constants,
+  autoSettle,
   log,
 }: CreateAutomineSequencerArgs): Promise<AutomineSequencer> {
   const publisherManager = new PublisherManager(l1TxUtils, getPublisherConfigFromSequencerConfig(config), {
@@ -136,6 +142,7 @@ export async function createAutomineSequencer({
     config,
     archiver,
     l1TxUtils: reorgResetL1TxUtils,
+    autoSettle,
     stopExtras: () => publisherManager.stop(),
     log: log.createChild('automine-sequencer'),
   });