@aztec/aztec 0.0.1-commit.24de95ac → 0.0.1-commit.2606882

package/src/local-network/local-network.ts

@@ -0,0 +1,303 @@
+#!/usr/bin/env -S node --no-warnings
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { waitForPublicClient } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { NULL_KEY } from '@aztec/ethereum/constants';
+import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { SequencerState } from '@aztec/sequencer-client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { TxStatus } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
+import {
+  type TelemetryClient,
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+} from '@aztec/telemetry-client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { createAccountLogs } from '../cli/util.js';
+import { DefaultMnemonic } from '../mnemonic.js';
+import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
+import { EpochTestSettler } from '../testing/epoch_test_settler.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
+import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
+import { getSponsoredFPCAddress } from './sponsored_fpc.js';
+
+const logger = createLogger('local-network');
+
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
+
+const localAnvil = foundry;
+
+/**
+ * Function to deploy our L1 contracts to the local network L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export async function deployContractsToL1(
+  aztecNodeConfig: AztecNodeConfig,
+  privateKey: Hex,
+  opts: {
+    genesisArchiveRoot?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
+  } = {},
+): Promise<L1ContractAddresses> {
+  await waitForPublicClient(aztecNodeConfig);
+
+  const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+    ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+    ...aztecNodeConfig,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+    feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+    aztecTargetCommitteeSize: 0, // no committee in local network
+    slasherEnabled: false, // no slashing in local network
+    realVerifier: false,
+  });
+
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
+  aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
+
+  return l1Contracts.l1ContractAddresses;
+}
+
+/** Local network settings. */
+export type LocalNetworkConfig = AztecNodeConfig & {
+  /** Mnemonic used to derive the L1 deployer private key.*/
+  l1Mnemonic: string;
+  /** Whether to deploy test accounts on local network start.*/
+  testAccounts: boolean;
+};
+
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional local network settings.
+ */
+export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {}, userLog: LogFn) {
+  // local network is meant for test envs. We should only need one l1RpcUrl
+  const l1RpcUrl = config.l1RpcUrls?.[0];
+  if (!l1RpcUrl) {
+    throw new Error('An L1 RPC URL is required');
+  }
+  if ((config.l1RpcUrls?.length || 0) > 1) {
+    logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
+  }
+
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+  };
+  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+  if (
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
+  ) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
+  }
+  if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${Buffer.from(privKey!).toString('hex')}`]);
+  }
+  aztecNodeConfig.coinbase = EthAddress.fromString(
+    privateKeyToAddress(aztecNodeConfig.validatorPrivateKeys.getValue()[0]),
+  );
+
+  const initialAccounts = await (async () => {
+    if (config.testAccounts === true || config.testAccounts === undefined) {
+      if (aztecNodeConfig.p2pEnabled) {
+        userLog(`Not setting up test accounts as we are connecting to a network`);
+      } else {
+        userLog(`Setting up test accounts`);
+        return await getInitialTestAccountsData();
+      }
+    }
+    return [];
+  })();
+
+  const bananaFPC = await getBananaFPCAddress(initialAccounts);
+  const sponsoredFPC = await getSponsoredFPCAddress();
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
+
+  const dateProvider = new TestDateProvider();
+
+  let cheatcodes: EthCheatCodes | undefined;
+  let rollupAddress: EthAddress | undefined;
+  let watcher: AnvilTestWatcher | undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    ({ rollupAddress } = await deployContractsToL1(
+      aztecNodeConfig,
+      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
+      {
+        genesisArchiveRoot,
+        feeJuicePortalInitialBalance: fundingNeeded,
+      },
+    ));
+
+    const chain =
+      aztecNodeConfig.l1RpcUrls.length > 0
+        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
+        : { chainInfo: localAnvil };
+
+    const publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
+    });
+
+    cheatcodes = new EthCheatCodes([l1RpcUrl], dateProvider);
+
+    watcher = new AnvilTestWatcher(cheatcodes, rollupAddress, publicClient, dateProvider);
+    watcher.setisLocalNetwork(true);
+    watcher.setIsMarkingAsProven(false); // Do not mark as proven in the watcher. It's marked in the epochTestSettler after the out hash is set.
+
+    await watcher.start();
+  }
+
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob client client inside the local network, no http connectivity
+  const blobClient = createBlobClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
+
+  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
+  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
+  // warping time out from under an in-progress block.
+  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
+  const sequencer = node.getSequencer()?.getSequencer();
+  if (sequencer) {
+    const idleStates: Set<string> = new Set([
+      SequencerState.STOPPED,
+      SequencerState.STOPPING,
+      SequencerState.IDLE,
+      SequencerState.SYNCHRONIZING,
+    ]);
+    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
+    // Under proposer pipelining the L1 publish for slot N happens during wall-clock slot N,
+    // but the proposer for slot N has already built the checkpoint during slot N-1 and is
+    // waiting for L1 to advance. We need to fast-forward L1 to wake that wait — and the wait
+    // we have to break first is `waitForValidParentCheckpointOnL1`, which blocks the
+    // checkpoint_proposal_job's background submission task until the archiver has synced past
+    // the build slot. That wait happens *before* `PUBLISHING_CHECKPOINT` is set, so a hook on
+    // that state transition would be circular (L1 has to advance before the state we'd use to
+    // advance L1 fires). The earliest pre-wait signal is `block-proposed`, which the sequencer
+    // emits once each block is built. In sandbox single-block-per-slot mode this is
+    // effectively "checkpoint built", and the watcher warp is harmless if a subsequent
+    // assembly/validation/parent-wait step aborts: L1 just sits one slot ahead, which the
+    // cascade absorbs.
+    if (watcher) {
+      sequencer.on('block-proposed', ({ slot }) => watcher!.setProposedTargetSlot(Number(slot)));
+    }
+  }
+
+  let epochTestSettler: EpochTestSettler | undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    epochTestSettler = new EpochTestSettler(
+      cheatcodes!,
+      rollupAddress!,
+      node.getBlockSource(),
+      logger.createChild('epoch-settler'),
+      { pollingIntervalMs: 200 },
+    );
+    await epochTestSettler.start();
+  }
+
+  if (initialAccounts.length) {
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
+
+    userLog('Setting up funded test accounts...');
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts, setupWaitOpts);
+    const accLogs = await createAccountLogs(accountManagers, wallet);
+    userLog(accLogs.join(''));
+
+    userLog('Publishing standard AuthRegistry contract...');
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
+
+    userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
+
+    // We no longer need the wallet once we've setup the accounts so we stop the underlying PXE job queue
+    await wallet.stop();
+  }
+
+  const stop = async () => {
+    await node.stop();
+    await watcher?.stop();
+    await epochTestSettler?.stop();
+  };
+
+  return { node, stop };
+}
+
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export async function createAztecNode(
+  config: Partial<AztecNodeConfig> = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
+  options: { genesis?: GenesisData } = {},
+) {
+  // TODO(#12272): will clean this up. This is criminal.
+  // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+  };
+  const node = await AztecNodeService.createAndSync(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
+  return node;
+}

package/src/{sandbox → local-network}/sponsored_fpc.ts

@@ -1,3 +1,4 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
   type ContractInstanceWithAddress,
   getContractInstanceFromInstantiationParams,
@@ -13,11 +14,11 @@ async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
   });
 }
 
-export async function getSponsoredFPCAddress() {
+export async function getSponsoredFPCAddress(): Promise<AztecAddress> {
   return (await getSponsoredFPCInstance()).address;
 }
 
-export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet) {
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<AztecAddress> {
   const fpc = await getSponsoredFPCInstance();
   // The following is no-op if the contract is already registered
   await wallet.registerContract(fpc, SponsoredFPCContract.artifact);

package/src/testing/anvil_test_watcher.ts

@@ -1,5 +1,6 @@
-import type { ViemClient } from '@aztec/ethereum';
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -8,6 +9,11 @@ import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 
+export type AnvilTestWatcherOpts = {
+  isLocalNetwork?: boolean;
+  isMarkingAsProven?: boolean;
+};
+
 /**
  * Represents a watcher for a rollup contract.
  *
@@ -16,11 +22,12 @@ import { type GetContractReturnType, getAddress, getContract } from 'viem';
  * block within the slot. And if so, it will time travel into the next slot.
  */
 export class AnvilTestWatcher {
-  private isSandbox: boolean = false;
+  private isLocalNetwork;
+  private isMarkingAsProven;
 
   private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
   private rollupCheatCodes: RollupCheatCodes;
-  private l2SlotDuration!: bigint;
+  private l2SlotDuration!: number;
 
   private filledRunningPromise?: RunningPromise;
   private syncDateProviderPromise?: RunningPromise;
@@ -28,13 +35,27 @@ export class AnvilTestWatcher {
 
   private logger: Logger = createLogger(`aztecjs:utils:watcher`);
 
-  private isMarkingAsProven = true;
+  // Optional callback to check if there are pending txs in the mempool.
+  private getPendingTxCount?: () => Promise<number>;
+
+  // Optional callback to check if the sequencer is actively building a block.
+  private isSequencerBuilding?: () => boolean;
+
+  // Tracks when we first observed the current unfilled slot with pending txs (real wall time).
+  private unfilledSlotFirstSeen?: { slot: number; realTime: number };
+
+  // Latest target slot for which the proposer has built a block destined for L1 but which has
+  // not yet been committed. Set by the proposer-pipelining hook from `block-proposed` events so
+  // the watcher can advance L1 (and the injected date provider) to the target slot ahead of the
+  // publisher's `sendRequestsAt` sleep, instead of waiting a full wall-clock slot.
+  private proposedTargetSlot?: number;
 
   constructor(
     private cheatcodes: EthCheatCodes,
     rollupAddress: EthAddress,
     l1Client: ViemClient,
     private dateProvider?: TestDateProvider,
+    opts: AnvilTestWatcherOpts = {},
   ) {
     this.rollup = getContract({
       address: getAddress(rollupAddress.toString()),
@@ -46,6 +67,9 @@ export class AnvilTestWatcher {
       rollupAddress,
     });
 
+    this.isLocalNetwork = opts.isLocalNetwork ?? false;
+    this.isMarkingAsProven = opts.isMarkingAsProven ?? true;
+
     this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
   }
 
@@ -54,8 +78,30 @@ export class AnvilTestWatcher {
     this.isMarkingAsProven = isMarkingAsProven;
   }
 
-  setIsSandbox(isSandbox: boolean) {
-    this.isSandbox = isSandbox;
+  setisLocalNetwork(isLocalNetwork: boolean) {
+    this.isLocalNetwork = isLocalNetwork;
+  }
+
+  /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */
+  setGetPendingTxCount(fn: () => Promise<number>) {
+    this.getPendingTxCount = fn;
+  }
+
+  /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */
+  setIsSequencerBuilding(fn: () => boolean) {
+    this.isSequencerBuilding = fn;
+  }
+
+  /**
+   * Records the target slot for which the proposer has built a block destined for L1. Used by
+   * the local-network watcher to fast-forward L1 (and the injected date provider) ahead of the
+   * pipelined publisher's `sendRequestsAt` sleep so it ends promptly instead of waiting a full
+   * wall-clock slot. Only ratchets up — late warps for stale slots are no-ops.
+   */
+  setProposedTargetSlot(slot: number) {
+    if (this.proposedTargetSlot === undefined || slot > this.proposedTargetSlot) {
+      this.proposedTargetSlot = slot;
+    }
   }
 
   async start() {
@@ -68,7 +114,7 @@ export class AnvilTestWatcher {
 
     // If auto mining is not supported (e.g., we are on a real network), then we
     // will simple do nothing. But if on an anvil or the like, this make sure that
-    // the sandbox and tests don't break because time is frozen and we never get to
+    // the local network and tests don't break because time is frozen and we never get to
     // the next slot.
     const isAutoMining = await this.cheatcodes.isAutoMining();
 
@@ -105,60 +151,123 @@ export class AnvilTestWatcher {
   }
 
   async syncDateProviderToL1IfBehind() {
-    // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
+    // this doesn't apply to the local network, because we don't have a date provider in the local network
     if (!this.dateProvider) {
       return;
     }
 
-    const l1Time = (await this.cheatcodes.timestamp()) * 1000;
+    const l1Time = (await this.cheatcodes.lastBlockTimestamp()) * 1000;
     const wallTime = this.dateProvider.now();
     if (l1Time > wallTime) {
       this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
       this.dateProvider.setTime(l1Time);
     } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
-      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
-      await this.cheatcodes.warp(Math.ceil(wallTime / 1000));
+      // Warp L1 to the slot boundary at-or-before wall time. Rounding to a slot boundary (rather than
+      // `ceil(wallTime / 1000)`) keeps this loop's target aligned with `warpTimeIfNeeded`'s
+      // `nextSlotTimestamp` target, avoiding a race where the two loops pick timestamps a fraction of
+      // a second apart and one of them is then rejected by anvil as non-monotonic.
+      const wallSec = Math.floor(wallTime / 1000);
+      const targetSlot = await this.rollup.read.getSlotAt([BigInt(wallSec)]);
+      const targetTimestamp = Number(await this.rollup.read.getTimestampForSlot([targetSlot]));
+      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to slot ${targetSlot} boundary`);
+      await this.warpToTimestamp(targetTimestamp);
     }
   }
 
   async warpTimeIfNeeded() {
     try {
-      const currentSlot = await this.rollup.read.getCurrentSlot();
-      const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
-      const blockLog = await this.rollup.read.getBlock([pendingBlockNumber]);
-      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([currentSlot + 1n]));
-
-      if (currentSlot === blockLog.slotNumber) {
-        // We should jump to the next slot
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, {
-            resetBlockInterval: true,
-          });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+      const currentSlot = SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+      const pendingCheckpointNumber = await this.rollup.read.getPendingCheckpointNumber();
+      const checkpointLog = await this.rollup.read.getCheckpoint([pendingCheckpointNumber]);
+      const nextSlot = SlotNumber(currentSlot + 1);
+      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]));
+
+      if (BigInt(currentSlot) === checkpointLog.slotNumber) {
+        // The current slot has been filled, we should jump to the next slot.
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
         }
+        return;
+      }
 
-        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+      // If we are not in local network, we don't need to warp time
+      if (!this.isLocalNetwork) {
         return;
       }
 
-      // If we are not in sandbox, we don't need to warp time
-      if (!this.isSandbox) {
+      // Pipelined-publish shortcut: if the proposer has built a block destined for a slot
+      // beyond the current L1 slot, fast-forward L1 to that slot's timestamp so the publisher's
+      // `sendRequestsAt(targetSlot)` sleep ends and the multicall mines inside the target slot.
+      // Without this, the publisher waits up to a full real-time slot for wall clock to catch up.
+      if (this.proposedTargetSlot !== undefined && this.proposedTargetSlot > currentSlot) {
+        const targetSlotTimestamp = Number(
+          await this.rollup.read.getTimestampForSlot([BigInt(this.proposedTargetSlot)]),
+        );
+        if (await this.warpToTimestamp(targetSlotTimestamp)) {
+          this.logger.info(`Warped L1 to target slot ${this.proposedTargetSlot} for pipelined publish`);
+        }
         return;
       }
 
+      // If there are pending txs and the sequencer missed them, warp quickly (after a 2s real-time debounce) so the
+      // sequencer can retry in the next slot. Without this, we'd have to wait a full real-time slot duration (~36s) for
+      // the dateProvider to catch up to the next slot timestamp. We skip the warp if the sequencer is actively building
+      // to avoid invalidating its in-progress work.
+      if (this.getPendingTxCount) {
+        const pendingTxs = await this.getPendingTxCount();
+        if (pendingTxs > 0) {
+          if (this.isSequencerBuilding?.()) {
+            this.unfilledSlotFirstSeen = undefined;
+            return;
+          }
+
+          const realNow = Date.now();
+          if (!this.unfilledSlotFirstSeen || this.unfilledSlotFirstSeen.slot !== currentSlot) {
+            this.unfilledSlotFirstSeen = { slot: currentSlot, realTime: realNow };
+            return;
+          }
+
+          if (realNow - this.unfilledSlotFirstSeen.realTime > 2000) {
+            if (await this.warpToTimestamp(nextSlotTimestamp)) {
+              this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
+            }
+            this.unfilledSlotFirstSeen = undefined;
+          }
+
+          return;
+        }
+      }
+
+      // Fallback: warp when the dateProvider time has passed the next slot timestamp.
       const currentTimestamp = this.dateProvider?.now() ?? Date.now();
       if (currentTimestamp > nextSlotTimestamp * 1000) {
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, { resetBlockInterval: true });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+          this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
         }
-
-        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
       }
     } catch {
       this.logger.error('mineIfSlotFilled failed');
     }
   }
+
+  /**
+   * Warps L1 to `timestamp`, unless L1 is already at or past it. Returns true when a warp actually
+   * happened, false when skipped or on error. Callers use the return value to gate success logs.
+   */
+  private async warpToTimestamp(timestamp: number): Promise<boolean> {
+    try {
+      // Anvil rejects evm_setNextBlockTimestamp values <= the current block's timestamp. The two
+      // watcher loops can race and pick targets a fraction of a second apart; skip here rather than
+      // letting the second one error out noisily.
+      const lastTimestamp = await this.cheatcodes.lastBlockTimestamp();
+      if (timestamp <= lastTimestamp) {
+        return false;
+      }
+      await this.cheatcodes.warp(timestamp, { resetBlockInterval: true });
+      return true;
+    } catch (e) {
+      this.logger.error(`Failed to warp to timestamp ${timestamp}: ${e}`);
+      return false;
+    }
+  }
 }