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

package/dest/fixtures/snapshot_manager.js

@@ -1,18 +1,25 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AnvilTestWatcher, BatchCall, CheatCodes, getContractClassFromArtifact } from '@aztec/aztec.js';
-import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { getContractClassFromArtifact } from '@aztec/aztec.js/contracts';
+import { BatchCall, waitForProven } from '@aztec/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { createBlobSinkServer } from '@aztec/blob-sink/server';
-import { createL1Clients, getL1ContractsConfigEnvVars, l1Artifacts } from '@aztec/ethereum';
+import { createExtendedL1Client, deployMulticall3, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
 import { EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
 import { asyncMap } from '@aztec/foundation/async-map';
+import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
+import { tryRmDir } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { resolver, reviver } from '@aztec/foundation/serialize';
 import { TestDateProvider } from '@aztec/foundation/timer';
-import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { getPXEConfig } from '@aztec/pxe/server';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { copySync, removeSync } from 'fs-extra/esm';
@@ -20,13 +27,13 @@ import fs from 'fs/promises';
 import getPort from 'get-port';
 import { tmpdir } from 'os';
 import path, { join } from 'path';
-import { getContract } from 'viem';
 import { mnemonicToAccount } from 'viem/accounts';
-import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
+import { foundry } from 'viem/chains';
+import { MNEMONIC, TEST_MAX_TX_POOL_SIZE, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import { setupL1Contracts } from './setup_l1_contracts.js';
-import { createAndSyncProverNode, getLogger, getPrivateKeyFromIndex } from './utils.js';
+import { createAndSyncProverNode, getLogger, getPrivateKeyFromIndex, getSponsoredFPCAddress } from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 export function createSnapshotManager(testName, dataPath, config = {}, deployL1ContractsArgs = {
     initialValidators: []
@@ -114,7 +121,7 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         // Execute the restoration function.
         await restore(snapshotData, context);
         // Save the snapshot data.
-        const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls);
+        const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls, context.dateProvider);
         const anvilStateFile = `${this.livePath}/anvil.dat`;
         await ethCheatCodes.dumpChainState(anvilStateFile);
         writeFileSync(`${this.livePath}/${name}.json`, JSON.stringify(snapshotData || {}, resolver));
@@ -176,28 +183,19 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     if (!context) {
         return;
     }
+    const logger = getLogger();
     try {
-        getLogger().info('Tearing down subsystems');
-        await context.proverNode?.stop();
-        await context.aztecNode.stop();
+        logger.info('Tearing down subsystems');
+        await tryStop(context.proverNode);
+        await tryStop(context.aztecNode);
         await context.acvmConfig?.cleanup();
         await context.bbConfig?.cleanup();
-        await context.anvil.stop();
-        await context.watcher.stop();
-        await context.blobSink.stop();
-        if (context.directoryToCleanup) {
-            try {
-                await fs.rm(context.directoryToCleanup, {
-                    recursive: true,
-                    force: true,
-                    maxRetries: 3
-                });
-            } catch (err) {
-                getLogger().warn(`Failed to delete tmp directory ${context.directoryToCleanup}: ${err}`);
-            }
-        }
+        await tryStop(context.anvil);
+        await tryStop(context.watcher);
+        await tryStop(context.blobSink);
+        await tryRmDir(context.directoryToCleanup, logger);
     } catch (err) {
-        getLogger().error('Error during teardown', err);
+        logger.error('Error during teardown', err);
     }
 }
 /**
@@ -209,6 +207,9 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
 }) {
     logger.verbose(`Initializing state...`);
     const blobSinkPort = await getPort();
+    // Default to no slashing
+    opts.slasherFlavor ??= 'none';
+    deployL1ContractsArgs.slasherFlavor ??= opts.slasherFlavor;
     // Fetch the AztecNode config.
     // TODO: For some reason this is currently the union of a bunch of subsystems. That needs fixing.
     const aztecNodeConfig = {
@@ -216,6 +217,15 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         ...opts
     };
     aztecNodeConfig.peerCheckIntervalMS = TEST_PEER_CHECK_INTERVAL_MS;
+    aztecNodeConfig.maxTxPoolSize = opts.maxTxPoolSize ?? TEST_MAX_TX_POOL_SIZE;
+    // Only enable proving if specifically requested.
+    aztecNodeConfig.realProofs = !!opts.realProofs;
+    // Only enforce the time table if requested
+    aztecNodeConfig.enforceTimeTable = !!opts.enforceTimeTable;
+    // Only set the target committee size if it is explicitly set
+    aztecNodeConfig.aztecTargetCommitteeSize = opts.aztecTargetCommitteeSize ?? 0;
+    aztecNodeConfig.listenAddress = '127.0.0.1';
+    deployL1ContractsArgs.aztecTargetCommitteeSize ??= aztecNodeConfig.aztecTargetCommitteeSize;
     // Create a temp directory for all ephemeral state and cleanup afterwards
     const directoryToCleanup = path.join(tmpdir(), randomBytes(8).toString('hex'));
     await fs.mkdir(directoryToCleanup, {
@@ -226,16 +236,25 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     } else {
         aztecNodeConfig.dataDirectory = statePath;
     }
-    aztecNodeConfig.blobSinkUrl = `http://localhost:${blobSinkPort}`;
-    // Setup blob sink service
-    const blobSink = await createBlobSinkServer({
-        port: blobSinkPort,
-        dataStoreConfig: {
-            dataDirectory: aztecNodeConfig.dataDirectory,
-            dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB
-        }
+    aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
+    const hdAccount = mnemonicToAccount(MNEMONIC, {
+        addressIndex: 0
     });
-    await blobSink.start();
+    const publisherPrivKeyRaw = hdAccount.getHdKey().privateKey;
+    const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
+    const l1Client = createExtendedL1Client([
+        aztecNodeConfig.l1RpcUrls[0]
+    ], hdAccount, foundry);
+    const validatorPrivKey = getPrivateKeyFromIndex(0);
+    const proverNodePrivateKey = getPrivateKeyFromIndex(0);
+    aztecNodeConfig.publisherPrivateKeys = [
+        new SecretValue(`0x${publisherPrivKey.toString('hex')}`)
+    ];
+    aztecNodeConfig.validatorPrivateKeys = new SecretValue([
+        `0x${validatorPrivKey.toString('hex')}`
+    ]);
+    aztecNodeConfig.coinbase = opts.coinbase ?? EthAddress.fromString(`${hdAccount.address}`);
+    logger.info(`Setting up environment with config`, aztecNodeConfig);
     // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
     logger.verbose('Starting anvil...');
     const res = await startAnvil({
@@ -245,57 +264,30 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     aztecNodeConfig.l1RpcUrls = [
         res.rpcUrl
     ];
+    const dateProvider = new TestDateProvider();
+    const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
     // Deploy our L1 contracts.
     logger.verbose('Deploying L1 contracts...');
-    const hdAccount = mnemonicToAccount(MNEMONIC, {
-        accountIndex: 0
-    });
-    const publisherPrivKeyRaw = hdAccount.getHdKey().privateKey;
-    const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
-    const validatorPrivKey = getPrivateKeyFromIndex(0);
-    const proverNodePrivateKey = getPrivateKeyFromIndex(0);
-    aztecNodeConfig.publisherPrivateKey = `0x${publisherPrivKey.toString('hex')}`;
-    aztecNodeConfig.validatorPrivateKey = `0x${validatorPrivKey.toString('hex')}`;
-    const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
     if (opts.l1StartTime) {
-        await ethCheatCodes.warp(opts.l1StartTime);
+        await ethCheatCodes.warp(opts.l1StartTime, {
+            resetBlockInterval: true
+        });
     }
     const initialFundedAccounts = await generateSchnorrAccounts(numberOfInitialFundedAccounts);
-    const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map((a)=>a.address), opts.initialAccountFeeJuice);
+    const sponsoredFPCAddress = await getSponsoredFPCAddress();
+    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(initialFundedAccounts.map((a)=>a.address).concat(sponsoredFPCAddress), opts.initialAccountFeeJuice);
+    await deployMulticall3(l1Client, logger);
     const deployL1ContractsValues = await setupL1Contracts(aztecNodeConfig.l1RpcUrls[0], hdAccount, logger, {
         ...getL1ContractsConfigEnvVars(),
         genesisArchiveRoot,
-        genesisBlockHash,
+        feeJuicePortalInitialBalance: fundingNeeded,
         salt: opts.salt,
         ...deployL1ContractsArgs,
         initialValidators: opts.initialValidators
     });
     aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
-    aztecNodeConfig.l1PublishRetryIntervalMS = 100;
-    if (opts.fundRewardDistributor) {
-        // Mints block rewards for 10000 blocks to the rewardDistributor contract
-        const rewardDistributor = getContract({
-            address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
-            abi: l1Artifacts.rewardDistributor.contractAbi,
-            client: deployL1ContractsValues.publicClient
-        });
-        const blockReward = await rewardDistributor.read.BLOCK_REWARD();
-        const mintAmount = 10_000n * blockReward;
-        const feeJuice = getContract({
-            address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-            abi: l1Artifacts.feeAsset.contractAbi,
-            client: deployL1ContractsValues.walletClient
-        });
-        const rewardDistributorMintTxHash = await feeJuice.write.mint([
-            rewardDistributor.address,
-            mintAmount
-        ], {});
-        await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-            hash: rewardDistributorMintTxHash
-        });
-        logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
-    }
-    const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls), deployL1ContractsValues.l1ContractAddresses.rollupAddress, deployL1ContractsValues.publicClient);
+    aztecNodeConfig.rollupVersion = deployL1ContractsValues.rollupVersion;
+    const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider), deployL1ContractsValues.l1ContractAddresses.rollupAddress, deployL1ContractsValues.l1Client, dateProvider);
     await watcher.start();
     const acvmConfig = await getACVMConfig(logger);
     if (acvmConfig) {
@@ -308,8 +300,17 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         aztecNodeConfig.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
     }
     const telemetry = getEndToEndTestTelemetryClient(opts.metricsPort);
-    logger.verbose('Creating and synching an aztec node...');
-    const dateProvider = new TestDateProvider();
+    // Setup blob sink service
+    const blobSink = await createBlobSinkServer({
+        l1ChainId: aztecNodeConfig.l1ChainId,
+        l1RpcUrls: aztecNodeConfig.l1RpcUrls,
+        l1Contracts: aztecNodeConfig.l1Contracts,
+        port: blobSinkPort,
+        dataDirectory: aztecNodeConfig.dataDirectory,
+        dataStoreMapSizeKb: aztecNodeConfig.dataStoreMapSizeKb
+    }, telemetry);
+    await blobSink.start();
+    logger.info('Creating and synching an aztec node...');
     const aztecNode = await AztecNodeService.createAndSync(aztecNodeConfig, {
         telemetry,
         dateProvider
@@ -318,14 +319,20 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     });
     let proverNode = undefined;
     if (opts.startProverNode) {
-        logger.verbose('Creating and syncing a simulated prover node...');
-        proverNode = await createAndSyncProverNode(`0x${proverNodePrivateKey.toString('hex')}`, aztecNodeConfig, aztecNode, path.join(directoryToCleanup, randomBytes(8).toString('hex')), prefilledPublicData);
+        logger.verbose('Creating and syncing a simulated prover node with p2p disabled...');
+        proverNode = await createAndSyncProverNode(`0x${proverNodePrivateKey.toString('hex')}`, aztecNodeConfig, {
+            ...aztecNodeConfig.proverNodeConfig,
+            dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+            p2pEnabled: false
+        }, aztecNode, prefilledPublicData);
     }
     logger.verbose('Creating pxe...');
-    const pxeConfig = getPXEServiceConfig();
+    const pxeConfig = getPXEConfig();
     pxeConfig.dataDirectory = statePath ?? path.join(directoryToCleanup, randomBytes(8).toString('hex'));
-    const pxe = await createPXEService(aztecNode, pxeConfig);
-    const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+    // Only enable proving if specifically requested.
+    pxeConfig.proverEnabled = !!opts.realProofs;
+    const wallet = await TestWallet.create(aztecNode, pxeConfig);
+    const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
     if (statePath) {
         writeFileSync(`${statePath}/aztec_node_config.json`, JSON.stringify(aztecNodeConfig, resolver));
         writeFileSync(`${statePath}/accounts.json`, JSON.stringify(initialFundedAccounts, resolver));
@@ -334,7 +341,8 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         aztecNodeConfig,
         anvil,
         aztecNode,
-        pxe,
+        wallet,
+        sequencer: aztecNode.getSequencer(),
         acvmConfig,
         bbConfig,
         deployL1ContractsValues,
@@ -361,16 +369,9 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     const aztecNodeConfig = JSON.parse(readFileSync(`${statePath}/aztec_node_config.json`, 'utf-8'), reviver);
     aztecNodeConfig.dataDirectory = statePath;
     aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
+    aztecNodeConfig.listenAddress = '127.0.0.1';
     const initialFundedAccounts = JSON.parse(readFileSync(`${statePath}/accounts.json`, 'utf-8'), reviver) || [];
     const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map((a)=>a.address));
-    const blobSink = await createBlobSinkServer({
-        port: blobSinkPort,
-        dataStoreConfig: {
-            dataDirectory: statePath,
-            dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB
-        }
-    });
-    await blobSink.start();
     // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
     const { anvil, rpcUrl } = await startAnvil();
     aztecNodeConfig.l1RpcUrls = [
@@ -378,7 +379,8 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
     ];
     // Load anvil state.
     const anvilStateFile = `${statePath}/anvil.dat`;
-    const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
+    const dateProvider = new TestDateProvider();
+    const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
     await ethCheatCodes.loadChainState(anvilStateFile);
     // TODO: Encapsulate this in a NativeAcvm impl.
     const acvmConfig = await getACVMConfig(logger);
@@ -392,12 +394,20 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         aztecNodeConfig.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
     }
     logger.verbose('Creating ETH clients...');
-    const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, mnemonicToAccount(MNEMONIC));
-    const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls), aztecNodeConfig.l1Contracts.rollupAddress, publicClient);
+    const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, mnemonicToAccount(MNEMONIC));
+    const watcher = new AnvilTestWatcher(ethCheatCodes, aztecNodeConfig.l1Contracts.rollupAddress, l1Client, dateProvider);
     await watcher.start();
-    logger.verbose('Creating aztec node...');
     const telemetry = initTelemetryClient(getTelemetryConfig());
-    const dateProvider = new TestDateProvider();
+    const blobSink = await createBlobSinkServer({
+        l1ChainId: aztecNodeConfig.l1ChainId,
+        l1RpcUrls: aztecNodeConfig.l1RpcUrls,
+        l1Contracts: aztecNodeConfig.l1Contracts,
+        port: blobSinkPort,
+        dataDirectory: statePath,
+        dataStoreMapSizeKb: aztecNodeConfig.dataStoreMapSizeKb
+    }, telemetry);
+    await blobSink.start();
+    logger.verbose('Creating aztec node...');
     const aztecNode = await AztecNodeService.createAndSync(aztecNodeConfig, {
         telemetry,
         dateProvider
@@ -409,25 +419,30 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
         logger.verbose('Creating and syncing a simulated prover node...');
         const proverNodePrivateKey = getPrivateKeyFromIndex(2);
         const proverNodePrivateKeyHex = `0x${proverNodePrivateKey.toString('hex')}`;
-        proverNode = await createAndSyncProverNode(proverNodePrivateKeyHex, aztecNodeConfig, aztecNode, path.join(directoryToCleanup, randomBytes(8).toString('hex')), prefilledPublicData);
+        proverNode = await createAndSyncProverNode(proverNodePrivateKeyHex, aztecNodeConfig, {
+            ...aztecNodeConfig.proverNodeConfig,
+            dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+            p2pEnabled: false
+        }, aztecNode, prefilledPublicData);
     }
     logger.verbose('Creating pxe...');
-    const pxeConfig = getPXEServiceConfig();
+    const pxeConfig = getPXEConfig();
     pxeConfig.dataDirectory = statePath;
-    const pxe = await createPXEService(aztecNode, pxeConfig);
-    const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+    const wallet = await TestWallet.create(aztecNode, pxeConfig);
+    const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
     return {
         aztecNodeConfig,
         anvil,
         aztecNode,
-        pxe,
+        wallet,
+        sequencer: aztecNode.getSequencer(),
         acvmConfig,
         bbConfig,
         proverNode,
         deployL1ContractsValues: {
-            walletClient,
-            publicClient,
-            l1ContractAddresses: aztecNodeConfig.l1Contracts
+            l1Client,
+            l1ContractAddresses: aztecNodeConfig.l1Contracts,
+            rollupVersion: aztecNodeConfig.rollupVersion
         },
         watcher,
         cheatCodes,
@@ -440,15 +455,21 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
 /**
  * Snapshot 'apply' helper function to add accounts.
  * The 'restore' function is not provided, as it must be a closure within the test context to capture the results.
- */ export const deployAccounts = (numberOfAccounts, logger, waitUntilProven = false)=>async ({ pxe, initialFundedAccounts })=>{
+ */ export const deployAccounts = (numberOfAccounts, logger)=>async ({ wallet, initialFundedAccounts })=>{
         if (initialFundedAccounts.length < numberOfAccounts) {
             throw new Error(`Cannot deploy more than ${initialFundedAccounts.length} initial accounts.`);
         }
         logger.verbose('Deploying accounts funded with fee juice...');
         const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-        await deployFundedSchnorrAccounts(pxe, deployedAccounts, {
-            proven: waitUntilProven
-        });
+        // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
+        for(let i = 0; i < deployedAccounts.length; i++){
+            const accountManager = await wallet.createSchnorrAccount(deployedAccounts[i].secret, deployedAccounts[i].salt, deployedAccounts[i].signingKey);
+            const deployMethod = await accountManager.getDeployMethod();
+            await deployMethod.send({
+                from: AztecAddress.ZERO,
+                skipClassPublication: i !== 0
+            }).wait();
+        }
         return {
             deployedAccounts
         };
@@ -458,22 +479,27 @@ export function createSnapshotManager(testName, dataPath, config = {}, deployL1C
  * Use this when you need to make a public call to an account contract, such as for requesting a public authwit.
  * @param sender - Wallet to send the deployment tx.
  * @param accountsToDeploy - Which accounts to publicly deploy.
- */ export async function publicDeployAccounts(sender, accountsToDeploy, waitUntilProven = false) {
-    const accountAddressesToDeploy = accountsToDeploy.map((a)=>'address' in a ? a.address : a);
-    const instances = (await Promise.all(accountAddressesToDeploy.map((account)=>sender.getContractMetadata(account)))).map((metadata)=>metadata.contractInstance);
+ * @param waitUntilProven - Whether to wait for the tx to be proven.
+ * @param node - AztecNode used to wait for proven tx.
+ */ export async function publicDeployAccounts(wallet, accountsToDeploy, waitUntilProven = false, node) {
+    const instances = (await Promise.all(accountsToDeploy.map((account)=>wallet.getContractMetadata(account)))).map((metadata)=>metadata.contractInstance);
     const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-    const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
-    const fns = await Promise.all([
+    const alreadyRegistered = (await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
+    const calls = await Promise.all([
         ...!alreadyRegistered ? [
-            registerContractClass(sender, SchnorrAccountContractArtifact)
+            publishContractClass(wallet, SchnorrAccountContractArtifact)
         ] : [],
-        ...instances.map((instance)=>deployInstance(sender, instance))
+        ...instances.map((instance)=>publishInstance(wallet, instance))
     ]);
-    const calls = await Promise.all(fns.map((fn)=>fn.request()));
-    const capsules = fns.map((fn)=>fn.getCapsules()).flat();
-    const batch = new BatchCall(sender, calls);
-    batch.addCapsules(capsules);
-    await batch.send().wait({
-        proven: waitUntilProven
-    });
+    const batch = new BatchCall(wallet, calls);
+    const txReceipt = await batch.send({
+        from: accountsToDeploy[0]
+    }).wait();
+    if (waitUntilProven) {
+        if (!node) {
+            throw new Error('Need to provide an AztecNode to wait for proven.');
+        } else {
+            await waitForProven(node, txReceipt);
+        }
+    }
 }

package/dest/fixtures/token_utils.d.ts

@@ -1,6 +1,9 @@
-import type { AztecAddress, Logger, Wallet } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-export declare function deployToken(adminWallet: Wallet, initialAdminBalance: bigint, logger: Logger): Promise<TokenContract>;
-export declare function mintTokensToPrivate(token: TokenContract, minterWallet: Wallet, recipient: AztecAddress, amount: bigint): Promise<void>;
+export declare function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger): Promise<TokenContract>;
+export declare function mintTokensToPrivate(token: TokenContract, minter: AztecAddress, recipient: AztecAddress, amount: bigint): Promise<void>;
 export declare function expectTokenBalance(wallet: Wallet, token: TokenContract, owner: AztecAddress, expectedBalance: bigint, logger: Logger): Promise<void>;
+export declare function mintNotes(wallet: Wallet, minter: AztecAddress, recipient: AztecAddress, asset: TokenContract, noteAmounts: bigint[]): Promise<bigint>;
 //# sourceMappingURL=token_utils.d.ts.map

package/dest/fixtures/token_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token_utils.d.ts","sourceRoot":"","sources":["../../src/fixtures/token_utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,0BAcjG;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,YAAY,EACvB,MAAM,EAAE,MAAM,iBAKf;AAGD,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,YAAY,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,iBAOf"}
+{"version":3,"file":"token_utils.d.ts","sourceRoot":"","sources":["../../src/fixtures/token_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,0BAajH;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,MAAM,EAAE,MAAM,iBAGf;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,YAAY,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,iBAOf;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dest/fixtures/token_utils.js

@@ -1,21 +1,21 @@
-// docs:start:token_utils
+import { BatchCall } from '@aztec/aztec.js/contracts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-export async function deployToken(adminWallet, initialAdminBalance, logger) {
+export async function deployToken(wallet, admin, initialAdminBalance, logger) {
     logger.info(`Deploying Token contract...`);
-    const contract = await TokenContract.deploy(adminWallet, adminWallet.getAddress(), 'TokenName', 'TokenSymbol', 18).send().deployed();
+    const contract = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+        from: admin
+    }).deployed();
     if (initialAdminBalance > 0n) {
-        // Minter is minting to herself so contract as minter is the same as contract as recipient
-        await mintTokensToPrivate(contract, adminWallet, adminWallet.getAddress(), initialAdminBalance);
+        await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
     }
     logger.info('L2 contract deployed');
     return contract;
 }
-export async function mintTokensToPrivate(token, minterWallet, recipient, amount) {
-    const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
-    const from = minterWallet.getAddress(); // we are setting from to minter here because we need a sender to calculate the tag
-    await tokenAsMinter.methods.mint_to_private(from, recipient, amount).send().wait();
+export async function mintTokensToPrivate(token, minter, recipient, amount) {
+    await token.methods.mint_to_private(recipient, amount).send({
+        from: minter
+    }).wait();
 }
-// docs:end:token_utils
 export async function expectTokenBalance(wallet, token, owner, expectedBalance, logger) {
     // Then check the balance
     const contractWithWallet = await TokenContract.at(token.address, wallet);
@@ -25,3 +25,16 @@ export async function expectTokenBalance(wallet, token, owner, expectedBalance,
     logger.info(`Account ${owner} balance: ${balance}`);
     expect(balance).toBe(expectedBalance);
 }
+export async function mintNotes(wallet, minter, recipient, asset, noteAmounts) {
+    // We can only mint 5 notes at a time, since that's the maximum number of calls our entrypoints allow
+    // TODO(#13024): mint as many notes as possible in a single tx
+    const notesPerIteration = 5;
+    for(let mintedNotes = 0; mintedNotes < noteAmounts.length; mintedNotes += notesPerIteration){
+        const toMint = noteAmounts.slice(mintedNotes, mintedNotes + notesPerIteration);
+        const actions = toMint.map((amt)=>asset.methods.mint_to_private(recipient, amt));
+        await new BatchCall(wallet, actions).send({
+            from: minter
+        }).wait();
+    }
+    return noteAmounts.reduce((prev, curr)=>prev + curr, 0n);
+}