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

package/src/bench/utils.ts

@@ -1,16 +1,13 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { type AztecNode, BatchCall, INITIAL_L2_BLOCK_NUM, type SentTx, type WaitOpts } from '@aztec/aztec.js';
-import { mean, stdDev, timesParallel } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
-import { BenchmarkingContract } from '@aztec/noir-contracts.js/Benchmarking';
+import { type AztecNode, BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js';
+import { mean, stdDev, times } from '@aztec/foundation/collection';
+import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
 import { type PXEService, type PXEServiceConfig, createPXEService } from '@aztec/pxe/server';
 import type { MetricsType } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
-import { writeFileSync } from 'fs';
-import { mkdirpSync } from 'fs-extra';
-import { globSync } from 'glob';
-import { join } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
 
 import { type EndToEndContext, type SetupOptions, setup } from '../fixtures/utils.js';
 
@@ -25,7 +22,9 @@ export async function benchmarkSetup(
   },
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
-  const contract = await BenchmarkingContract.deploy(context.wallet).send().deployed();
+  const contract = await BenchmarkingContract.deploy(context.wallet)
+    .send({ from: context.wallet.getAddress() })
+    .deployed();
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
   const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
@@ -36,7 +35,11 @@ export async function benchmarkSetup(
     await telemetry.flush();
     const data = telemetry.getMeters();
     const formatted = formatMetricsForGithubBenchmarkAction(data, opts.metrics);
+    if (formatted.length === 0) {
+      throw new Error(`No benchmark data generated. Please review your test setup.`);
+    }
     const benchOutput = opts.benchOutput ?? process.env.BENCH_OUTPUT ?? 'bench.json';
+    mkdirSync(path.dirname(benchOutput), { recursive: true });
     writeFileSync(benchOutput, JSON.stringify(formatted));
     context.logger.info(`Wrote ${data.length} metrics to ${benchOutput}`);
     await origTeardown();
@@ -52,7 +55,7 @@ type MetricFilter = {
 };
 
 // See https://github.com/benchmark-action/github-action-benchmark/blob/e3c661617bc6aa55f26ae4457c737a55545a86a4/src/extract.ts#L659-L670
-type GithubActionBenchmarkResult = {
+export type GithubActionBenchmarkResult = {
   name: string;
   value: number;
   range?: string;
@@ -91,30 +94,6 @@ function getMetricValues(points: BenchmarkDataPoint[]) {
   }
 }
 
-/**
- * Creates and returns a directory with the current job name and a random number.
- * @param index - Index to merge into the dir path.
- * @returns A path to a created dir.
- */
-export function makeDataDirectory(index: number) {
-  const testName = expect.getState().currentTestName!.split(' ')[0].replaceAll('/', '_');
-  const db = join('data', testName, index.toString(), `${randomInt(99)}`);
-  mkdirpSync(db);
-  return db;
-}
-
-/**
- * Returns the size in disk of a folder.
- * @param path - Path to the folder.
- * @returns Size in bytes.
- */
-export function getFolderSize(path: string): number {
-  return globSync('**', { stat: true, cwd: path, nodir: true, withFileTypes: true }).reduce(
-    (accum, file) => accum + (file as any as { /** Size */ size: number }).size,
-    0,
-  );
-}
-
 /**
  * Returns a call to the benchmark contract. Each call has a private execution (account entrypoint),
  * a nested private call (create_note), a public call (increment_balance), and a nested public
@@ -126,22 +105,19 @@ export function getFolderSize(path: string): number {
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns A BatchCall instance.
  */
-export async function makeCall(
+function makeCall(
   index: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean,
 ) {
   const owner = context.wallet.getAddress();
-  const sender = owner;
   if (heavyPublicCompute) {
-    return new BatchCall(context.wallet, [
-      await contract.methods.sha256_hash_2048(randomBytesAsBigInts(2048)).request(),
-    ]);
+    return new BatchCall(context.wallet, [contract.methods.sha256_hash_2048(randomBytesAsBigInts(2048))]);
   } else {
     return new BatchCall(context.wallet, [
-      await contract.methods.create_note(owner, sender, index + 1).request(),
-      await contract.methods.increment_balance(owner, index + 1).request(),
+      contract.methods.create_note(owner, index + 1),
+      contract.methods.increment_balance(owner, index + 1),
     ]);
   }
 }
@@ -161,9 +137,9 @@ export async function sendTxs(
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
 ): Promise<SentTx[]> {
-  const calls = await timesParallel(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
+  const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
   context.logger.info(`Creating ${txCount} txs`);
-  const provenTxs = await Promise.all(calls.map(call => call.prove({ skipPublicSimulation: true })));
+  const provenTxs = await Promise.all(calls.map(call => call.prove({ from: context.wallet.getAddress() })));
   context.logger.info(`Sending ${txCount} txs`);
   return provenTxs.map(tx => tx.send());
 }
@@ -181,23 +157,21 @@ export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpt
  * @param startingBlock - First l2 block to process.
  * @returns The new PXE.
  */
-export async function createNewPXE(
-  node: AztecNode,
-  contract: BenchmarkingContract,
-  startingBlock: number = INITIAL_L2_BLOCK_NUM,
-): Promise<PXEService> {
+export async function createNewPXE(node: AztecNode, contract: BenchmarkingContract): Promise<PXEService> {
   const l1Contracts = await node.getL1ContractAddresses();
-  const { l1ChainId, protocolVersion } = await node.getNodeInfo();
+  const { l1ChainId, rollupVersion } = await node.getNodeInfo();
   const pxeConfig = {
-    l2StartingBlock: startingBlock,
+    l2BlockBatchSize: 50,
     l2BlockPollingIntervalMS: 100,
     dataDirectory: undefined,
-    dataStoreMapSizeKB: 1024 * 1024,
+    dataStoreMapSizeKb: 1024 * 1024,
     l1Contracts,
     l1ChainId,
-    version: protocolVersion,
+    rollupVersion,
   } as PXEServiceConfig;
+  // docs:start:PXEcreate
   const pxe = await createPXEService(node, pxeConfig);
+  // docs:end:PXEcreate
   await pxe.registerContract(contract);
   return pxe;
 }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -1,17 +1,21 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
   type AccountWallet,
+  AztecAddress,
+  type AztecNode,
   type CompleteAddress,
   Fr,
   type Logger,
+  type PXE,
   type TxHash,
   computeSecretHash,
   createLogger,
 } from '@aztec/aztec.js';
-import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { DocsExampleContract } from '@aztec/noir-contracts.js/DocsExample';
+import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
+import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
+import type { SequencerClient } from '@aztec/sequencer-client';
 
 import { jest } from '@jest/globals';
 
@@ -54,31 +58,39 @@ export class Role {
 }
 
 export class BlacklistTokenContractTest {
-  // A low delay is really poor ux, but we need to keep it low for the tests to run "quickly".
   // This value MUST match the same value that we have in the contract
-  static DELAY = 2;
+  static CHANGE_ROLES_DELAY = 86400;
 
   private snapshotManager: ISnapshotManager;
   logger: Logger;
   wallets: AccountWallet[] = [];
+  pxe!: PXE;
   accounts: CompleteAddress[] = [];
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
-  badAccount!: DocsExampleContract;
+  badAccount!: InvalidAccountContract;
+  cheatCodes!: CheatCodes;
+  sequencer!: SequencerClient;
+  aztecNode!: AztecNode;
 
   admin!: AccountWallet;
+  adminAddress!: AztecAddress;
   other!: AccountWallet;
+  otherAddress!: AztecAddress;
   blacklisted!: AccountWallet;
+  blacklistedAddress!: AztecAddress;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
     this.snapshotManager = createSnapshotManager(`e2e_blacklist_token_contract/${testName}`, dataPath);
   }
 
-  async mineBlocks(amount: number = BlacklistTokenContractTest.DELAY) {
-    for (let i = 0; i < amount; ++i) {
-      await this.asset.methods.get_roles(this.admin.getAddress()).send().wait();
-    }
+  async crossTimestampOfChange() {
+    await this.cheatCodes.warpL2TimeAtLeastBy(
+      this.sequencer,
+      this.aztecNode,
+      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
+    );
   }
 
   /**
@@ -93,11 +105,18 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
+      async ({ deployedAccounts }, { pxe, cheatCodes, aztecNode, sequencer }) => {
+        this.pxe = pxe;
+        this.cheatCodes = cheatCodes;
+        this.aztecNode = aztecNode;
+        this.sequencer = sequencer;
         this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.admin = this.wallets[0];
+        this.adminAddress = this.admin.getAddress();
         this.other = this.wallets[1];
+        this.otherAddress = this.other.getAddress();
         this.blacklisted = this.wallets[2];
+        this.blacklistedAddress = this.blacklisted.getAddress();
         this.accounts = this.wallets.map(w => w.getCompleteAddress());
       },
     );
@@ -108,17 +127,19 @@ export class BlacklistTokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.admin, this.accounts.slice(0, 3));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.admin, this.admin.getAddress()).send().deployed();
+        this.asset = await TokenBlacklistContract.deploy(this.admin, this.adminAddress)
+          .send({ from: this.adminAddress })
+          .deployed();
         this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await DocsExampleContract.deploy(this.wallets[0]).send().deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
-        await this.mineBlocks();
+        await this.crossTimestampOfChange();
 
         return { tokenContractAddress: this.asset.address, badAccountAddress: this.badAccount.address };
       },
@@ -129,15 +150,16 @@ export class BlacklistTokenContractTest {
 
         this.tokenSim = new TokenSimulator(
           this.asset as unknown as TokenContract,
-          this.wallets[0],
+          this.admin,
+          this.adminAddress,
           this.logger,
           this.accounts.map(a => a.address),
         );
 
-        this.badAccount = await DocsExampleContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
-        expect(await this.asset.methods.get_roles(this.admin.getAddress()).simulate()).toEqual(
+        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
           new Role().withAdmin().toNoirStruct(),
         );
       },
@@ -158,29 +180,25 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.teardown();
   }
 
-  #toBoundedVec(arr: Fr[], maxLen: number) {
-    return { len: arr.length, storage: arr.concat(new Array(maxLen - arr.length).fill(new Fr(0))) };
-  }
-
   async addPendingShieldNoteToPXE(
     contract: TokenBlacklistContract,
-    wallet: AccountWallet,
+    recipient: AztecAddress,
     amount: bigint,
     secretHash: Fr,
     txHash: TxHash,
   ) {
-    const txEffects = await wallet.getTxEffect(txHash);
+    const txEffects = await this.pxe.getTxEffect(txHash);
     await contract.methods
       .deliver_transparent_note(
         contract.address,
         amount,
         secretHash,
         txHash.hash,
-        this.#toBoundedVec(txEffects!.data.noteHashes, MAX_NOTE_HASHES_PER_TX),
+        txEffects!.data.noteHashes,
         txEffects!.data.nullifiers[0],
-        wallet.getAddress(),
+        recipient,
       )
-      .simulate();
+      .simulate({ from: recipient });
   }
 
   async applyMintSnapshot() {
@@ -194,33 +212,35 @@ export class BlacklistTokenContractTest {
         await this.asset
           .withWallet(this.admin)
           .methods.update_roles(this.admin.getAddress(), adminMinterRole.toNoirStruct())
-          .send()
+          .send({ from: this.adminAddress })
           .wait();
 
         const blacklistRole = new Role().withBlacklisted();
         await this.asset
           .withWallet(this.admin)
           .methods.update_roles(this.blacklisted.getAddress(), blacklistRole.toNoirStruct())
-          .send()
+          .send({ from: this.adminAddress })
           .wait();
 
-        await this.mineBlocks(); // This gets us past the block of change
+        await this.crossTimestampOfChange();
 
-        expect(await this.asset.methods.get_roles(this.admin.getAddress()).simulate()).toEqual(
-          adminMinterRole.toNoirStruct(),
-        );
+        expect(
+          await this.asset.methods.get_roles(this.admin.getAddress()).simulate({ from: this.adminAddress }),
+        ).toEqual(adminMinterRole.toNoirStruct());
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(accounts[0].address, amount).send().wait();
+        await asset.methods.mint_public(accounts[0].address, amount).send({ from: this.adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
         const secret = Fr.random();
         const secretHash = await computeSecretHash(secret);
-        const receipt = await asset.methods.mint_private(amount, secretHash).send().wait();
+        const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress }).wait();
 
-        await this.addPendingShieldNoteToPXE(asset, wallets[0], amount, secretHash, receipt.txHash);
-        const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send();
-        await txClaim.wait({ debug: true });
+        await this.addPendingShieldNoteToPXE(asset, wallets[0].getAddress(), amount, secretHash, receipt.txHash);
+        const txClaim = asset.methods
+          .redeem_shield(accounts[0].address, amount, secret)
+          .send({ from: this.adminAddress });
+        await txClaim.wait();
         this.logger.verbose(`Minting complete.`);
 
         return { amount };
@@ -233,16 +253,16 @@ export class BlacklistTokenContractTest {
         } = this;
         tokenSim.mintPublic(address, amount);
 
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
         expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
 
         tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
         expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -4,17 +4,23 @@ import {
   type AccountWallet,
   AztecAddress,
   type AztecNode,
-  CheatCodes,
   type CompleteAddress,
   EthAddress,
   type Logger,
   type PXE,
   createLogger,
 } from '@aztec/aztec.js';
-import { type ViemPublicClient, createL1Clients, deployL1Contract } from '@aztec/ethereum';
-import { InboxAbi, OutboxAbi, RollupAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
+import { CheatCodes } from '@aztec/aztec/testing';
+import {
+  type DeployL1ContractsReturnType,
+  type ExtendedViemWalletClient,
+  createExtendedL1Client,
+  deployL1Contract,
+} from '@aztec/ethereum';
+import { InboxAbi, OutboxAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { getContract } from 'viem';
 
@@ -33,26 +39,29 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class CrossChainMessagingTest {
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
   accounts: CompleteAddress[] = [];
   aztecNode!: AztecNode;
   pxe!: PXE;
   aztecNodeConfig!: AztecNodeConfig;
+  aztecNodeAdmin!: AztecNodeAdmin;
 
-  publicClient!: ViemPublicClient | undefined;
+  l1Client!: ExtendedViemWalletClient | undefined;
 
   user1Wallet!: AccountWallet;
+  user1Address!: AztecAddress;
   user2Wallet!: AccountWallet;
+  user2Address!: AztecAddress;
   crossChainTestHarness!: CrossChainTestHarness;
   ethAccount!: EthAddress;
   ownerAddress!: AztecAddress;
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
-  rollup!: any; // GetContractReturnType<typeof RollupAbi> | undefined;
   inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
   outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
-  cheatcodes!: CheatCodes;
+  cheatCodes!: CheatCodes;
+
+  deployL1ContractsValues!: DeployL1ContractsReturnType;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
@@ -60,15 +69,17 @@ export class CrossChainMessagingTest {
   }
 
   async assumeProven() {
-    await this.cheatcodes.rollup.markAsProven(await this.rollup.read.getPendingBlockNumber());
+    await this.cheatCodes.rollup.markAsProven();
   }
 
   async setup() {
-    const { aztecNode, pxe, aztecNodeConfig } = await this.snapshotManager.setup();
+    const { aztecNode, pxe, aztecNodeConfig, deployL1ContractsValues } = await this.snapshotManager.setup();
     this.aztecNode = aztecNode;
     this.pxe = pxe;
     this.aztecNodeConfig = aztecNodeConfig;
-    this.cheatcodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
+    this.cheatCodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
+    this.deployL1ContractsValues = deployL1ContractsValues;
+    this.aztecNodeAdmin = aztecNode;
   }
 
   snapshot = <T>(
@@ -88,19 +99,15 @@ export class CrossChainMessagingTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode, deployL1ContractsValues }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-
-        this.rollup = getContract({
-          address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-          abi: RollupAbi,
-          client: deployL1ContractsValues.walletClient,
-        });
+      async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode }) => {
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        this.accounts = wallets.map(w => w.getCompleteAddress());
+        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
 
-        this.user1Wallet = this.wallets[0];
-        this.user2Wallet = this.wallets[1];
+        this.user1Wallet = wallets[0];
+        this.user1Address = this.user1Wallet.getAddress();
+        this.user2Wallet = wallets[1];
+        this.user2Address = this.user2Wallet.getAddress();
 
         this.pxe = pxe;
         this.aztecNode = aztecNode;
@@ -114,41 +121,30 @@ export class CrossChainMessagingTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 3));
-
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-
-        const underlyingERC20Address = await deployL1Contract(
-          walletClient,
-          publicClient,
-          TestERC20Abi,
-          TestERC20Bytecode,
-          ['Underlying', 'UND', walletClient.account.address],
-        ).then(({ address }) => address);
-
-        const underlyingERC20 = getContract({
-          address: underlyingERC20Address!.toString(),
-          abi: TestERC20Abi,
-          client: walletClient,
-        });
+        await publicDeployAccounts(this.user1Wallet, this.accounts.slice(0, 3));
+
+        this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
-        // allow anyone to mint
-        await underlyingERC20.write.setFreeForAll([true], {} as any);
+        const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
+          'Underlying',
+          'UND',
+          this.l1Client.account.address,
+        ]).then(({ address }) => address);
 
         this.logger.verbose(`Setting up cross chain harness...`);
         this.crossChainTestHarness = await CrossChainTestHarness.new(
           this.aztecNode,
           this.pxe,
-          publicClient,
-          walletClient,
-          this.wallets[0],
+          this.l1Client,
+          this.user1Wallet,
+          this.user1Address,
           this.logger,
           underlyingERC20Address,
         );
 
         this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
 
-        return this.toCrossChainContext();
+        return this.crossChainTestHarness.toCrossChainContext();
       },
       async crossChainContext => {
         this.l2Token = await TokenContract.at(crossChainContext.l2Token, this.user1Wallet);
@@ -159,17 +155,17 @@ export class CrossChainMessagingTest {
         this.ownerAddress = AztecAddress.fromString(crossChainContext.ownerAddress.toString());
         const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
 
-        const { publicClient, walletClient } = createL1Clients(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
         const inbox = getContract({
           address: this.aztecNodeConfig.l1Contracts.inboxAddress.toString(),
           abi: InboxAbi,
-          client: walletClient,
+          client: l1Client,
         });
         const outbox = getContract({
           address: this.aztecNodeConfig.l1Contracts.outboxAddress.toString(),
           abi: OutboxAbi,
-          client: walletClient,
+          client: l1Client,
         });
 
         this.crossChainTestHarness = new CrossChainTestHarness(
@@ -181,40 +177,16 @@ export class CrossChainMessagingTest {
           this.ethAccount,
           tokenPortalAddress,
           crossChainContext.underlying,
-          publicClient,
-          walletClient,
+          l1Client,
           this.aztecNodeConfig.l1Contracts,
           this.user1Wallet,
+          this.user1Address,
         );
 
-        this.publicClient = publicClient;
+        this.l1Client = l1Client;
         this.inbox = inbox;
         this.outbox = outbox;
       },
     );
   }
-
-  toCrossChainContext(): CrossChainContext {
-    return {
-      l2Token: this.crossChainTestHarness.l2Token.address,
-      l2Bridge: this.crossChainTestHarness.l2Bridge.address,
-      tokenPortal: this.crossChainTestHarness.tokenPortalAddress,
-      underlying: this.crossChainTestHarness.underlyingERC20Address,
-      ethAccount: this.crossChainTestHarness.ethAccount,
-      ownerAddress: this.crossChainTestHarness.ownerAddress,
-      inbox: this.crossChainTestHarness.l1ContractAddresses.inboxAddress,
-      outbox: this.crossChainTestHarness.l1ContractAddresses.outboxAddress,
-    };
-  }
 }
-
-type CrossChainContext = {
-  l2Token: AztecAddress;
-  l2Bridge: AztecAddress;
-  tokenPortal: EthAddress;
-  underlying: EthAddress;
-  ethAccount: EthAddress;
-  ownerAddress: AztecAddress;
-  inbox: EthAddress;
-  outbox: EthAddress;
-};

package/src/e2e_deploy_contract/deploy_test.ts

@@ -11,9 +11,10 @@ import {
   type PublicKeys,
   type Wallet,
   createLogger,
-  getContractInstanceFromDeployParams,
+  getContractInstanceFromInstantiationParams,
 } from '@aztec/aztec.js';
-import type { StatefulTestContract } from '@aztec/noir-contracts.js/StatefulTest';
+import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
 
@@ -21,12 +22,12 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 
 export class DeployTest {
   private snapshotManager: ISnapshotManager;
-  private wallets: AccountWallet[] = [];
-
   public logger: Logger;
   public pxe!: PXE;
   public wallet!: AccountWallet;
+  public defaultAccountAddress!: AztecAddress;
   public aztecNode!: AztecNode;
+  public aztecNodeAdmin!: AztecNodeAdmin;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_deploy_contract:${testName}`);
@@ -37,6 +38,7 @@ export class DeployTest {
     await this.applyInitialAccountSnapshot();
     const context = await this.snapshotManager.setup();
     ({ pxe: this.pxe, aztecNode: this.aztecNode } = context);
+    this.aztecNodeAdmin = context.aztecNode;
     return this;
   }
 
@@ -49,9 +51,10 @@ export class DeployTest {
       'initial_account',
       deployAccounts(1, this.logger),
       async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        this.wallet = this.wallets[0];
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        this.wallet = wallets[0];
+        this.defaultAccountAddress = this.wallet.getAddress();
       },
     );
   }
@@ -68,7 +71,7 @@ export class DeployTest {
     } = {},
   ): Promise<T> {
     const { salt, publicKeys, initArgs, constructorName, deployer } = opts;
-    const instance = await getContractInstanceFromDeployParams(contractArtifact.artifact, {
+    const instance = await getContractInstanceFromInstantiationParams(contractArtifact.artifact, {
       constructorArgs: initArgs ?? [],
       constructorArtifact: constructorName,
       salt,