@aztec/end-to-end 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/src/fixtures/utils.ts

@@ -1,13 +1,31 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
+import {
+  type InitialAccountData,
+  deployFundedSchnorrAccounts,
+  generateSchnorrAccounts,
+  getDeployedTestAccounts,
+  getDeployedTestAccountsWallets,
+} from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, type ContractMethod } from '@aztec/aztec.js/contracts';
+import {
+  AccountManager,
+  type AccountWalletWithSecretKey,
+  type AztecAddress,
+  type AztecNode,
+  BatchCall,
+  type ContractMethod,
+  type Logger,
+  type PXE,
+  type Wallet,
+  createAztecNodeClient,
+  createLogger,
+  createPXEClient,
+  makeFetch,
+  sleep,
+  waitForPXE,
+} from '@aztec/aztec.js';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import { type AztecNode, createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
-import type { Wallet } from '@aztec/aztec.js/wallet';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
@@ -39,18 +57,24 @@ import { Fr } from '@aztec/foundation/fields';
 import { tryRmDir } from '@aztec/foundation/fs';
 import { withLogNameSuffix } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
-import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { P2PClientDeps } from '@aztec/p2p';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
-import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { type ProverNode, type ProverNodeConfig, type ProverNodeDeps, createProverNode } from '@aztec/prover-node';
-import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
+import {
+  type PXEService,
+  type PXEServiceConfig,
+  createPXEServiceWithSimulator,
+  getPXEServiceConfig,
+} from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
+import { FileCircuitRecorder } from '@aztec/simulator/testing';
 import {
   type ContractInstanceWithAddress,
   getContractClassFromArtifact,
@@ -67,7 +91,6 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import type { Anvil } from '@viem/anvil';
@@ -87,8 +110,8 @@ import { isMetricsLoggingRequested, setupMetricsLogger } from './logging.js';
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 export { startAnvil };
 
-const { AZTEC_NODE_URL = '' } = process.env;
-const getAztecUrl = () => AZTEC_NODE_URL;
+const { PXE_URL = '' } = process.env;
+const getAztecUrl = () => PXE_URL;
 
 let telemetry: TelemetryClient | undefined = undefined;
 function getTelemetryClient(partialConfig: Partial<TelemetryClientConfig> & { benchmark?: boolean } = {}) {
@@ -119,7 +142,7 @@ export const setupL1Contracts = async (
 ) => {
   const l1Data = await deployL1Contracts(l1RpcUrls, account, chain, logger, {
     vkTreeRoot: getVKTreeRoot(),
-    protocolContractsHash,
+    protocolContractTreeRoot,
     genesisArchiveRoot: args.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
     salt: args.salt,
     initialValidators: args.initialValidators,
@@ -132,23 +155,23 @@ export const setupL1Contracts = async (
 };
 
 /**
- * Sets up Private eXecution Environment (PXE) and returns the corresponding test wallet.
+ * Sets up Private eXecution Environment (PXE).
  * @param aztecNode - An instance of Aztec Node.
- * @param opts - Partial configuration for the PXE.
+ * @param opts - Partial configuration for the PXE service.
  * @param logger - The logger to be used.
  * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns A test wallet, logger and teardown function.
+ * @returns Private eXecution Environment (PXE), logger and teardown function.
  */
-export async function setupPXEAndGetWallet(
+export async function setupPXEService(
   aztecNode: AztecNode,
-  opts: Partial<PXEConfig> = {},
+  opts: Partial<PXEServiceConfig> = {},
   logger = getLogger(),
   useLogSuffix = false,
 ): Promise<{
   /**
-   * The wallet instance.
+   * The PXE instance.
    */
-  wallet: TestWallet;
+  pxe: PXEService;
   /**
    * Logger instance named as the current test.
    */
@@ -158,24 +181,29 @@ export async function setupPXEAndGetWallet(
    */
   teardown: () => Promise<void>;
 }> {
-  const PXEConfig = { ...getPXEConfig(), ...opts };
+  const pxeServiceConfig = { ...getPXEServiceConfig(), ...opts };
   // For tests we only want proving enabled if specifically requested
-  PXEConfig.proverEnabled = !!opts.proverEnabled;
+  pxeServiceConfig.proverEnabled = !!opts.proverEnabled;
 
   // If no data directory provided, create a temp directory and clean up afterwards
-  const configuredDataDirectory = PXEConfig.dataDirectory;
+  const configuredDataDirectory = pxeServiceConfig.dataDirectory;
   if (!configuredDataDirectory) {
-    PXEConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
+    pxeServiceConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
   }
 
-  const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(PXEConfig.dataDirectory!);
-
-  const wallet = await TestWallet.create(aztecNode, PXEConfig, {
+  const simulator = new WASMSimulator();
+  const recorder = process.env.CIRCUIT_RECORD_DIR
+    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
+    : new MemoryCircuitRecorder();
+  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
+  const pxe = await createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, pxeServiceConfig, {
     useLogSuffix,
   });
 
+  const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(pxeServiceConfig.dataDirectory!);
+
   return {
-    wallet,
+    pxe,
     logger,
     teardown,
   };
@@ -200,10 +228,12 @@ async function setupWithRemoteEnvironment(
   const aztecNodeUrl = getAztecUrl();
   logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
   const aztecNode = createAztecNodeClient(aztecNodeUrl);
-  await waitForNode(aztecNode, logger);
-  logger.verbose('JSON RPC client connected to Aztec Node');
-  logger.verbose(`Retrieving contract addresses from ${aztecNodeUrl}`);
-  const { l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
+  logger.verbose(`Creating PXE client to remote host ${PXE_URL}`);
+  const pxeClient = createPXEClient(PXE_URL, {}, makeFetch([1, 2, 3], true));
+  await waitForPXE(pxeClient, logger);
+  logger.verbose('JSON RPC client connected to PXE');
+  logger.verbose(`Retrieving contract addresses from ${PXE_URL}`);
+  const { l1ContractAddresses, rollupVersion } = await pxeClient.getNodeInfo();
 
   const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
 
@@ -212,36 +242,31 @@ async function setupWithRemoteEnvironment(
     l1Client,
     rollupVersion,
   };
-  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, new DateProvider());
-  const wallet = await TestWallet.create(aztecNode);
-  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, new DateProvider());
+  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls);
+  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxeClient!);
   const teardown = () => Promise.resolve();
 
-  logger.verbose('Populating wallet from already registered accounts...');
-  const initialFundedAccounts = await getInitialTestAccountsData();
+  logger.verbose('Constructing available wallets from already registered accounts...');
+  const initialFundedAccounts = await getDeployedTestAccounts(pxeClient);
+  const wallets = await getDeployedTestAccountsWallets(pxeClient);
 
-  if (initialFundedAccounts.length < numberOfAccounts) {
-    throw new Error(`Required ${numberOfAccounts} accounts. Found ${initialFundedAccounts.length}.`);
+  if (wallets.length < numberOfAccounts) {
+    throw new Error(`Required ${numberOfAccounts} accounts. Found ${wallets.length}.`);
     // Deploy new accounts if there's a test that requires more funded accounts in the remote environment.
   }
 
-  const testAccounts = await Promise.all(
-    initialFundedAccounts.slice(0, numberOfAccounts).map(async account => {
-      const accountManager = await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey);
-      return accountManager.address;
-    }),
-  );
-
   return {
     aztecNode,
     aztecNodeAdmin: undefined,
     sequencer: undefined,
     proverNode: undefined,
+    pxe: pxeClient,
     deployL1ContractsValues,
     config,
     initialFundedAccounts,
-    wallet,
-    accounts: testAccounts,
+    wallets,
+    wallet: wallets[0],
+    accounts: wallets.slice(0, numberOfAccounts).map(w => w.getAddress()),
     logger,
     cheatCodes,
     ethCheatCodes,
@@ -313,15 +338,19 @@ export type EndToEndContext = {
   proverNode: ProverNode | undefined;
   /** A client to the sequencer service (undefined if connected to remote environment) */
   sequencer: SequencerClient | undefined;
+  /** The Private eXecution Environment (PXE). */
+  pxe: PXE;
   /** Return values from deployL1Contracts function. */
   deployL1ContractsValues: DeployL1ContractsReturnType;
   /** The Aztec Node configuration. */
   config: AztecNodeConfig;
   /** The data for the initial funded accounts. */
   initialFundedAccounts: InitialAccountData[];
-  /** The wallet to be used. */
-  wallet: TestWallet;
-  /** The wallets to be used. */
+  /* Wallets created for the initial funded accounts, with secret keys. */
+  wallets: AccountWalletWithSecretKey[];
+  /** The first wallet to be used. */
+  wallet: AccountWalletWithSecretKey;
+  /** The accounts to be used. */
   accounts: AztecAddress[];
   /** Logger instance named as the current test. */
   logger: Logger;
@@ -354,7 +383,7 @@ export type EndToEndContext = {
 export async function setup(
   numberOfAccounts = 1,
   opts: SetupOptions = {},
-  pxeOpts: Partial<PXEConfig> = {},
+  pxeOpts: Partial<PXEServiceConfig> = {},
   chain: Chain = foundry,
 ): Promise<EndToEndContext> {
   let anvil: Anvil | undefined;
@@ -385,9 +414,9 @@ export async function setup(
       if (!isAnvilTestChain(chain.id)) {
         throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
       }
-      if (AZTEC_NODE_URL) {
+      if (PXE_URL) {
         throw new Error(
-          `AZTEC_NODE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
+          `PXE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
         );
       }
 
@@ -407,8 +436,7 @@ export async function setup(
       setupMetricsLogger(filename);
     }
 
-    const dateProvider = new TestDateProvider();
-    const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls, dateProvider);
+    const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls);
 
     if (opts.stateLoad) {
       await ethCheatCodes.loadChainState(opts.stateLoad);
@@ -440,7 +468,7 @@ export async function setup(
 
     config.coinbase = EthAddress.fromString(publisherHdAccount.address);
 
-    if (AZTEC_NODE_URL) {
+    if (PXE_URL) {
       // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
       return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
     }
@@ -509,7 +537,6 @@ export async function setup(
     if (enableAutomine) {
       await ethCheatCodes.setAutomine(false);
       await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
-      dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
     }
 
     if (opts.l2StartTime) {
@@ -518,8 +545,11 @@ export async function setup(
       await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
     }
 
+    const dateProvider = new TestDateProvider();
+    dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
+
     const watcher = new AnvilTestWatcher(
-      new EthCheatCodesWithState(config.l1RpcUrls, dateProvider),
+      new EthCheatCodesWithState(config.l1RpcUrls),
       deployL1ContractsValues.l1ContractAddresses.rollupAddress,
       deployL1ContractsValues.l1Client,
       dateProvider,
@@ -627,38 +657,40 @@ export async function setup(
     }
 
     logger.verbose('Creating a pxe...');
-    const { wallet, teardown: pxeTeardown } = await setupPXEAndGetWallet(aztecNode!, pxeOpts, logger);
+    const { pxe, teardown: pxeTeardown } = await setupPXEService(aztecNode!, pxeOpts, logger);
 
-    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, dateProvider);
+    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxe!);
 
     if (
       (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
       (opts.initialValidators && opts.initialValidators.length > 0)
     ) {
       // We need to advance such that the committee is set up.
-      await cheatCodes.rollup.advanceToEpoch((await cheatCodes.rollup.getEpoch()) + BigInt(config.lagInEpochs + 1));
+      await cheatCodes.rollup.advanceToEpoch((await cheatCodes.rollup.getEpoch()) + BigInt(config.lagInEpochs + 1), {
+        updateDateProvider: dateProvider,
+      });
       await cheatCodes.rollup.setupEpoch();
       await cheatCodes.rollup.debugRollup();
     }
-    let accounts: AztecAddress[] = [];
+
     // Below we continue with what we described in the long comment on line 571.
+    let accountManagers: AccountManager[] = [];
     if (numberOfAccounts === 0) {
       logger.info('No accounts are being deployed, waiting for an empty block 1 to be mined');
-      while ((await aztecNode.getBlockNumber()) === 0) {
+      while ((await pxe.getBlockNumber()) === 0) {
         await sleep(2000);
       }
     } else {
       logger.info(
         `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
       );
-      const accountsData = initialFundedAccounts.slice(0, numberOfAccounts);
-      const accountManagers = await deployFundedSchnorrAccounts(wallet, aztecNode, accountsData);
-      accounts = accountManagers.map(accountManager => accountManager.address);
+      accountManagers = await deployFundedSchnorrAccounts(pxe, initialFundedAccounts.slice(0, numberOfAccounts));
     }
 
     // Now we restore the original minTxsPerBlock setting.
     sequencerClient!.getSequencer().updateConfig({ minTxsPerBlock: originalMinTxsPerBlock });
 
+    const wallets = await Promise.all(accountManagers.map(account => account.getWallet()));
     if (initialFundedAccounts.length < numberOfAccounts) {
       // TODO: Create (numberOfAccounts - initialFundedAccounts.length) wallets without funds.
       throw new Error(
@@ -705,11 +737,13 @@ export async function setup(
       mockGossipSubNetwork,
       prefilledPublicData,
       proverNode,
+      pxe,
       sequencer: sequencerClient,
       teardown,
       telemetryClient: telemetry,
-      wallet,
-      accounts,
+      wallets,
+      wallet: wallets[0],
+      accounts: wallets.map(w => w.getAddress()),
       watcher,
     };
   } catch (err) {
@@ -726,14 +760,16 @@ export async function setup(
  * @param accountsToDeploy - Which accounts to publicly deploy.
  */
 
-export async function ensureAccountContractsPublished(wallet: Wallet, accountsToDeploy: AztecAddress[]) {
+// docs:start:public_deploy_accounts
+export async function ensureAccountContractsPublished(sender: Wallet, accountsToDeploy: Wallet[]) {
   // We have to check whether the accounts are already deployed. This can happen if the test runs against
   // the sandbox and the test accounts exist
   const accountsAndAddresses = await Promise.all(
-    accountsToDeploy.map(async address => {
+    accountsToDeploy.map(async account => {
+      const address = account.getAddress();
       return {
         address,
-        deployed: (await wallet.getContractMetadata(address)).isContractPublished,
+        deployed: (await sender.getContractMetadata(address)).isContractPublished,
       };
     }),
   );
@@ -741,18 +777,33 @@ export async function ensureAccountContractsPublished(wallet: Wallet, accountsTo
     await Promise.all(
       accountsAndAddresses
         .filter(({ deployed }) => !deployed)
-        .map(({ address }) => wallet.getContractMetadata(address)),
+        .map(({ address }) => sender.getContractMetadata(address)),
     )
   ).map(contractMetadata => contractMetadata.contractInstance);
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  if (!(await wallet.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
-    await (await publishContractClass(wallet, SchnorrAccountContractArtifact))
-      .send({ from: accountsToDeploy[0] })
+  if (!(await sender.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(sender, SchnorrAccountContractArtifact))
+      .send({ from: accountsToDeploy[0].getAddress() })
       .wait();
   }
-  const requests = await Promise.all(instances.map(async instance => await publishInstance(wallet, instance!)));
-  const batch = new BatchCall(wallet, requests);
-  await batch.send({ from: accountsToDeploy[0] }).wait();
+  const requests = await Promise.all(instances.map(async instance => await publishInstance(sender, instance!)));
+  const batch = new BatchCall(sender, requests);
+  await batch.send({ from: accountsToDeploy[0].getAddress() }).wait();
+}
+// docs:end:public_deploy_accounts
+
+/**
+ * Sets the timestamp of the next block.
+ * @param rpcUrl - rpc url of the blockchain instance to connect to
+ * @param timestamp - the timestamp for the next block
+ */
+export async function setNextBlockTimestamp(rpcUrl: string, timestamp: number) {
+  const params = `[${timestamp}]`;
+  await fetch(rpcUrl, {
+    body: `{"jsonrpc":"2.0", "method": "evm_setNextBlockTimestamp", "params": ${params}, "id": 1}`,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+  });
 }
 
 /** Returns the job name for the current test. */
@@ -818,7 +869,7 @@ export async function expectMappingDelta<K, V extends number | bigint>(
 }
 
 /**
- * Computes the address of the "canonical" SponsoredFPCContract. This is not a protocol contract
+ * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
  * but by conventions its address is computed with a salt of 0.
  * @returns The address of the sponsored FPC contract
  */
@@ -831,7 +882,7 @@ export function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress>
 }
 
 /**
- * Computes the address of the "canonical" SponsoredFPCContract. This is not a protocol contract
+ * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
  * but by conventions its address is computed with a salt of 0.
  * @returns The address of the sponsored FPC contract
  */
@@ -843,22 +894,22 @@ export async function getSponsoredFPCAddress() {
 /**
  * Deploy a sponsored FPC contract to a running instance.
  */
-export async function setupSponsoredFPC(wallet: Wallet) {
+export async function setupSponsoredFPC(pxe: PXE) {
   const instance = await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
     salt: new Fr(SPONSORED_FPC_SALT),
   });
 
-  await wallet.registerContract({ instance, artifact: SponsoredFPCContract.artifact });
+  await pxe.registerContract({ instance, artifact: SponsoredFPCContract.artifact });
   getLogger().info(`SponsoredFPC: ${instance.address}`);
   return instance;
 }
 
 /**
  * Registers the SponsoredFPC in this PXE instance
- * @param wallet - The wallet
+ * @param pxe - The pxe client
  */
-export async function registerSponsoredFPC(wallet: Wallet): Promise<void> {
-  await wallet.registerContract({ instance: await getSponsoredFPCInstance(), artifact: SponsoredFPCContract.artifact });
+export async function registerSponsoredFPC(pxe: PXE): Promise<void> {
+  await pxe.registerContract({ instance: await getSponsoredFPCInstance(), artifact: SponsoredFPCContract.artifact });
 }
 
 export async function waitForProvenChain(node: AztecNode, targetBlock?: number, timeoutSec = 60, intervalSec = 1) {

package/src/fixtures/web3signer.ts

@@ -1,7 +1,5 @@
+import { sleep } from '@aztec/aztec.js';
 import { randomBytes } from '@aztec/foundation/crypto';
-import { retryUntil } from '@aztec/foundation/retry';
-import { sleep } from '@aztec/foundation/sleep';
-import { RemoteSigner } from '@aztec/node-keystore';
 
 import { mkdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
@@ -23,26 +21,11 @@ privateKey: ${pk}`,
   await writeFile(path, yaml, { flag: 'wx' });
 }
 
-export async function refreshWeb3Signer(url: string, ...expectedAddresses: string[]) {
+export async function refreshWeb3Signer(url: string) {
   await fetch(new URL('reload', url), { method: 'POST' });
-
-  if (expectedAddresses.length > 0) {
-    await retryUntil(
-      async () => {
-        try {
-          await RemoteSigner.validateAccess(url, expectedAddresses);
-          return true;
-        } catch {
-          return false;
-        }
-      },
-      'web3signer refresh',
-      10,
-      0.5,
-    );
-  } else {
-    await sleep(1000);
-  }
+  // give the service a chance to load up the new files
+  // 1s might not be enough if there are a lot of files to scan
+  await sleep(1000);
 }
 
 export function getWeb3SignerTestKeystoreDir(): string {

package/src/guides/up_quick_start.sh

@@ -19,28 +19,36 @@ aztec-wallet() {
 aztec-wallet import-test-accounts
 
 # docs:start:declare-accounts
-aztec-wallet create-account -a alice -f test0
-aztec-wallet create-account -a bob -f test0
+aztec-wallet create-account -a alice --payment method=fee_juice,feePayer=test0
+aztec-wallet create-account -a bob --payment method=fee_juice,feePayer=test0
 # docs:end:declare-accounts
 
+# docs:start:deploy
 DEPLOY_OUTPUT=$(aztec-wallet deploy ../noir-contracts.js/artifacts/token_contract-Token.json --args accounts:test0 Test TST 18 -f test0)
 TOKEN_ADDRESS=$(echo "$DEPLOY_OUTPUT" | grep -oE 'Contract deployed at 0x[0-9a-fA-F]+' | cut -d ' ' -f4)
 echo "Deployed contract at $TOKEN_ADDRESS"
+# docs:end:deploy
 
+# docs:start:mint-private
 MINT_AMOUNT=69
 aztec-wallet send mint_to_private -ca last --args accounts:alice $MINT_AMOUNT -f test0
+# docs:end:mint-private
 
+# docs:start:get-balance
 ALICE_BALANCE=$(aztec-wallet simulate balance_of_private -ca last --args accounts:alice -f alice)
 if ! echo $ALICE_BALANCE | grep -q $MINT_AMOUNT; then
   echo "Incorrect Alice balance after transaction (expected $MINT_AMOUNT but got $ALICE_BALANCE)"
   exit 1
 fi
+# docs:end:get-balance
 
+# docs:start:transfer
 TRANSFER_AMOUNT=42
 
 aztec-wallet create-authwit transfer_in_private accounts:test0 -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -f alice
 
 aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -aw authwits:last -f test0
+# docs:end:transfer
 
 # Test end result
 ALICE_BALANCE=$(aztec-wallet simulate balance_of_private -ca last --args accounts:alice -f alice)

package/src/quality_of_service/alert_checker.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/aztec.js';
 
 import * as fs from 'fs';
 import * as yaml from 'js-yaml';