@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-c83136db25

package/dest/simulators/token_simulator.js

@@ -1,17 +1,19 @@
-/* eslint-disable jsdoc/require-jsdoc */ import { BatchCall } from '@aztec/aztec.js';
+import { BatchCall } from '@aztec/aztec.js/contracts';
 import chunk from 'lodash.chunk';
 export class TokenSimulator {
     token;
     defaultWallet;
+    defaultAddress;
     logger;
     accounts;
     balancesPrivate;
     balancePublic;
     totalSupply;
     lookupProvider;
-    constructor(token, defaultWallet, logger, accounts){
+    constructor(token, defaultWallet, defaultAddress, logger, accounts){
         this.token = token;
         this.defaultWallet = defaultWallet;
+        this.defaultAddress = defaultAddress;
         this.logger = logger;
         this.accounts = accounts;
         this.balancesPrivate = new Map();
@@ -83,12 +85,12 @@ export class TokenSimulator {
     async checkPublic() {
         // public calls
         const calls = [
-            await this.token.methods.total_supply().request()
+            this.token.methods.total_supply(),
+            ...this.accounts.map((address)=>this.token.methods.balance_of_public(address))
         ];
-        for (const address of this.accounts){
-            calls.push(await this.token.methods.balance_of_public(address).request());
-        }
-        const results = (await Promise.all(chunk(calls, 4).map((batch)=>new BatchCall(this.defaultWallet, batch).simulate()))).flat();
+        const results = (await Promise.all(chunk(calls, 5).map((batch)=>new BatchCall(this.defaultWallet, batch).simulate({
+                from: this.defaultAddress
+            })))).flat();
         expect(results[0]).toEqual(this.totalSupply);
         // Check that all our balances match
         for(let i = 0; i < this.accounts.length; i++){
@@ -106,11 +108,10 @@ export class TokenSimulator {
                 defaultLookups.push(address);
             }
         }
-        const defaultCalls = [];
-        for (const address of defaultLookups){
-            defaultCalls.push(await this.token.methods.balance_of_private(address).request());
-        }
-        const results = (await Promise.all(chunk(defaultCalls, 4).map((batch)=>new BatchCall(this.defaultWallet, batch).simulate()))).flat();
+        const defaultCalls = defaultLookups.map((address)=>this.token.methods.balance_of_private(address));
+        const results = (await Promise.all(chunk(defaultCalls, 4).map((batch)=>new BatchCall(this.defaultWallet, batch).simulate({
+                from: this.defaultAddress
+            })))).flat();
         for(let i = 0; i < defaultLookups.length; i++){
             expect(results[i]).toEqual(this.balanceOfPrivate(defaultLookups[i]));
         }
@@ -121,7 +122,9 @@ export class TokenSimulator {
             const asset = wallet ? this.token.withWallet(wallet) : this.token;
             const actualPrivateBalance = await asset.methods.balance_of_private({
                 address
-            }).simulate();
+            }).simulate({
+                from: this.defaultAddress
+            });
             expect(actualPrivateBalance).toEqual(this.balanceOfPrivate(address));
         }
     }

package/dest/spartan/setup_test_wallets.d.ts

@@ -1,20 +1,33 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, type PXE } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type FeePaymentMethod } from '@aztec/aztec.js/fee';
+import { type AztecNode } from '@aztec/aztec.js/node';
 import type { Logger } from '@aztec/foundation/log';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-export interface TestWallets {
-    pxe: PXE;
-    wallets: AccountWalletWithSecretKey[];
-    tokenAdminWallet: TokenContract;
+import { TestWallet } from '@aztec/test-wallet/server';
+export interface TestAccounts {
+    aztecNode: AztecNode;
+    wallet: TestWallet;
+    accounts: AztecAddress[];
+    tokenContract: TokenContract;
+    tokenAdminAddress: AztecAddress;
     tokenName: string;
-    recipientWallet: AccountWalletWithSecretKey;
+    recipientAddress: AztecAddress;
     tokenAddress: AztecAddress;
 }
-export declare function setupTestWalletsWithTokens(pxeUrl: string, mintAmount: bigint, logger: Logger): Promise<TestWallets>;
-export declare function deployTestWalletWithTokens(pxeUrl: string, nodeUrl: string, l1RpcUrl: string, mnemonicOrPrivateKey: string, mintAmount: bigint, logger: Logger, numberOfFundedWallets?: number, initialFeeJuice?: bigint): Promise<TestWallets>;
-export declare function performTransfers({ testWallets, rounds, transferAmount, logger, }: {
-    testWallets: TestWallets;
+export declare function setupTestAccountsWithTokens(nodeUrl: string, mintAmount: bigint, logger: Logger): Promise<TestAccounts>;
+export declare function deploySponsoredTestAccounts(wallet: TestWallet, aztecNode: AztecNode, mintAmount: bigint, logger: Logger, numberOfFundedWallets?: number): Promise<TestAccounts>;
+export declare function deployTestAccountsWithTokens(nodeUrl: string, l1RpcUrls: string[], mnemonicOrPrivateKey: string, mintAmount: bigint, logger: Logger, numberOfFundedWallets?: number): Promise<TestAccounts>;
+export declare function performTransfers({ wallet, testAccounts, rounds, transferAmount, logger, feePaymentMethod, }: {
+    wallet: TestWallet;
+    testAccounts: TestAccounts;
     rounds: number;
     transferAmount: bigint;
     logger: Logger;
+    feePaymentMethod?: FeePaymentMethod;
 }): Promise<void>;
+export declare function createWalletAndAztecNodeClient(nodeUrl: string, proverEnabled: boolean, logger: Logger): Promise<{
+    wallet: TestWallet;
+    aztecNode: AztecNode;
+    cleanup: () => Promise<void>;
+}>;
 //# sourceMappingURL=setup_test_wallets.d.ts.map

package/dest/spartan/setup_test_wallets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup_test_wallets.d.ts","sourceRoot":"","sources":["../../src/spartan/setup_test_wallets.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAKjB,KAAK,GAAG,EAIT,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,0BAA0B,EAAE,CAAC;IACtC,gBAAgB,EAAE,aAAa,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,0BAA0B,CAAC;IAC5C,YAAY,EAAE,YAAY,CAAC;CAC5B;AAMD,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,qBAAqB,SAAI,EACzB,eAAe,SAAa,GAC3B,OAAO,CAAC,WAAW,CAAC,CAsCtB;AA2DD,wBAAsB,gBAAgB,CAAC,EACrC,WAAW,EACX,MAAM,EACN,cAAc,EACd,MAAM,GACP,EAAE;IACD,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,iBAkBA"}
+{"version":3,"file":"setup_test_wallets.d.ts","sourceRoot":"","sources":["../../src/spartan/setup_test_wallets.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,KAAK,gBAAgB,EAA6B,MAAM,qBAAqB,CAAC;AAEvF,OAAO,EAAE,KAAK,SAAS,EAAyB,MAAM,sBAAsB,CAAC;AAG7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,UAAU,EAA4D,MAAM,2BAA2B,CAAC;AAMjH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,EAAE,YAAY,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;CAC5B;AAMD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,CAAC,CAyBvB;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,qBAAqB,SAAI,GACxB,OAAO,CAAC,YAAY,CAAC,CAuCvB;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAAE,EACnB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,qBAAqB,SAAI,GACxB,OAAO,CAAC,YAAY,CAAC,CA+CvB;AA6ED,wBAAsB,gBAAgB,CAAC,EACrC,MAAM,EACN,YAAY,EACZ,MAAM,EACN,cAAc,EACd,MAAM,EACN,gBAAgB,GACjB,EAAE;IACD,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,iBAqBA;AAED,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,OAAO,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAqBrF"}

package/dest/spartan/setup_test_wallets.js

@@ -1,99 +1,208 @@
-import { getSchnorrAccount, getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
-import { generateSchnorrAccounts, getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
-import { FeeJuicePaymentMethodWithClaim, Fr, L1FeeJuicePortalManager, createAztecNodeClient, createCompatibleClient, retryUntil } from '@aztec/aztec.js';
-import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
+import { SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import { retryUntil } from '@aztec/foundation/retry';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestWallet, proveInteraction, registerInitialSandboxAccountsInWallet } from '@aztec/test-wallet/server';
+import { getACVMConfig } from '../fixtures/get_acvm_config.js';
+import { getBBConfig } from '../fixtures/get_bb_config.js';
+import { getSponsoredFPCAddress, registerSponsoredFPC } from '../fixtures/utils.js';
 const TOKEN_NAME = 'USDC';
 const TOKEN_SYMBOL = 'USD';
 const TOKEN_DECIMALS = 18n;
-export async function setupTestWalletsWithTokens(pxeUrl, mintAmount, logger) {
-    const WALLET_COUNT = 1; // TODO fix this to allow for 16 wallets again
-    const pxe = await createCompatibleClient(pxeUrl, logger);
-    const [recipientWallet, ...wallets] = (await getDeployedTestAccountsWallets(pxe)).slice(0, WALLET_COUNT + 1);
-    const tokenAdmin = wallets[0];
-    const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
-    const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+export async function setupTestAccountsWithTokens(nodeUrl, mintAmount, logger) {
+    const ACCOUNT_COUNT = 1; // TODO fix this to allow for 16 wallets again
+    const aztecNode = createAztecNodeClient(nodeUrl);
+    const wallet = await TestWallet.create(aztecNode);
+    const [recipientAccount, ...accounts] = (await registerInitialSandboxAccountsInWallet(wallet)).slice(0, ACCOUNT_COUNT + 1);
+    const tokenAdmin = accounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, accounts, tokenAdmin, mintAmount, undefined, logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
     return {
-        pxe,
-        wallets,
-        tokenAdminWallet,
+        aztecNode,
+        accounts,
+        wallet,
+        tokenAdminAddress: tokenAdmin,
         tokenName: TOKEN_NAME,
         tokenAddress,
-        recipientWallet
+        tokenContract,
+        recipientAddress: recipientAccount
     };
 }
-export async function deployTestWalletWithTokens(pxeUrl, nodeUrl, l1RpcUrl, mnemonicOrPrivateKey, mintAmount, logger, numberOfFundedWallets = 1, initialFeeJuice = 10n ** 22n) {
-    const pxe = await createCompatibleClient(pxeUrl, logger);
-    const node = createAztecNodeClient(nodeUrl);
+export async function deploySponsoredTestAccounts(wallet, aztecNode, mintAmount, logger, numberOfFundedWallets = 1) {
     const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
-    const recipientWallet = await getSchnorrWalletWithSecretKey(pxe, recipient.secret, recipient.signingKey, recipient.salt);
-    const fundedAccounts = await Promise.all(funded.map((a)=>getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)));
-    const claims = await Promise.all(fundedAccounts.map((a)=>bridgeL1FeeJuice(l1RpcUrl, mnemonicOrPrivateKey, pxe, a.getAddress(), initialFeeJuice, logger)));
-    // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
-    await advanceL2Block(node);
-    await advanceL2Block(node);
-    const wallets = await Promise.all(fundedAccounts.map(async (a, i)=>{
-        const wallet = await a.getWallet();
-        const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claims[i]);
-        await a.deploy({
+    const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+    const fundedAccounts = await Promise.all(funded.map((a)=>wallet.createSchnorrAccount(a.secret, a.salt)));
+    await registerSponsoredFPC(wallet);
+    const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
+    const recipientDeployMethod = await recipientAccount.getDeployMethod();
+    await recipientDeployMethod.send({
+        from: AztecAddress.ZERO,
+        fee: {
+            paymentMethod
+        }
+    }).wait({
+        timeout: 2400
+    });
+    await Promise.all(fundedAccounts.map(async (a)=>{
+        const deployMethod = await a.getDeployMethod();
+        await deployMethod.send({
+            from: AztecAddress.ZERO,
+            fee: {
+                paymentMethod
+            }
+        }).wait({
+            timeout: 2400
+        }); // increase timeout on purpose in order to account for two empty epochs
+        logger.info(`Account deployed at ${a.address}`);
+    }));
+    const tokenAdmin = fundedAccounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, fundedAccounts.map((acc)=>acc.address), tokenAdmin.address, mintAmount, new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()), logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
+    return {
+        aztecNode,
+        wallet,
+        accounts: fundedAccounts.map((acc)=>acc.address),
+        tokenAdminAddress: tokenAdmin.address,
+        tokenName: TOKEN_NAME,
+        tokenAddress,
+        tokenContract,
+        recipientAddress: recipientAccount.address
+    };
+}
+export async function deployTestAccountsWithTokens(nodeUrl, l1RpcUrls, mnemonicOrPrivateKey, mintAmount, logger, numberOfFundedWallets = 1) {
+    const aztecNode = createAztecNodeClient(nodeUrl);
+    const wallet = await TestWallet.create(aztecNode);
+    const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
+    const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+    const fundedAccounts = await Promise.all(funded.map((a)=>wallet.createSchnorrAccount(a.secret, a.salt)));
+    const claims = await Promise.all(fundedAccounts.map((a)=>bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, aztecNode, a.address, undefined, logger)));
+    // Progress by 3 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
+    await advanceL2Block(aztecNode);
+    await advanceL2Block(aztecNode);
+    await advanceL2Block(aztecNode);
+    await Promise.all(fundedAccounts.map(async (a, i)=>{
+        const paymentMethod = new FeeJuicePaymentMethodWithClaim(a.address, claims[i]);
+        const deployMethod = await a.getDeployMethod();
+        await deployMethod.send({
+            from: AztecAddress.ZERO,
             fee: {
                 paymentMethod
             }
         }).wait();
-        logger.info(`Account deployed at ${a.getAddress()}`);
-        return wallet;
+        logger.info(`Account deployed at ${a.address}`);
     }));
-    const tokenAdmin = wallets[0];
-    const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
-    const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+    const tokenAdmin = fundedAccounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, fundedAccounts.map((acc)=>acc.address), tokenAdmin.address, mintAmount, undefined, logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
     return {
-        pxe,
-        wallets,
-        tokenAdminWallet,
+        aztecNode,
+        wallet,
+        accounts: fundedAccounts.map((acc)=>acc.address),
+        tokenAdminAddress: tokenAdmin.address,
         tokenName: TOKEN_NAME,
         tokenAddress,
-        recipientWallet
+        tokenContract,
+        recipientAddress: recipientAccount.address
     };
 }
-async function bridgeL1FeeJuice(l1RpcUrl, mnemonicOrPrivateKey, pxe, recipient, amount, log) {
-    const { l1ChainId } = await pxe.getNodeInfo();
-    const chain = createEthereumChain([
-        l1RpcUrl
-    ], l1ChainId);
-    const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
-    const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, log);
+async function bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, aztecNode, recipient, amount, log) {
+    const { l1ChainId } = await aztecNode.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+    const l1Client = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+    const portal = await L1FeeJuicePortalManager.new(aztecNode, l1Client, log);
     const claim = await portal.bridgeTokensPublic(recipient, amount, true);
-    const isSynced = async ()=>await pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+    const isSynced = async ()=>await aztecNode.getL1ToL2MessageBlock(Fr.fromHexString(claim.messageHash)) !== undefined;
     await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 0.5);
     log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
     return claim;
 }
-async function advanceL2Block(node) {
-    const initialBlockNumber = await node.getBlockNumber();
-    await node.flushTxs();
-    await retryUntil(async ()=>await node.getBlockNumber() >= initialBlockNumber + 1);
+async function advanceL2Block(aztecNode, nodeAdmin) {
+    const initialBlockNumber = await aztecNode.getBlockNumber();
+    let minTxsPerBlock = undefined;
+    if (nodeAdmin) {
+        ({ minTxsPerBlock } = await nodeAdmin.getConfig());
+        await nodeAdmin.setConfig({
+            minTxsPerBlock: 0
+        }); // Set to 0 to ensure we can advance the block
+    }
+    await retryUntil(async ()=>await aztecNode.getBlockNumber() >= initialBlockNumber + 1);
+    if (nodeAdmin && minTxsPerBlock !== undefined) {
+        await nodeAdmin.setConfig({
+            minTxsPerBlock
+        });
+    }
 }
-async function deployTokenAndMint(wallets, admin, mintAmount, logger) {
+async function deployTokenAndMint(wallet, accounts, admin, mintAmount, paymentMethod, logger) {
     logger.verbose(`Deploying TokenContract...`);
-    const tokenContract = await TokenContract.deploy(wallets[0], admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS).send().deployed({
+    const tokenContract = await TokenContract.deploy(wallet, admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS).send({
+        from: admin,
+        fee: {
+            paymentMethod
+        }
+    }).deployed({
         timeout: 600
     });
     const tokenAddress = tokenContract.address;
-    logger.verbose(`Minting ${mintAmount} public assets to the ${wallets.length} wallets...`);
-    await Promise.all(wallets.map(async (w)=>(await TokenContract.at(tokenAddress, w)).methods.mint_to_public(w.getAddress(), mintAmount).send().wait({
+    logger.verbose(`Minting ${mintAmount} public assets to the ${accounts.length} accounts...`);
+    await Promise.all(accounts.map(async (acc)=>(await TokenContract.at(tokenAddress, wallet)).methods.mint_to_public(acc, mintAmount).send({
+            from: admin,
+            fee: {
+                paymentMethod
+            }
+        }).wait({
             timeout: 600
         })));
     logger.verbose(`Minting complete.`);
     return tokenAddress;
 }
-export async function performTransfers({ testWallets, rounds, transferAmount, logger }) {
-    const recipient = testWallets.recipientWallet.getAddress();
+export async function performTransfers({ wallet, testAccounts, rounds, transferAmount, logger, feePaymentMethod }) {
+    const recipient = testAccounts.recipientAddress;
+    // Default to sponsored fee payment if no fee method is provided
+    const defaultFeePaymentMethod = feePaymentMethod || new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
     for(let i = 0; i < rounds; i++){
-        const interactions = await Promise.all(testWallets.wallets.map(async (w)=>(await TokenContract.at(testWallets.tokenAddress, w)).methods.transfer_in_public(w.getAddress(), recipient, transferAmount, 0)));
-        const txs = await Promise.all(interactions.map(async (i)=>await i.prove()));
-        await Promise.all(txs.map((t)=>t.send().wait({
+        const txs = testAccounts.accounts.map(async (acc)=>{
+            const token = await TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet);
+            return proveInteraction(wallet, token.methods.transfer_in_public(acc, recipient, transferAmount, 0), {
+                from: acc,
+                fee: {
+                    paymentMethod: defaultFeePaymentMethod
+                }
+            });
+        });
+        const provenTxs = await Promise.all(txs);
+        await Promise.all(provenTxs.map((t)=>t.send().wait({
                 timeout: 600
             })));
         logger.info(`Completed round ${i + 1} / ${rounds}`);
     }
 }
+export async function createWalletAndAztecNodeClient(nodeUrl, proverEnabled, logger) {
+    const aztecNode = createAztecNodeClient(nodeUrl);
+    const [bbConfig, acvmConfig] = await Promise.all([
+        getBBConfig(logger),
+        getACVMConfig(logger)
+    ]);
+    const pxeConfig = {
+        dataDirectory: undefined,
+        dataStoreMapSizeKb: 1024 * 1024,
+        ...bbConfig,
+        ...acvmConfig,
+        proverEnabled
+    };
+    const wallet = await TestWallet.create(aztecNode, pxeConfig);
+    return {
+        wallet,
+        aztecNode,
+        async cleanup () {
+            await wallet.stop();
+            await bbConfig?.cleanup();
+            await acvmConfig?.cleanup();
+        }
+    };
+}