@aztec/end-to-end 0.0.1-commit.d431d1c → 0.0.1-commit.d939eb5aa

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,10 +1,11 @@
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
 import { type FeePaymentMethod, PrivateFeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { CheatCodes } from '@aztec/aztec/testing';
+import { CheatCodes, getTokenAllowedSetupFunctions } from '@aztec/aztec/testing';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
@@ -26,7 +27,6 @@ import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../../fixtures/fixtures.js';
 import { type EndToEndContext, type SetupOptions, deployAccounts, setup, teardown } from '../../fixtures/setup.js';
@@ -37,6 +37,7 @@ import {
   FeeJuicePortalTestingHarnessFactory,
   type GasBridgingTestHarness,
 } from '../../shared/gas_portal_test_harness.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
 import { ProxyLogger } from './benchmark.js';
 import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './config.js';
 
@@ -130,24 +131,28 @@ export class ClientFlowsBenchmark {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
+    // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+    const tokenAllowList = await getTokenAllowedSetupFunctions();
     this.context = await setup(0, {
       ...this.setupOptions,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
       l1ContractsArgs: this.setupOptions,
+      txPublicSetupAllowListExtend: [...(this.setupOptions.txPublicSetupAllowListExtend ?? []), ...tokenAllowList],
     });
     await this.applyBaseSetup();
 
-    await this.context.aztecNodeService!.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+    await this.context.aztecNodeService.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
 
     const rollupContract = RollupContract.getFromConfig(this.context.config);
-    this.chainMonitor = new ChainMonitor(rollupContract, this.context.dateProvider!, this.logger, 200).start();
+    this.chainMonitor = new ChainMonitor(rollupContract, this.context.dateProvider, this.logger, 200).start();
 
     return this;
   }
 
   async teardown() {
     await this.chainMonitor.stop();
+    await this.userWallet?.stop();
     await teardown(this.context);
   }
 
@@ -156,21 +161,20 @@ export class ClientFlowsBenchmark {
     const { claimSecret: secret, messageLeafIndex: index } = claim;
     await this.feeJuiceContract.methods
       .claim(address, claim.claimAmount, secret, index)
-      .send({ from: this.adminAddress })
-      .wait();
+      .send({ from: this.adminAddress });
   }
 
   /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods
+    const { result: balanceBefore } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+      .simulate({ from: address });
 
     await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods
+    const { result: balanceAfter } = await this.bananaCoin.methods
       .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+      .simulate({ from: address });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -208,7 +212,7 @@ export class ClientFlowsBenchmark {
     const [{ address: adminAddress }, { address: sequencerAddress }] = deployedAccounts;
 
     this.adminWallet = this.context.wallet;
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.cheatCodes = this.context.cheatCodes;
 
     this.adminAddress = adminAddress;
@@ -236,8 +240,8 @@ export class ClientFlowsBenchmark {
     this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
 
     this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-      aztecNode: this.context.aztecNodeService!,
-      aztecNodeAdmin: this.context.aztecNodeService!,
+      aztecNode: this.context.aztecNodeService,
+      aztecNodeAdmin: this.context.aztecNodeService,
       l1Client: this.context.deployL1ContractsValues.l1Client,
       wallet: this.adminWallet,
       logger: this.logger,
@@ -252,9 +256,9 @@ export class ClientFlowsBenchmark {
       'BC',
       'BC',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
     this.bananaCoin = bananaCoin;
     this.bananaCoinInstance = bananaCoinInstance;
@@ -268,9 +272,9 @@ export class ClientFlowsBenchmark {
       'CBC',
       'CBC',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
     this.candyBarCoin = candyBarCoin;
     this.candyBarCoinInstance = candyBarCoinInstance;
@@ -286,9 +290,9 @@ export class ClientFlowsBenchmark {
       this.adminWallet,
       bananaCoin.address,
       this.adminAddress,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
 
     this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
@@ -336,12 +340,10 @@ export class ClientFlowsBenchmark {
     const benchysAddress = benchysAccountManager.address;
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
     const behchysDeployMethod = await benchysAccountManager.getDeployMethod();
-    await behchysDeployMethod
-      .send({
-        from: AztecAddress.ZERO,
-        fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
-      })
-      .wait();
+    await behchysDeployMethod.send({
+      from: NO_FROM,
+      fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
+    });
     // Register benchy on the user's Wallet, where we're going to be interacting from
     const accountManager = await this.userWallet.createAccount({
       secret: benchysAccount.getSecretKey(),
@@ -359,19 +361,17 @@ export class ClientFlowsBenchmark {
       'LPT',
       'LPT',
       18n,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({
+      from: this.adminAddress,
+    });
     const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
       this.adminWallet,
       this.bananaCoin.address,
       this.candyBarCoin.address,
       liquidityToken.address,
-    )
-      .send({ from: this.adminAddress })
-      .wait();
+    ).send({ from: this.adminAddress });
     this.logger.info(`AMM deployed at ${amm.address}`);
-    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress }).wait();
+    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
     this.liquidityToken = liquidityToken;
     this.liquidityTokenInstance = liquidityTokenInstance;
     this.amm = amm;
@@ -387,7 +387,7 @@ export class ClientFlowsBenchmark {
     // The private fee paying method assembled on the app side requires knowledge of the maximum
     // fee the user is willing to pay
     const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1.5);
-    const gasSettings = GasSettings.default({ maxFeesPerGas });
+    const gasSettings = GasSettings.fallback({ maxFeesPerGas });
     return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
   }
 

package/src/bench/client_flows/config.ts

@@ -6,7 +6,7 @@ export type ClientFlowConfig = {
   recursions?: number[];
 };
 
-type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm';
+type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm' | 'storageProof';
 
 export type ClientFlowsConfig = {
   [key in ClientFlows]: ClientFlowConfig;
@@ -34,6 +34,10 @@ export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1],
   },
+  storageProof: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
 };
 
 export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
@@ -58,4 +62,8 @@ export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1, 2],
   },
+  storageProof: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+  },
 };

package/src/bench/utils.ts

@@ -1,8 +1,10 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { BatchCall, NO_WAIT, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { waitForTx } from '@aztec/aztec.js/node';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
 import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
+import type { TxHash } from '@aztec/stdlib/tx';
 import type { MetricDefinition } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
@@ -23,10 +25,10 @@ export async function benchmarkSetup(
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
   const defaultAccountAddress = context.accounts[0];
-  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress }).deployed();
+  const { contract } = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress });
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
-  const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
+  const telemetry = context.telemetryClient as BenchmarkTelemetryClient;
   context.logger.warn(`Cleared benchmark data points from setup`);
   telemetry.clear();
   const origTeardown = context.teardown.bind(context);
@@ -142,18 +144,23 @@ export async function sendTxs(
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): Promise<SentTx[]> {
+): Promise<TxHash[]> {
   const calls = await Promise.all(times(txCount, index => makeCall(index, context, contract, heavyPublicCompute)));
   context.logger.info(`Creating ${txCount} txs`);
   const [from] = context.accounts;
   context.logger.info(`Sending ${txCount} txs`);
-  return calls.map(call => call.send({ from }));
+  return Promise.all(
+    calls.map(async call => {
+      const { txHash } = await call.send({ from, wait: NO_WAIT });
+      return txHash;
+    }),
+  );
 }
 
-export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
+export async function waitTxs(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
   context.logger.info(`Awaiting ${txs.length} txs to be mined`);
-  await Promise.all(txs.map(tx => tx.wait(txWaitOpts)));
-  context.logger.info(`All ${txs.length} txs have been mined`);
+  await Promise.all(txs.map(txHash => waitForTx(context.aztecNode, txHash, txWaitOpts)));
+  context.logger.info(`${txs.length} txs have been mined`);
 }
 
 function randomBytesAsBigInts(length: number): bigint[] {

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -7,14 +7,16 @@ import type { TxHash } from '@aztec/aztec.js/tx';
 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 { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import { jest } from '@jest/globals';
 
 import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
 import { TokenSimulator } from '../simulators/token_simulator.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 export class Role {
   private isAdmin = false;
@@ -53,9 +55,10 @@ export class BlacklistTokenContractTest {
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
+  authwitProxy!: GenericProxyContract;
   cheatCodes!: CheatCodes;
   sequencer!: SequencerClient;
-  aztecNode!: AztecNode;
+  aztecNode!: AztecNode & AztecNodeDebug;
 
   adminAddress!: AztecAddress;
   otherAddress!: AztecAddress;
@@ -66,11 +69,7 @@ export class BlacklistTokenContractTest {
   }
 
   async crossTimestampOfChange() {
-    await this.cheatCodes.warpL2TimeAtLeastBy(
-      this.sequencer,
-      this.aztecNode,
-      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
-    );
+    await this.cheatCodes.warpL2TimeAtLeastBy(this.aztecNode, BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
   }
 
   /**
@@ -92,7 +91,7 @@ export class BlacklistTokenContractTest {
     });
 
     this.cheatCodes = this.context.cheatCodes;
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.sequencer = this.context.sequencer!;
     this.wallet = this.context.wallet;
     this.adminAddress = deployedAccounts[0].address;
@@ -105,15 +104,26 @@ export class BlacklistTokenContractTest {
     await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
 
     this.logger.verbose(`Deploying TokenContract...`);
-    this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress)
-      .send({ from: this.adminAddress })
-      .deployed();
+    ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
     this.logger.verbose(`Deploying bad account...`);
-    this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
     this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
+    // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
+    // (so their notes are in scope), but msg_sender in the target must differ from the note owner
+    // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
+    this.logger.verbose(`Deploying generic proxy...`);
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
+
     await this.crossTimestampOfChange();
 
     this.tokenSim = new TokenSimulator(
@@ -124,9 +134,9 @@ export class BlacklistTokenContractTest {
       [this.adminAddress, this.otherAddress, this.blacklistedAddress],
     );
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      new Role().withAdmin().toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(new Role().withAdmin().toNoirStruct());
   }
 
   async setup() {
@@ -171,50 +181,47 @@ export class BlacklistTokenContractTest {
     const adminMinterRole = new Role().withAdmin().withMinter();
     await this.asset.methods
       .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
-      .send({ from: this.adminAddress })
-      .wait();
+      .send({ from: this.adminAddress });
 
     const blacklistRole = new Role().withBlacklisted();
     await this.asset.methods
       .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
-      .send({ from: this.adminAddress })
-      .wait();
+      .send({ from: this.adminAddress });
 
     await this.crossTimestampOfChange();
 
-    expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-      adminMinterRole.toNoirStruct(),
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(adminMinterRole.toNoirStruct());
 
     this.logger.verbose(`Minting ${amount} publicly...`);
-    await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress }).wait();
+    await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress });
 
     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({ from: this.adminAddress }).wait();
+    const { receipt } = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
 
     await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
-    const txClaim = asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
-    await txClaim.wait();
+    await asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
     this.logger.verbose(`Minting complete.`);
 
     tokenSim.mintPublic(this.adminAddress, amount);
 
-    const publicBalance = await asset.methods
+    const { result: publicBalance } = await asset.methods
       .balance_of_public(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
     expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
 
     tokenSim.mintPrivate(this.adminAddress, amount);
-    const privateBalance = await asset.methods
+    const { result: privateBalance } = await asset.methods
       .balance_of_private(this.adminAddress)
       .simulate({ from: this.adminAddress });
     this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
     expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
 
-    const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: this.adminAddress });
     this.logger.verbose(`Total supply: ${totalSupply}`);
     expect(totalSupply).toEqual(tokenSim.totalSupply);
   }

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -13,13 +13,12 @@ import type {
 } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
-import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { sleep } from '@aztec/foundation/sleep';
 import { 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 type { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
@@ -31,6 +30,7 @@ import {
   teardown,
 } from '../fixtures/setup.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 export class CrossChainMessagingTest {
   private requireEpochProven: boolean;
@@ -86,9 +86,8 @@ export class CrossChainMessagingTest {
   }
 
   async advanceToEpochProven(l2TxReceipt: TxReceipt): Promise<EpochNumber> {
-    const epoch = await this.rollup.getEpochNumberForCheckpoint(
-      CheckpointNumber.fromBlockNumber(l2TxReceipt.blockNumber!),
-    );
+    const block = await this.aztecNode.getBlock(l2TxReceipt.blockNumber!);
+    const epoch = await this.rollup.getEpochNumberForCheckpoint(block!.checkpointNumber);
     // Warp to the next epoch.
     await this.cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
     // Wait for the tx to be proven.
@@ -110,16 +109,16 @@ export class CrossChainMessagingTest {
 
   async applyBaseSetup() {
     // Set up base context fields
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.wallet = this.context.wallet;
     this.aztecNodeConfig = this.context.config;
     this.cheatCodes = this.context.cheatCodes;
     this.deployL1ContractsValues = this.context.deployL1ContractsValues;
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
 
     if (this.requireEpochProven) {
       // Turn off the watcher to prevent it from keep marking blocks as proven.
-      this.context.watcher!.setIsMarkingAsProven(false);
+      this.context.watcher.setIsMarkingAsProven(false);
     }
 
     // Deploy 3 accounts

package/src/e2e_deploy_contract/deploy_test.ts

@@ -8,9 +8,9 @@ import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { type EndToEndContext, deployAccounts, setup, teardown } from '../fixtures/setup.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 export class DeployTest {
   public context!: EndToEndContext;
@@ -30,9 +30,9 @@ export class DeployTest {
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
     });
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.wallet = this.context.wallet;
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
     await this.applyInitialAccount();
     return this;
   }