@aztec/aztec 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/src/testing/cheat_codes.ts

@@ -1,15 +1,10 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { retryUntil } from '@aztec/foundation/retry';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
- * A class that provides utility functions for interacting with the chain.
- * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
- * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
- * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
  */
 export class CheatCodes {
   constructor(
@@ -29,51 +24,25 @@ export class CheatCodes {
   }
 
   /**
-   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
-   * by the slot number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
-   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+   * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
-    const currentL2BlockNumber: BlockNumber = await node.getBlockNumber();
-
-    // We warp the L1 timestamp
-    await this.eth.warp(targetTimestamp, { resetBlockInterval: true });
-
-    // Wait until an L2 block is mined
-    const sequencer = sequencerClient.getSequencer();
-    const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
-    sequencer.updateConfig({ minTxsPerBlock: 0 });
-
-    await retryUntil(
-      async () => {
-        const newL2BlockNumber: BlockNumber = await node.getBlockNumber();
-        return newL2BlockNumber > currentL2BlockNumber;
-      },
-      'new block after warping L2 time',
-      36,
-      1,
-    );
-
-    // Restore original minTxsPerBlock
-    sequencer.updateConfig({ minTxsPerBlock });
+  warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastTo(Number(targetTimestamp));
   }
 
   /**
-   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
-   * number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
-   * @param duration - The duration to advance time by (in seconds)
+   * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+   * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+   * queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param duration - The duration to advance time by (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number) {
-    const currentTimestamp = await this.eth.lastBlockTimestamp();
-    const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
-    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+  warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastBy(Number(duration));
   }
 }

package/src/testing/epoch_test_settler.ts

@@ -1,10 +1,9 @@
-import { Fr } from '@aztec/aztec.js/fields';
 import { type EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { type EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
+import { settleEpochOutbox } from '@aztec/prover-client/test';
 import { EpochMonitor } from '@aztec/prover-node';
 import type { EthAddress, L2BlockSource } from '@aztec/stdlib/block';
-import { computeEpochOutHash } from '@aztec/stdlib/messaging';
 
 export class EpochTestSettler {
   private rollupCheatCodes: RollupCheatCodes;
@@ -31,34 +30,12 @@ export class EpochTestSettler {
   }
 
   async handleEpochReadyToProve(epoch: EpochNumber): Promise<boolean> {
-    const checkpointedBlocks = await this.l2BlockSource.getCheckpointedBlocksForEpoch(epoch);
-    const blocks = checkpointedBlocks.map(b => b.block);
-    this.log.info(
-      `Settling epoch ${epoch} with blocks ${blocks[0]?.header.getBlockNumber()} to ${blocks.at(-1)?.header.getBlockNumber()}`,
-      { blocks: blocks.map(b => b.toBlockInfo()) },
-    );
-    const messagesInEpoch: Fr[][][][] = [];
-    let previousSlotNumber = SlotNumber.ZERO;
-    let checkpointIndex = -1;
-
-    for (const block of blocks) {
-      const slotNumber = block.header.globalVariables.slotNumber;
-      if (slotNumber !== previousSlotNumber) {
-        checkpointIndex++;
-        messagesInEpoch[checkpointIndex] = [];
-        previousSlotNumber = slotNumber;
-      }
-      messagesInEpoch[checkpointIndex].push(block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
-    }
-
-    const outHash = computeEpochOutHash(messagesInEpoch);
-    if (!outHash.isZero()) {
-      await this.rollupCheatCodes.insertOutbox(epoch, outHash.toBigInt());
-    } else {
-      this.log.info(`No L2 to L1 messages in epoch ${epoch}`);
-    }
-
-    const lastCheckpoint = checkpointedBlocks.at(-1)?.checkpointNumber;
+    const lastCheckpoint = await settleEpochOutbox({
+      rollupCheatCodes: this.rollupCheatCodes,
+      l2BlockSource: this.l2BlockSource,
+      epoch,
+      log: this.log,
+    });
     if (lastCheckpoint !== undefined) {
       await this.rollupCheatCodes.markAsProven(lastCheckpoint);
     } else {

package/src/testing/index.ts

@@ -1,5 +1,5 @@
-export { AnvilTestWatcher } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 export { CheatCodes } from './cheat_codes.js';
 export { EpochTestSettler } from './epoch_test_settler.js';
+export { setupLocalNetwork, TEST_FEE_PADDING, type LocalNetwork, type LocalNetworkOptions } from './local-network.js';
 export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';

package/src/testing/local-network.ts

@@ -0,0 +1,97 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { AztecNodeConfig } from '@aztec/aztec-node/config';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { startAnvil } from '@aztec/ethereum/test';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { foundry } from 'viem/chains';
+
+import { createLocalNetwork } from '../local-network/local-network.js';
+
+/** A running in-process local network: an inline Aztec node backed by its own anvil L1. */
+export interface LocalNetwork extends AsyncDisposable {
+  /** Fully-synced Aztec node, ready to serve client requests. */
+  node: AztecNodeService;
+  /** RPC URL of the spawned anvil instance. */
+  l1RpcUrl: string;
+  /** Chain id used on L1 (foundry's default 31337). */
+  l1ChainId: number;
+  /** Stops every process started by the fixture: node and anvil. Also invoked by `await using`. */
+  stop: () => Promise<void>;
+}
+
+/** Options for {@link setupLocalNetwork}. */
+export interface LocalNetworkOptions {
+  /**
+   * Addresses that should hold fee juice at genesis. Saves each of these the round-trip of bridging
+   * + claiming fee juice before they can pay for gas.
+   */
+  fundedAddresses?: AztecAddress[];
+  /** Override the default per-address genesis fee juice granted to {@link fundedAddresses}. */
+  initialAccountFeeJuice?: Fr;
+  /** Node config overrides, e.g. `realProofs`, `aztecEpochDuration`, `p2pEnabled`. */
+  config?: Partial<AztecNodeConfig>;
+}
+
+/**
+ * Spin up an in-process local network with the given addresses pre-funded.
+ *
+ * Each call spawns its own anvil on an OS-assigned random port and runs the Aztec node inline via
+ * the same {@link createLocalNetwork} codepath that backs `aztec start --local-network` (with the
+ * sandbox account/FPC/token setup skipped). Distinct ports let independent suites run in parallel.
+ * The caller must `await result.stop()` in its teardown (or hold the result with `await using`).
+ *
+ * Requires a Foundry toolchain (`anvil`/`forge`), installed via `aztec-up` or `foundryup`. Binaries
+ * are located in the standard install directories or on `PATH`; set `$ANVIL_BIN` / `$FORGE_BIN` to
+ * pin specific ones.
+ */
+export async function setupLocalNetwork(opts: LocalNetworkOptions = {}): Promise<LocalNetwork> {
+  // `--port 0` → anvil binds an ephemeral port that `startAnvil` reads back, so parallel suites
+  // never collide on a fixed port.
+  const { rpcUrl, stop: stopAnvil } = await startAnvil({ port: 0 });
+
+  try {
+    const { node, stop: stopNode } = await createLocalNetwork(
+      {
+        ...opts.config,
+        l1RpcUrls: [rpcUrl],
+        testAccounts: false,
+        prefundAddresses: (opts.fundedAddresses ?? []).map(a => a.toString()),
+        initialAccountFeeJuice: opts.initialAccountFeeJuice,
+      },
+      () => {},
+    );
+
+    // Stop the node before anvil (its teardown still talks to L1); the finally guarantees anvil is
+    // reaped even if node shutdown throws.
+    const stop = async () => {
+      try {
+        await stopNode();
+      } finally {
+        await stopAnvil();
+      }
+    };
+
+    return {
+      node,
+      l1RpcUrl: rpcUrl,
+      l1ChainId: foundry.id,
+      stop,
+      [Symbol.asyncDispose]: stop,
+    };
+  } catch (err) {
+    await stopAnvil();
+    throw err;
+  }
+}
+
+/**
+ * Min-fee padding multiplier for test wallets whose txs may mine well after their fee estimate.
+ * The automine sequencer builds one block per tx and advances L1 time in big jumps, and proposer
+ * pipelining evolves the fee-asset price across the build/publish gap (~20x observed in CI), so the
+ * network's congestion base fee can swing sharply between the wallet's fee estimate and the block
+ * the tx actually lands in. The default wallet padding isn't enough and trips
+ * `maxFeesPerGas.feePerL2Gas must be >= gasFees.feePerL2Gas`. Apply via
+ * `wallet.setMinFeePadding(TEST_FEE_PADDING)` on every test wallet that sends txs.
+ */
+export const TEST_FEE_PADDING = 30;

package/src/testing/token_allowed_setup.ts

@@ -1,19 +1,26 @@
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { buildAllowedElement } from '@aztec/p2p/msg_validators';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
 
 /**
- * Returns Token-specific allowlist entries needed for FPC-based fee payments.
- * These are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+ * Returns the allowlist entries needed for FPC-based fee payments, keyed by the contract class of
+ * the `artifact` actually deployed as the fee token (defaults to canonical Token). The setup-phase
+ * validator matches these entries by class id, so a test deploying the codegen'd TestToken as its
+ * fee vehicle must pass `TestTokenContract.artifact` here -- otherwise the FPC fee calls are matched
+ * against the wrong class and rejected. Test-only: FPC fee payment with custom tokens won't work on
+ * mainnet alpha.
  */
-export async function getTokenAllowedSetupFunctions(): Promise<AllowedElement[]> {
-  const tokenClassId = (await getContractClassFromArtifact(TokenContractArtifact)).id;
+export async function getTokenAllowedSetupFunctions(
+  artifact: ContractArtifact = TokenContractArtifact,
+): Promise<AllowedElement[]> {
+  const tokenClassId = (await getContractClassFromArtifact(artifact)).id;
   const target = { classId: tokenClassId };
   return Promise.all([
-    // Token: needed for private transfers via FPC (transfer_to_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, '_increase_public_balance', { onlySelf: true }),
-    // Token: needed for public transfers via FPC (fee_entrypoint_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, 'transfer_in_public'),
+    // needed for private transfers via FPC (transfer_to_public enqueues this)
+    buildAllowedElement(artifact, target, '_increase_public_balance', { onlySelf: true }),
+    // needed for public transfers via FPC (fee_entrypoint_public enqueues this)
+    buildAllowedElement(artifact, target, 'transfer_in_public'),
   ]);
 }

package/dest/cli/cmds/start_archiver.d.ts

@@ -1,9 +0,0 @@
-import { type ArchiverConfig } from '@aztec/archiver';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { type DataStoreConfig } from '@aztec/stdlib/kv-store';
-export type { ArchiverConfig, DataStoreConfig };
-/** Starts a standalone archiver. */
-export declare function startArchiver(options: any, signalHandlers: (() => Promise<void>)[], services: NamespacedApiHandlers): Promise<{
-    config: ArchiverConfig & DataStoreConfig;
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnRfYXJjaGl2ZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY21kcy9zdGFydF9hcmNoaXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQW9FLE1BQU0saUJBQWlCLENBQUM7QUFJeEgsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUvRSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQXNCLE1BQU0sd0JBQXdCLENBQUM7QUFLbEYsWUFBWSxFQUFFLGNBQWMsRUFBRSxlQUFlLEVBQUUsQ0FBQztBQUVoRCxvQ0FBb0M7QUFDcEMsd0JBQXNCLGFBQWEsQ0FDakMsT0FBTyxFQUFFLEdBQUcsRUFDWixjQUFjLEVBQUUsQ0FBQyxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLEVBQ3ZDLFFBQVEsRUFBRSxxQkFBcUIsR0FDOUIsT0FBTyxDQUFDO0lBQUUsTUFBTSxFQUFFLGNBQWMsR0FBRyxlQUFlLENBQUE7Q0FBRSxDQUFDLENBK0J2RCJ9

package/dest/cli/cmds/start_archiver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start_archiver.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/start_archiver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAoE,MAAM,iBAAiB,CAAC;AAIxH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAKlF,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC;AAEhD,oCAAoC;AACpC,wBAAsB,aAAa,CACjC,OAAO,EAAE,GAAG,EACZ,cAAc,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EACvC,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC;IAAE,MAAM,EAAE,cAAc,GAAG,eAAe,CAAA;CAAE,CAAC,CA+BvD"}

package/dest/cli/cmds/start_archiver.js

@@ -1,48 +0,0 @@
-import { archiverConfigMappings, createArchiver, getArchiverConfigFromEnv } from '@aztec/archiver';
-import { createLogger } from '@aztec/aztec.js/log';
-import { blobClientConfigMapping, createBlobClient } from '@aztec/blob-client/client';
-import { getL1Config } from '@aztec/cli/config';
-import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
-import { dataConfigMappings } from '@aztec/stdlib/kv-store';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-import { extractRelevantOptions } from '../util.js';
-/** Starts a standalone archiver. */ export async function startArchiver(options, signalHandlers, services) {
-    const envConfig = getArchiverConfigFromEnv();
-    const cliOptions = extractRelevantOptions(options, {
-        ...archiverConfigMappings,
-        ...dataConfigMappings,
-        ...blobClientConfigMapping
-    }, 'archiver');
-    let archiverConfig = {
-        ...envConfig,
-        ...cliOptions
-    };
-    archiverConfig.dataStoreMapSizeKb = archiverConfig.archiverStoreMapSizeKb ?? archiverConfig.dataStoreMapSizeKb;
-    if (!archiverConfig.l1Contracts.registryAddress || archiverConfig.l1Contracts.registryAddress.isZero()) {
-        throw new Error('L1 registry address is required to start an Archiver');
-    }
-    const { addresses, config: l1Config } = await getL1Config(archiverConfig.l1Contracts.registryAddress, archiverConfig.l1RpcUrls, archiverConfig.l1ChainId);
-    archiverConfig.l1Contracts = addresses;
-    archiverConfig = {
-        ...archiverConfig,
-        ...l1Config
-    };
-    const telemetry = await initTelemetryClient(getTelemetryClientConfig());
-    const blobClient = createBlobClient(archiverConfig, {
-        logger: createLogger('archiver:blob-client:client')
-    });
-    const archiver = await createArchiver(archiverConfig, {
-        telemetry,
-        blobClient
-    }, {
-        blockUntilSync: true
-    });
-    services.archiver = [
-        archiver,
-        ArchiverApiSchema
-    ];
-    signalHandlers.push(archiver.stop);
-    return {
-        config: archiverConfig
-    };
-}

package/dest/testing/anvil_test_watcher.d.ts

@@ -1,42 +0,0 @@
-import { EthCheatCodes } from '@aztec/ethereum/test';
-import type { ViemClient } from '@aztec/ethereum/types';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { TestDateProvider } from '@aztec/foundation/timer';
-/**
- * Represents a watcher for a rollup contract.
- *
- * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
- * it will periodically check if the current slot have already been filled, e.g., there was an L2
- * block within the slot. And if so, it will time travel into the next slot.
- */
-export declare class AnvilTestWatcher {
-    private cheatcodes;
-    private dateProvider?;
-    private isLocalNetwork;
-    private rollup;
-    private rollupCheatCodes;
-    private l2SlotDuration;
-    private filledRunningPromise?;
-    private syncDateProviderPromise?;
-    private markingAsProvenRunningPromise?;
-    private logger;
-    private isMarkingAsProven;
-    private getPendingTxCount?;
-    private isSequencerBuilding?;
-    private unfilledSlotFirstSeen?;
-    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, l1Client: ViemClient, dateProvider?: TestDateProvider | undefined);
-    setIsMarkingAsProven(isMarkingAsProven: boolean): void;
-    setisLocalNetwork(isLocalNetwork: boolean): void;
-    /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */
-    setGetPendingTxCount(fn: () => Promise<number>): void;
-    /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */
-    setIsSequencerBuilding(fn: () => boolean): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    trigger(): Promise<void>;
-    markAsProven(): Promise<void>;
-    syncDateProviderToL1IfBehind(): Promise<void>;
-    warpTimeIfNeeded(): Promise<void>;
-    private warpToTimestamp;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW52aWxfdGVzdF93YXRjaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9hbnZpbF90ZXN0X3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBb0IsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBS2hFOzs7Ozs7R0FNRztBQUNILHFCQUFhLGdCQUFnQjtJQXlCekIsT0FBTyxDQUFDLFVBQVU7SUFHbEIsT0FBTyxDQUFDLFlBQVksQ0FBQztJQTNCdkIsT0FBTyxDQUFDLGNBQWMsQ0FBa0I7SUFFeEMsT0FBTyxDQUFDLE1BQU0sQ0FBc0Q7SUFDcEUsT0FBTyxDQUFDLGdCQUFnQixDQUFtQjtJQUMzQyxPQUFPLENBQUMsY0FBYyxDQUFVO0lBRWhDLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUFpQjtJQUM5QyxPQUFPLENBQUMsdUJBQXVCLENBQUMsQ0FBaUI7SUFDakQsT0FBTyxDQUFDLDZCQUE2QixDQUFDLENBQWlCO0lBRXZELE9BQU8sQ0FBQyxNQUFNLENBQWlEO0lBRS9ELE9BQU8sQ0FBQyxpQkFBaUIsQ0FBUTtJQUdqQyxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBd0I7SUFHbEQsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQWdCO0lBRzVDLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFxQztJQUVuRSxZQUNVLFVBQVUsRUFBRSxhQUFhLEVBQ2pDLGFBQWEsRUFBRSxVQUFVLEVBQ3pCLFFBQVEsRUFBRSxVQUFVLEVBQ1osWUFBWSxDQUFDLDhCQUFrQixFQWF4QztJQUVELG9CQUFvQixDQUFDLGlCQUFpQixFQUFFLE9BQU8sUUFHOUM7SUFFRCxpQkFBaUIsQ0FBQyxjQUFjLEVBQUUsT0FBTyxRQUV4QztJQUVELHlHQUF5RztJQUN6RyxvQkFBb0IsQ0FBQyxFQUFFLEVBQUUsTUFBTSxPQUFPLENBQUMsTUFBTSxDQUFDLFFBRTdDO0lBRUQsdUdBQXVHO0lBQ3ZHLHNCQUFzQixDQUFDLEVBQUUsRUFBRSxNQUFNLE9BQU8sUUFFdkM7SUFFSyxLQUFLLGtCQXlCVjtJQUVLLElBQUksa0JBSVQ7SUFFSyxPQUFPLGtCQUlaO0lBRUssWUFBWSxrQkFLakI7SUFFSyw0QkFBNEIsa0JBZWpDO0lBRUssZ0JBQWdCLGtCQXlEckI7WUFFYSxlQUFlO0NBTzlCIn0=

package/dest/testing/anvil_test_watcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"anvil_test_watcher.d.ts","sourceRoot":"","sources":["../../src/testing/anvil_test_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAKhE;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAyBzB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY,CAAC;IA3BvB,OAAO,CAAC,cAAc,CAAkB;IAExC,OAAO,CAAC,MAAM,CAAsD;IACpE,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,cAAc,CAAU;IAEhC,OAAO,CAAC,oBAAoB,CAAC,CAAiB;IAC9C,OAAO,CAAC,uBAAuB,CAAC,CAAiB;IACjD,OAAO,CAAC,6BAA6B,CAAC,CAAiB;IAEvD,OAAO,CAAC,MAAM,CAAiD;IAE/D,OAAO,CAAC,iBAAiB,CAAQ;IAGjC,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAGlD,OAAO,CAAC,mBAAmB,CAAC,CAAgB;IAG5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,YACU,UAAU,EAAE,aAAa,EACjC,aAAa,EAAE,UAAU,EACzB,QAAQ,EAAE,UAAU,EACZ,YAAY,CAAC,8BAAkB,EAaxC;IAED,oBAAoB,CAAC,iBAAiB,EAAE,OAAO,QAG9C;IAED,iBAAiB,CAAC,cAAc,EAAE,OAAO,QAExC;IAED,yGAAyG;IACzG,oBAAoB,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,QAE7C;IAED,uGAAuG;IACvG,sBAAsB,CAAC,EAAE,EAAE,MAAM,OAAO,QAEvC;IAEK,KAAK,kBAyBV;IAEK,IAAI,kBAIT;IAEK,OAAO,kBAIZ;IAEK,YAAY,kBAKjB;IAEK,4BAA4B,kBAejC;IAEK,gBAAgB,kBAyDrB;YAEa,eAAe;CAO9B"}

package/dest/testing/anvil_test_watcher.js

@@ -1,181 +0,0 @@
-import { RollupCheatCodes } from '@aztec/ethereum/test';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
-import { getAddress, getContract } from 'viem';
-/**
- * Represents a watcher for a rollup contract.
- *
- * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
- * it will periodically check if the current slot have already been filled, e.g., there was an L2
- * block within the slot. And if so, it will time travel into the next slot.
- */ export class AnvilTestWatcher {
-    cheatcodes;
-    dateProvider;
-    isLocalNetwork;
-    rollup;
-    rollupCheatCodes;
-    l2SlotDuration;
-    filledRunningPromise;
-    syncDateProviderPromise;
-    markingAsProvenRunningPromise;
-    logger;
-    isMarkingAsProven;
-    // Optional callback to check if there are pending txs in the mempool.
-    getPendingTxCount;
-    // Optional callback to check if the sequencer is actively building a block.
-    isSequencerBuilding;
-    // Tracks when we first observed the current unfilled slot with pending txs (real wall time).
-    unfilledSlotFirstSeen;
-    constructor(cheatcodes, rollupAddress, l1Client, dateProvider){
-        this.cheatcodes = cheatcodes;
-        this.dateProvider = dateProvider;
-        this.isLocalNetwork = false;
-        this.logger = createLogger(`aztecjs:utils:watcher`);
-        this.isMarkingAsProven = true;
-        this.rollup = getContract({
-            address: getAddress(rollupAddress.toString()),
-            abi: RollupAbi,
-            client: l1Client
-        });
-        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
-            rollupAddress
-        });
-        this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
-    }
-    setIsMarkingAsProven(isMarkingAsProven) {
-        this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
-        this.isMarkingAsProven = isMarkingAsProven;
-    }
-    setisLocalNetwork(isLocalNetwork) {
-        this.isLocalNetwork = isLocalNetwork;
-    }
-    /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */ setGetPendingTxCount(fn) {
-        this.getPendingTxCount = fn;
-    }
-    /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */ setIsSequencerBuilding(fn) {
-        this.isSequencerBuilding = fn;
-    }
-    async start() {
-        if (this.filledRunningPromise) {
-            throw new Error('Watcher already watching for filled slot');
-        }
-        const config = await this.rollupCheatCodes.getConfig();
-        this.l2SlotDuration = config.slotDuration;
-        // 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 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();
-        if (isAutoMining) {
-            this.filledRunningPromise = new RunningPromise(()=>this.warpTimeIfNeeded(), this.logger, 200);
-            this.filledRunningPromise.start();
-            this.syncDateProviderPromise = new RunningPromise(()=>this.syncDateProviderToL1IfBehind(), this.logger, 200);
-            this.syncDateProviderPromise.start();
-            this.markingAsProvenRunningPromise = new RunningPromise(()=>this.markAsProven(), this.logger, 200);
-            this.markingAsProvenRunningPromise.start();
-            this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
-        } else {
-            this.logger.info(`Watcher not started because not auto mining`);
-        }
-    }
-    async stop() {
-        await this.filledRunningPromise?.stop();
-        await this.syncDateProviderPromise?.stop();
-        await this.markingAsProvenRunningPromise?.stop();
-    }
-    async trigger() {
-        await this.filledRunningPromise?.trigger();
-        await this.syncDateProviderPromise?.trigger();
-        await this.markingAsProvenRunningPromise?.trigger();
-    }
-    async markAsProven() {
-        if (!this.isMarkingAsProven) {
-            return;
-        }
-        await this.rollupCheatCodes.markAsProven();
-    }
-    async syncDateProviderToL1IfBehind() {
-        // 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.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));
-        }
-    }
-    async warpTimeIfNeeded() {
-        try {
-            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.
-                await this.warpToTimestamp(nextSlotTimestamp);
-                this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
-                return;
-            }
-            // If we are not in local network, we don't need to warp time
-            if (!this.isLocalNetwork) {
-                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) {
-                        await this.warpToTimestamp(nextSlotTimestamp);
-                        this.unfilledSlotFirstSeen = undefined;
-                        this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
-                    }
-                    return;
-                }
-            }
-            // Fallback: warp when the dateProvider time has passed the next slot timestamp.
-            const currentTimestamp = this.dateProvider?.now() ?? Date.now();
-            if (currentTimestamp > nextSlotTimestamp * 1000) {
-                await this.warpToTimestamp(nextSlotTimestamp);
-                this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
-            }
-        } catch  {
-            this.logger.error('mineIfSlotFilled failed');
-        }
-    }
-    async warpToTimestamp(timestamp) {
-        try {
-            await this.cheatcodes.warp(timestamp, {
-                resetBlockInterval: true
-            });
-        } catch (e) {
-            this.logger.error(`Failed to warp to timestamp ${timestamp}: ${e}`);
-        }
-    }
-}

package/src/cli/cmds/start_archiver.ts

@@ -1,50 +0,0 @@
-import { type ArchiverConfig, archiverConfigMappings, createArchiver, getArchiverConfigFromEnv } from '@aztec/archiver';
-import { createLogger } from '@aztec/aztec.js/log';
-import { type BlobClientConfig, blobClientConfigMapping, createBlobClient } from '@aztec/blob-client/client';
-import { getL1Config } from '@aztec/cli/config';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-
-import { extractRelevantOptions } from '../util.js';
-
-export type { ArchiverConfig, DataStoreConfig };
-
-/** Starts a standalone archiver. */
-export async function startArchiver(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-): Promise<{ config: ArchiverConfig & DataStoreConfig }> {
-  const envConfig = getArchiverConfigFromEnv();
-  const cliOptions = extractRelevantOptions<ArchiverConfig & DataStoreConfig & BlobClientConfig>(
-    options,
-    { ...archiverConfigMappings, ...dataConfigMappings, ...blobClientConfigMapping },
-    'archiver',
-  );
-
-  let archiverConfig = { ...envConfig, ...cliOptions };
-  archiverConfig.dataStoreMapSizeKb = archiverConfig.archiverStoreMapSizeKb ?? archiverConfig.dataStoreMapSizeKb;
-
-  if (!archiverConfig.l1Contracts.registryAddress || archiverConfig.l1Contracts.registryAddress.isZero()) {
-    throw new Error('L1 registry address is required to start an Archiver');
-  }
-
-  const { addresses, config: l1Config } = await getL1Config(
-    archiverConfig.l1Contracts.registryAddress,
-    archiverConfig.l1RpcUrls,
-    archiverConfig.l1ChainId,
-  );
-
-  archiverConfig.l1Contracts = addresses;
-  archiverConfig = { ...archiverConfig, ...l1Config };
-
-  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
-  const blobClient = createBlobClient(archiverConfig, { logger: createLogger('archiver:blob-client:client') });
-  const archiver = await createArchiver(archiverConfig, { telemetry, blobClient }, { blockUntilSync: true });
-  services.archiver = [archiver, ArchiverApiSchema];
-  signalHandlers.push(archiver.stop);
-
-  return { config: archiverConfig };
-}