@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/sandbox/sandbox.ts

@@ -1,40 +1,42 @@
 #!/usr/bin/env -S node --no-warnings
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
-import { setupCanonicalL2FeeJuice } from '@aztec/cli/setup-contracts';
-import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import {
   NULL_KEY,
   createEthereumChain,
   deployL1Contracts,
+  deployMulticall3,
   getL1ContractsConfigEnvVars,
   waitForPublicClient,
 } from '@aztec/ethereum';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/fields';
 import { type LogFn, createLogger } from '@aztec/foundation/log';
+import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
 } from '@aztec/telemetry-client';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type HDAccount, type PrivateKeyAccount, createPublicClient, fallback, http as httpViemTransport } from 'viem';
-import { mnemonicToAccount } from 'viem/accounts';
+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 { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
-import { getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js';
+import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
 const logger = createLogger('sandbox');
 
@@ -49,7 +51,12 @@ export async function deployContractsToL1(
   aztecNodeConfig: AztecNodeConfig,
   hdAccount: HDAccount | PrivateKeyAccount,
   contractDeployLogger = logger,
-  opts: { assumeProvenThroughBlockNumber?: number; salt?: number; genesisArchiveRoot?: Fr; genesisBlockHash?: Fr } = {},
+  opts: {
+    assumeProvenThroughBlockNumber?: number;
+    salt?: number;
+    genesisArchiveRoot?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
+  } = {},
 ) {
   const chain =
     aztecNodeConfig.l1RpcUrls.length > 0
@@ -66,16 +73,21 @@ export async function deployContractsToL1(
     {
       ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
       ...aztecNodeConfig,
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
+      protocolContractsHash,
       genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-      genesisBlockHash: opts.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
       salt: opts.salt,
+      feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+      aztecTargetCommitteeSize: 0, // no committee in sandbox
+      slasherFlavor: 'none', // no slashing in sandbox
+      realVerifier: false,
     },
   );
 
+  await deployMulticall3(l1Contracts.l1Client, logger);
+
   aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+  aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
 
   return aztecNodeConfig.l1Contracts;
 }
@@ -85,9 +97,7 @@ export type SandboxConfig = AztecNodeConfig & {
   /** Mnemonic used to derive the L1 deployer private key.*/
   l1Mnemonic: string;
   /** Salt used to deploy L1 contracts.*/
-  l1Salt: string;
-  /** Whether to expose PXE service on sandbox start.*/
-  noPXE: boolean;
+  deployAztecContractsSalt: string;
   /** Whether to deploy test accounts on sandbox start.*/
   testAccounts: boolean;
 };
@@ -108,23 +118,29 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
   }
   const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
-  if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
+  if (
+    aztecNodeConfig.publisherPrivateKeys == undefined ||
+    !aztecNodeConfig.publisherPrivateKeys.length ||
+    aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY
+  ) {
     const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+    aztecNodeConfig.publisherPrivateKeys = [new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const)];
   }
-  if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
+  if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
     const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+    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) {
+    if (config.testAccounts === true || config.testAccounts === undefined) {
       if (aztecNodeConfig.p2pEnabled) {
         userLog(`Not setting up test accounts as we are connecting to a network`);
-      } else if (config.noPXE) {
-        userLog(`Not setting up test accounts as we are not exposing a PXE`);
       } else {
-        return await getInitialTestAccounts();
+        userLog(`Setting up test accounts`);
+        return await getInitialTestAccountsData();
       }
     }
     return [];
@@ -135,15 +151,16 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
   const fundedAddresses = initialAccounts.length
     ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
     : [];
-  const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(fundedAddresses);
+  const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
   let watcher: AnvilTestWatcher | undefined = undefined;
+  const dateProvider = new TestDateProvider();
   if (!aztecNodeConfig.p2pEnabled) {
     const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
       assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
       genesisArchiveRoot,
-      genesisBlockHash,
-      salt: config.l1Salt ? parseInt(config.l1Salt) : undefined,
+      salt: config.deployAztecContractsSalt ? parseInt(config.deployAztecContractsSalt) : undefined,
+      feeJuicePortalInitialBalance: fundingNeeded,
     });
 
     const chain =
@@ -156,7 +173,12 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
       transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
     });
 
-    watcher = new AnvilTestWatcher(new EthCheatCodes([l1RpcUrl]), l1ContractAddresses.rollupAddress, publicClient);
+    watcher = new AnvilTestWatcher(
+      new EthCheatCodes([l1RpcUrl], dateProvider),
+      l1ContractAddresses.rollupAddress,
+      publicClient,
+      dateProvider,
+    );
     watcher.setIsSandbox(true);
     await watcher.start();
   }
@@ -164,29 +186,31 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
   const telemetry = initTelemetryClient(getTelemetryClientConfig());
   // Create a local blob sink client inside the sandbox, no http connectivity
   const blobSinkClient = createBlobSinkClient();
-  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobSinkClient }, { prefilledPublicData });
-  const pxe = await createAztecPXE(node);
-
-  await setupCanonicalL2FeeJuice(
-    new SignerlessWallet(pxe),
-    aztecNodeConfig.l1Contracts.feeJuicePortalAddress,
-    undefined,
-    logger.info,
+  const node = await createAztecNode(
+    aztecNodeConfig,
+    { telemetry, blobSinkClient, dateProvider },
+    { prefilledPublicData },
   );
 
   if (initialAccounts.length) {
+    const PXEConfig = { proverEnabled: aztecNodeConfig.realProofs };
+    const wallet = await TestWallet.create(node, PXEConfig);
+
     userLog('Setting up funded test accounts...');
-    const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
-    const accountsWithSecrets = accounts.map((account, i) => ({
-      account,
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccounts);
+    const accountsWithSecrets = accountManagers.map((manager, i) => ({
+      account: manager,
       secretKey: initialAccounts[i].secret,
     }));
-    const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
+    const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
     userLog(accLogs.join(''));
 
-    const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
-    await setupBananaFPC(initialAccounts, deployer, userLog);
-    await setupSponsoredFPC(deployer, userLog);
+    await setupBananaFPC(initialAccounts, wallet, userLog);
+
+    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 () => {
@@ -194,7 +218,7 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
     await watcher?.stop();
   };
 
-  return { node, pxe, stop };
+  return { node, stop };
 }
 
 /**
@@ -203,7 +227,7 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
  */
 export async function createAztecNode(
   config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface } = {},
+  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface; dateProvider?: DateProvider } = {},
   options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
@@ -213,17 +237,6 @@ export async function createAztecNode(
     ...config,
     l1Contracts: { ...l1Contracts, ...config.l1Contracts },
   };
-  logger.info('createAztecNode', aztecNodeConfig);
   const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
   return node;
 }
-
-/**
- * Create and start a new Aztec PXE HTTP Server
- * @param config - Optional PXE settings.
- */
-export async function createAztecPXE(node: AztecNode, config: Partial<PXEServiceConfig> = {}) {
-  const pxeServiceConfig: PXEServiceConfig = { ...getPXEServiceConfig(), ...config };
-  const pxe = await createPXEService(node, pxeServiceConfig);
-  return pxe;
-}

package/src/sandbox/sponsored_fpc.ts

@@ -1,18 +1,15 @@
 import {
   type ContractInstanceWithAddress,
-  Fr,
-  type PXE,
-  type Wallet,
-  getContractInstanceFromDeployParams,
-} from '@aztec/aztec.js';
-import type { LogFn } from '@aztec/foundation/log';
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { SPONSORED_FPC_SALT } from '@aztec/constants';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 
-const SPONSORED_FPC_SALT = new Fr(0);
-
 async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
-  return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, {
-    salt: SPONSORED_FPC_SALT,
+  return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+    salt: new Fr(SPONSORED_FPC_SALT),
   });
 }
 
@@ -20,19 +17,9 @@ export async function getSponsoredFPCAddress() {
   return (await getSponsoredFPCInstance()).address;
 }
 
-export async function setupSponsoredFPC(deployer: Wallet, log: LogFn) {
-  const deployed = await SponsoredFPCContract.deploy(deployer)
-    .send({ contractAddressSalt: SPONSORED_FPC_SALT, universalDeploy: true })
-    .deployed();
-
-  log(`SponsoredFPC: ${deployed.address}`);
-}
-
-export async function getDeployedSponsoredFPCAddress(pxe: PXE) {
-  const fpc = await getSponsoredFPCAddress();
-  const contracts = await pxe.getContracts();
-  if (!contracts.find(c => c.equals(fpc))) {
-    throw new Error('SponsoredFPC not deployed.');
-  }
-  return fpc;
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet) {
+  const fpc = await getSponsoredFPCInstance();
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, SponsoredFPCContract.artifact);
+  return fpc.address;
 }

package/src/testing/anvil_test_watcher.ts

@@ -0,0 +1,164 @@
+import type { ViemClient } from '@aztec/ethereum';
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import { type GetContractReturnType, 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 {
+  private isSandbox: boolean = false;
+
+  private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
+  private rollupCheatCodes: RollupCheatCodes;
+  private l2SlotDuration!: bigint;
+
+  private filledRunningPromise?: RunningPromise;
+  private syncDateProviderPromise?: RunningPromise;
+  private markingAsProvenRunningPromise?: RunningPromise;
+
+  private logger: Logger = createLogger(`aztecjs:utils:watcher`);
+
+  private isMarkingAsProven = true;
+
+  constructor(
+    private cheatcodes: EthCheatCodes,
+    rollupAddress: EthAddress,
+    l1Client: ViemClient,
+    private dateProvider?: TestDateProvider,
+  ) {
+    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: boolean) {
+    this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
+    this.isMarkingAsProven = isMarkingAsProven;
+  }
+
+  setIsSandbox(isSandbox: boolean) {
+    this.isSandbox = isSandbox;
+  }
+
+  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 sandbox 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 sandbox, because we don't have a date provider in the sandbox
+    if (!this.dateProvider) {
+      return;
+    }
+
+    const l1Time = (await this.cheatcodes.timestamp()) * 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 = 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}`);
+        }
+
+        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+        return;
+      }
+
+      // If we are not in sandbox, we don't need to warp time
+      if (!this.isSandbox) {
+        return;
+      }
+
+      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}`);
+        }
+
+        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+      }
+    } catch {
+      this.logger.error('mineIfSlotFilled failed');
+    }
+  }
+}

package/src/testing/cheat_codes.ts

@@ -0,0 +1,78 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+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';
+
+/**
+ * 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.
+ */
+export class CheatCodes {
+  constructor(
+    /** Cheat codes for L1.*/
+    public eth: EthCheatCodes,
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    public rollup: RollupCheatCodes,
+  ) {}
+
+  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
+    const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
+    const rollupCheatCodes = new RollupCheatCodes(
+      ethCheatCodes,
+      await node.getNodeInfo().then(n => n.l1ContractAddresses),
+    );
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
+  }
+
+  /**
+   * 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)
+   */
+  async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
+    const currentL2BlockNumber = 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 = await node.getBlockNumber();
+        return newL2BlockNumber > currentL2BlockNumber;
+      },
+      'new block after warping L2 time',
+      36,
+      1,
+    );
+
+    // Restore original minTxsPerBlock
+    sequencer.updateConfig({ minTxsPerBlock });
+  }
+
+  /**
+   * 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)
+   */
+  async warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number) {
+    const currentTimestamp = await this.eth.timestamp();
+    const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
+    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+export { CheatCodes } from './cheat_codes.js';

package/dest/cli/chain_l2_config.d.ts

@@ -1,19 +0,0 @@
-export type NetworkNames = 'testnet-ignition';
-export type L2ChainConfig = {
-    l1ChainId: number;
-    ethereumSlotDuration: number;
-    aztecSlotDuration: number;
-    aztecEpochDuration: number;
-    aztecProofSubmissionWindow: number;
-    testAccounts: boolean;
-    p2pEnabled: boolean;
-    p2pBootstrapNodes: string[];
-    registryAddress: string;
-    seqMinTxsPerBlock: number;
-    seqMaxTxsPerBlock: number;
-};
-export declare const testnetIgnitionL2ChainConfig: L2ChainConfig;
-export declare function getBootnodes(networkName: NetworkNames): Promise<any>;
-export declare function getL2ChainConfig(networkName: NetworkNames): Promise<L2ChainConfig | undefined>;
-export declare function enrichEnvironmentWithChainConfig(networkName: NetworkNames): Promise<void>;
-//# sourceMappingURL=chain_l2_config.d.ts.map

package/dest/cli/chain_l2_config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/cli/chain_l2_config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,aAY1C,CAAC;AAEF,wBAAsB,YAAY,CAAC,WAAW,EAAE,YAAY,gBAQ3D;AAED,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAOpG;AAUD,wBAAsB,gCAAgC,CAAC,WAAW,EAAE,YAAY,iBAgB/E"}

package/dest/cli/chain_l2_config.js

@@ -1,56 +0,0 @@
-export const testnetIgnitionL2ChainConfig = {
-    l1ChainId: 11155111,
-    ethereumSlotDuration: 12,
-    aztecSlotDuration: 36,
-    aztecEpochDuration: 32,
-    aztecProofSubmissionWindow: 64,
-    testAccounts: true,
-    p2pEnabled: true,
-    p2pBootstrapNodes: [],
-    registryAddress: '0x12b3ebc176a1646b911391eab3760764f2e05fe3',
-    seqMinTxsPerBlock: 0,
-    seqMaxTxsPerBlock: 0
-};
-export async function getBootnodes(networkName) {
-    const url = `http://static.aztec.network/${networkName}/bootnodes.json`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch basic contract addresses from ${url}`);
-    }
-    const json = await response.json();
-    return json['bootnodes'];
-}
-export async function getL2ChainConfig(networkName) {
-    if (networkName === 'testnet-ignition') {
-        const config = {
-            ...testnetIgnitionL2ChainConfig
-        };
-        config.p2pBootstrapNodes = await getBootnodes(networkName);
-        return config;
-    }
-    return undefined;
-}
-function enrichVar(envVar, value) {
-    // Don't override
-    if (process.env[envVar]) {
-        return;
-    }
-    process.env[envVar] = value;
-}
-export async function enrichEnvironmentWithChainConfig(networkName) {
-    const config = await getL2ChainConfig(networkName);
-    if (!config) {
-        throw new Error(`Unknown network name: ${networkName}`);
-    }
-    enrichVar('ETHEREUM_SLOT_DURATION', config.ethereumSlotDuration.toString());
-    enrichVar('AZTEC_SLOT_DURATION', config.aztecSlotDuration.toString());
-    enrichVar('AZTEC_EPOCH_DURATION', config.aztecEpochDuration.toString());
-    enrichVar('AZTEC_PROOF_SUBMISSION_WINDOW', config.aztecProofSubmissionWindow.toString());
-    enrichVar('P2P_BOOTSTRAP_NODES', config.p2pBootstrapNodes.join(','));
-    enrichVar('TEST_ACCOUNTS', config.testAccounts.toString());
-    enrichVar('P2P_ENABLED', config.p2pEnabled.toString());
-    enrichVar('L1_CHAIN_ID', config.l1ChainId.toString());
-    enrichVar('REGISTRY_CONTRACT_ADDRESS', config.registryAddress);
-    enrichVar('SEQ_MIN_TX_PER_BLOCK', config.seqMinTxsPerBlock.toString());
-    enrichVar('SEQ_MAX_TX_PER_BLOCK', config.seqMaxTxsPerBlock.toString());
-}

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

@@ -1,4 +0,0 @@
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import type { LogFn } from '@aztec/foundation/log';
-export declare function startFaucet(options: any, signalHandlers: (() => Promise<void>)[], services: NamespacedApiHandlers, log: LogFn): Promise<void>;
-//# sourceMappingURL=start_faucet.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"start_faucet.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/start_faucet.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,GAAG,EACZ,cAAc,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EACvC,QAAQ,EAAE,qBAAqB,EAC/B,GAAG,EAAE,KAAK,iBAiBX"}

package/dest/cli/cmds/start_faucet.js

@@ -1,20 +0,0 @@
-import { Faucet, FaucetSchema, createFaucetHttpServer, faucetConfigMapping, getFaucetConfigFromEnv } from '@aztec/aztec-faucet';
-import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
-export async function startFaucet(options, signalHandlers, services, log) {
-    const faucetOptions = extractNamespacedOptions(options, 'faucet');
-    const config = {
-        ...getFaucetConfigFromEnv(),
-        ...extractRelevantOptions(options, faucetConfigMapping, 'faucet')
-    };
-    const faucet = await Faucet.create(config);
-    if (faucetOptions.apiServer) {
-        const httpServer = createFaucetHttpServer(faucet);
-        httpServer.listen(faucetOptions.apiServerPort);
-        signalHandlers.push(()=>new Promise((res)=>httpServer.close(()=>res())));
-        log(`Faucet now running on port: ${faucetOptions.apiServerPort}`);
-    }
-    services.faucet = [
-        faucet,
-        FaucetSchema
-    ];
-}