@aztec/end-to-end 1.0.0-nightly.20250810 → 1.0.0-nightly.20250812

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,5 +1,5 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type AztecNode, type CompleteAddress, type Logger, createLogger } from '@aztec/aztec.js';
+import { type AccountWallet, AztecAddress, type AztecNode, type Logger, createLogger } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 
@@ -23,13 +23,18 @@ export class TokenContractTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
-  badAccount!: InvalidAccountContract;
   node!: AztecNode;
 
+  badAccount!: InvalidAccountContract;
+  admin!: AccountWallet;
+  adminAddress!: AztecAddress;
+  account1!: AccountWallet;
+  account1Address!: AztecAddress;
+  account2!: AccountWallet;
+  account2Address!: AztecAddress;
+
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
     this.snapshotManager = createSnapshotManager(`e2e_token_contract/${testName}`, dataPath, {
@@ -51,8 +56,9 @@ export class TokenContractTest {
       deployAccounts(3, this.logger),
       async ({ deployedAccounts }, { pxe, aztecNode }) => {
         this.node = aztecNode;
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        [this.admin, this.account1, this.account2] = wallets;
+        [this.adminAddress, this.account1Address, this.account2Address] = wallets.map(w => w.getAddress());
       },
     );
 
@@ -62,42 +68,42 @@ export class TokenContractTest {
         // 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, 2));
+        await publicDeployAccounts(this.admin, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallets[0],
-          this.accounts[0],
+          this.admin,
+          this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
           TokenContractTest.TOKEN_DECIMALS,
         )
-          .send()
+          .send({ from: this.adminAddress })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.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}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.asset = await TokenContract.at(tokenContractAddress, this.admin);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(
-          this.asset,
-          this.wallets[0],
-          this.logger,
-          this.accounts.map(a => a.address),
-        );
+        this.tokenSim = new TokenSimulator(this.asset, this.admin, this.adminAddress, this.logger, [
+          this.adminAddress,
+          this.account1Address,
+        ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.admin);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
-        expect(await this.asset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
+          this.adminAddress.toBigInt(),
+        );
       },
     );
 
@@ -125,36 +131,32 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, wallets } = this;
+        const { asset, admin, adminAddress } = this;
         const amount = 10000n;
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_to_public(wallets[0].getAddress(), amount).send().wait();
+        await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, wallets[0], wallets[0].getAddress(), amount);
+        await mintTokensToPrivate(asset, adminAddress, admin, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };
       },
       async ({ amount }) => {
-        const {
-          asset,
-          accounts: [{ address }],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const { asset, adminAddress, tokenSim } = this;
+        tokenSim.mintPublic(adminAddress, amount);
+
+        const publicBalance = await asset.methods.balance_of_public(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
 
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        tokenSim.mintPrivate(adminAddress, amount);
+        const privateBalance = await asset.methods.balance_of_private(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/fixtures/e2e_prover_test.ts

@@ -141,7 +141,7 @@ export class FullProverTest {
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send()
+          .send({ from: this.wallets[0].getAddress() })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
@@ -155,11 +155,14 @@ export class FullProverTest {
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
           this.wallets[0],
+          this.wallets[0].getAddress(),
           this.logger,
           this.accounts.map(a => a.address),
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0].address })).toBe(
+          this.accounts[0].address.toBigInt(),
+        );
       },
     );
   }
@@ -365,11 +368,14 @@ export class FullProverTest {
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
           .mint_to_public(accounts[0].address, privateAmount + publicAmount)
-          .send()
+          .send({ from: accounts[0].address })
           .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods.transfer_to_private(accounts[0].address, privateAmount).send().wait();
+        await asset.methods
+          .transfer_to_private(accounts[0].address, privateAmount)
+          .send({ from: accounts[0].address })
+          .wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -383,16 +389,16 @@ export class FullProverTest {
         } = 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/fixtures/snapshot_manager.ts

@@ -666,7 +666,7 @@ export async function publicDeployAccounts(
 
   const batch = new BatchCall(sender, calls);
 
-  const txReceipt = await batch.send().wait();
+  const txReceipt = await batch.send({ from: accountAddressesToDeploy[0] }).wait();
   if (waitUntilProven) {
     if (!pxeOrNode) {
       throw new Error('Need to provide a PXE or AztecNode to wait for proven.');

package/src/fixtures/token_utils.ts

@@ -3,15 +3,20 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 // docs:start:token_utils
 
-export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigint, logger: Logger) {
+export async function deployToken(
+  adminWallet: Wallet,
+  deployerAddress: AztecAddress,
+  initialAdminBalance: bigint,
+  logger: Logger,
+) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(adminWallet, adminWallet.getAddress(), 'TokenName', 'TokenSymbol', 18)
-    .send()
+  const contract = await TokenContract.deploy(adminWallet, deployerAddress, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: deployerAddress })
     .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, deployerAddress, adminWallet, deployerAddress, initialAdminBalance);
   }
 
   logger.info('L2 contract deployed');
@@ -21,12 +26,13 @@ export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigi
 
 export async function mintTokensToPrivate(
   token: TokenContract,
+  minter: AztecAddress,
   minterWallet: Wallet,
   recipient: AztecAddress,
   amount: bigint,
 ) {
   const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
-  await tokenAsMinter.methods.mint_to_private(recipient, amount).send().wait();
+  await tokenAsMinter.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
 }
 // docs:end:token_utils
 
@@ -46,6 +52,7 @@ export async function expectTokenBalance(
 
 export async function mintNotes(
   sender: Wallet,
+  minter: AztecAddress,
   recipient: AztecAddress,
   asset: TokenContract,
   noteAmounts: bigint[],
@@ -56,7 +63,7 @@ export async function mintNotes(
   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(sender, actions).send().wait();
+    await new BatchCall(sender, actions).send({ from: minter }).wait();
   }
 
   return noteAmounts.reduce((prev, curr) => prev + curr, 0n);

package/src/fixtures/utils.ts

@@ -257,8 +257,9 @@ async function setupWithRemoteEnvironment(
     deployL1ContractsValues,
     config,
     initialFundedAccounts,
+    wallets,
     wallet: wallets[0],
-    wallets: wallets.slice(0, numberOfAccounts),
+    accounts: wallets.slice(0, numberOfAccounts).map(w => w.getAddress()),
     logger,
     cheatCodes,
     prefilledPublicData: undefined,
@@ -335,10 +336,12 @@ export type EndToEndContext = {
   config: AztecNodeConfig;
   /** The data for the initial funded accounts. */
   initialFundedAccounts: InitialAccountData[];
+  /* Wallets created for the initial funded accounts, with secret keys. */
+  wallets: AccountWalletWithSecretKey[];
   /** The first wallet to be used. */
   wallet: AccountWalletWithSecretKey;
-  /** The wallets to be used. */
-  wallets: AccountWalletWithSecretKey[];
+  /** The accounts to be used. */
+  accounts: AztecAddress[];
   /** Logger instance named as the current test. */
   logger: Logger;
   /** The cheat codes. */
@@ -710,8 +713,9 @@ export async function setup(
       sequencer: sequencerClient,
       teardown,
       telemetryClient: telemetry,
-      wallet: wallets[0],
       wallets,
+      wallet: wallets[0],
+      accounts: wallets.map(w => w.getAddress()),
       watcher,
     };
   } catch (err) {
@@ -750,11 +754,13 @@ export async function ensureAccountContractsPublished(sender: Wallet, accountsTo
   ).map(contractMetadata => contractMetadata.contractInstance);
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
   if (!(await sender.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
-    await (await publishContractClass(sender, SchnorrAccountContractArtifact)).send().wait();
+    await (await publishContractClass(sender, SchnorrAccountContractArtifact))
+      .send({ from: accountsToDeploy[0].getAddress() })
+      .wait();
   }
   const requests = await Promise.all(instances.map(async instance => await publishInstance(sender, instance!)));
   const batch = new BatchCall(sender, requests);
-  await batch.send().wait();
+  await batch.send({ from: accountsToDeploy[0].getAddress() }).wait();
 }
 // docs:end:public_deploy_accounts
 
@@ -794,11 +800,12 @@ export type BalancesFn = ReturnType<typeof getBalancesFn>;
 export function getBalancesFn(
   symbol: string,
   method: ContractMethod,
+  from: AztecAddress,
   logger: any,
 ): (...addresses: (AztecAddress | { address: AztecAddress })[]) => Promise<bigint[]> {
   const balances = async (...addressLikes: (AztecAddress | { address: AztecAddress })[]) => {
     const addresses = addressLikes.map(addressLike => ('address' in addressLike ? addressLike.address : addressLike));
-    const b = await Promise.all(addresses.map(address => method(address).simulate()));
+    const b = await Promise.all(addresses.map(address => method(address).simulate({ from })));
     const debugString = `${symbol} balances: ${addresses.map((address, i) => `${address}: ${b[i]}`).join(', ')}`;
     logger.verbose(debugString);
     return b;

package/src/sample-dapp/connect.mjs

@@ -4,7 +4,7 @@ import { createPXEClient } from '@aztec/aztec.js';
 const { PXE_URL = 'http://localhost:8080' } = process.env;
 
 async function main() {
-  const pxe = await createPXEClient(PXE_URL);
+  const pxe = createPXEClient(PXE_URL);
   const { l1ChainId } = await pxe.getNodeInfo();
   console.log(`Connected to chain ${l1ChainId}`);
 }

package/src/sample-dapp/contracts.mjs

@@ -7,7 +7,7 @@ import { readFileSync } from 'fs';
 const TokenContractArtifact = TokenContract.artifact;
 
 // docs:start:get-tokens
-export async function getToken(wallet) {
+export function getToken(wallet) {
   const addresses = JSON.parse(readFileSync('addresses.json'));
   return Contract.at(AztecAddress.fromString(addresses.token), TokenContractArtifact, wallet);
 }

package/src/sample-dapp/deploy.mjs

@@ -1,11 +1,11 @@
 // docs:start:deploy-imports
 import { getInitialTestAccountsWallets } from '@aztec/accounts/testing';
-import { Contract, createPXEClient, loadContractArtifact, waitForPXE } from '@aztec/aztec.js';
+import { Contract, createPXEClient, waitForPXE } from '@aztec/aztec.js';
 // docs:end:deploy-imports
 // docs:start:import_artifact
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+
 // docs:end:import_artifact
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 import { writeFileSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -21,7 +21,7 @@ async function main() {
   const ownerAddress = ownerWallet.getAddress();
 
   const token = await Contract.deploy(ownerWallet, TokenContractArtifact, [ownerAddress, 'TokenName', 'TKN', 18])
-    .send()
+    .send({ from: ownerAddress })
     .deployed();
 
   console.log(`Token deployed at ${token.address.toString()}`);

package/src/sample-dapp/index.mjs

@@ -25,7 +25,7 @@ async function showPrivateBalances(pxe) {
 
   for (const account of accounts) {
     // highlight-next-line:showPrivateBalances
-    const balance = await token.methods.balance_of_private(account.address).simulate();
+    const balance = await token.methods.balance_of_private(account.address).simulate({ from: account.address });
     console.log(`Balance of ${account.address}: ${balance}`);
   }
 }
@@ -40,7 +40,10 @@ async function mintPrivateFunds(pxe) {
 
   // We mint tokens to the owner
   const mintAmount = 20n;
-  await token.methods.mint_to_private(ownerWallet.getAddress(), mintAmount).send().wait();
+  await token.methods
+    .mint_to_private(ownerWallet.getAddress(), mintAmount)
+    .send({ from: ownerWallet.getAddress() })
+    .wait();
 
   await showPrivateBalances(pxe);
 }
@@ -53,7 +56,7 @@ async function transferPrivateFunds(pxe) {
 
   await showPrivateBalances(pxe);
   console.log(`Sending transaction, awaiting transaction to be mined`);
-  const receipt = await token.methods.transfer(recipient.getAddress(), 1).send().wait();
+  const receipt = await token.methods.transfer(recipient.getAddress(), 1).send({ from: owner.getAddress() }).wait();
 
   console.log(`Transaction ${receipt.txHash} has been mined on block ${receipt.blockNumber}`);
   await showPrivateBalances(pxe);
@@ -69,7 +72,7 @@ async function showPublicBalances(pxe) {
 
   for (const account of accounts) {
     // highlight-next-line:showPublicBalances
-    const balance = await token.methods.balance_of_public(account.address).simulate();
+    const balance = await token.methods.balance_of_public(account.address).simulate({ from: account.address });
     console.log(`Balance of ${account.address}: ${balance}`);
   }
 }
@@ -83,7 +86,7 @@ async function mintPublicFunds(pxe) {
   await showPublicBalances(pxe);
 
   console.log(`Sending transaction, awaiting transaction to be mined`);
-  const receipt = await token.methods.mint_to_public(owner.getAddress(), 100).send().wait();
+  const receipt = await token.methods.mint_to_public(owner.getAddress(), 100).send({ from: owner.getAddress() }).wait();
   console.log(`Transaction ${receipt.txHash} has been mined on block ${receipt.blockNumber}`);
 
   await showPublicBalances(pxe);
@@ -92,7 +95,9 @@ async function mintPublicFunds(pxe) {
   const blockNumber = await pxe.getBlockNumber();
   const logs = (await pxe.getPublicLogs({ fromBlock: blockNumber - 1 })).logs;
   const textLogs = logs.map(extendedLog => extendedLog.toHumanReadable().slice(0, 200));
-  for (const log of textLogs) console.log(`Log emitted: ${log}`);
+  for (const log of textLogs) {
+    console.log(`Log emitted: ${log}`);
+  }
   // docs:end:showLogs
 }
 // docs:end:mintPublicFunds
@@ -115,7 +120,6 @@ async function main() {
 
 // Execute main only if run directly
 if (process.argv[1].replace(/\/index\.m?js$/, '') === fileURLToPath(import.meta.url).replace(/\/index\.m?js$/, '')) {
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
   main()
     .then(() => process.exit(0))
     .catch(err => {

package/src/shared/cross_chain_test_harness.ts

@@ -75,22 +75,26 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   });
 
   // deploy l2 token
-  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18).send().deployed();
+  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: owner })
+    .deployed();
 
   // deploy l2 token bridge and attach to the portal
-  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress).send().deployed();
+  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress)
+    .send({ from: owner })
+    .deployed();
 
-  if ((await token.methods.get_admin().simulate()) !== owner.toBigInt()) {
+  if ((await token.methods.get_admin().simulate({ from: owner })) !== owner.toBigInt()) {
     throw new Error(`Token admin is not ${owner}`);
   }
 
-  if (!(await bridge.methods.get_config().simulate()).token.equals(token.address)) {
+  if (!(await bridge.methods.get_config().simulate({ from: owner })).token.equals(token.address)) {
     throw new Error(`Bridge token is not ${token.address}`);
   }
 
   // make the bridge a minter on the token:
-  await token.methods.set_minter(bridge.address, true).send().wait();
-  if ((await token.methods.is_minter(bridge.address).simulate()) === 1n) {
+  await token.methods.set_minter(bridge.address, true).send({ from: owner }).wait();
+  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
 
@@ -131,6 +135,7 @@ export class CrossChainTestHarness {
     pxeService: PXE,
     l1Client: ExtendedViemWalletClient,
     wallet: AccountWallet,
+    ownerAddress: AztecAddress,
     logger: Logger,
     underlyingERC20Address: EthAddress,
   ): Promise<CrossChainTestHarness> {
@@ -160,14 +165,13 @@ export class CrossChainTestHarness {
       l1Client,
       l1ContractAddresses,
       wallet,
+      ownerAddress,
     );
   }
 
   private readonly l1TokenManager: L1TokenManager;
   private readonly l1TokenPortalManager: L1TokenPortalManager;
 
-  public readonly ownerAddress: AztecAddress;
-
   constructor(
     /** Aztec node instance. */
     public aztecNode: AztecNode,
@@ -196,6 +200,9 @@ export class CrossChainTestHarness {
 
     /** Wallet of the owner. */
     public readonly ownerWallet: AccountWallet,
+
+    /** Owner of the l2 token and bridge */
+    public readonly ownerAddress: AztecAddress,
   ) {
     this.l1TokenPortalManager = new L1TokenPortalManager(
       this.tokenPortalAddress,
@@ -235,16 +242,19 @@ export class CrossChainTestHarness {
 
   async mintTokensPublicOnL2(amount: bigint) {
     this.logger.info('Minting tokens on L2 publicly');
-    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send().wait();
+    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress }).wait();
   }
 
   async mintTokensPrivateOnL2(amount: bigint) {
-    await mintTokensToPrivate(this.l2Token, this.ownerWallet, this.ownerAddress, amount);
+    await mintTokensToPrivate(this.l2Token, this.ownerAddress, this.ownerWallet, this.ownerAddress, amount);
   }
 
   async sendL2PublicTransfer(transferAmount: bigint, receiverAddress: AztecAddress) {
     // send a transfer tx to force through rollup with the message included
-    await this.l2Token.methods.transfer_in_public(this.ownerAddress, receiverAddress, transferAmount, 0).send().wait();
+    await this.l2Token.methods
+      .transfer_in_public(this.ownerAddress, receiverAddress, transferAmount, 0)
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async consumeMessageOnAztecAndMintPrivately(
@@ -254,7 +264,7 @@ export class CrossChainTestHarness {
     const { recipient, claimAmount, claimSecret: secretForL2MessageConsumption, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_private(recipient, claimAmount, secretForL2MessageConsumption, messageLeafIndex)
-      .send()
+      .send({ from: this.ownerAddress })
       .wait();
   }
 
@@ -265,7 +275,7 @@ export class CrossChainTestHarness {
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_public(this.ownerAddress, claimAmount, claimSecret, messageLeafIndex)
-      .send()
+      .send({ from: this.ownerAddress })
       .wait();
   }
 
@@ -276,7 +286,7 @@ export class CrossChainTestHarness {
   ): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ authWitnesses: [authWitness] })
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress })
       .wait();
 
     return withdrawReceipt;
@@ -285,7 +295,7 @@ export class CrossChainTestHarness {
   async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send()
+      .send({ from: this.ownerAddress })
       .wait();
 
     return withdrawReceipt;
@@ -302,7 +312,7 @@ export class CrossChainTestHarness {
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {
-    return await this.l2Token.methods.balance_of_public(owner).simulate();
+    return await this.l2Token.methods.balance_of_public(owner).simulate({ from: this.ownerAddress });
   }
 
   async expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {
@@ -336,14 +346,17 @@ export class CrossChainTestHarness {
 
   async transferToPrivateOnL2(shieldAmount: bigint) {
     this.logger.info('Transferring to private on L2');
-    await this.l2Token.methods.transfer_to_private(this.ownerAddress, shieldAmount).send().wait();
+    await this.l2Token.methods
+      .transfer_to_private(this.ownerAddress, shieldAmount)
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async transferToPublicOnL2(amount: bigint, authwitNonce = Fr.ZERO) {
     this.logger.info('Transferring tokens to public');
     await this.l2Token.methods
       .transfer_to_public(this.ownerAddress, this.ownerAddress, amount, authwitNonce)
-      .send()
+      .send({ from: this.ownerAddress })
       .wait();
   }
 

package/src/shared/gas_portal_test_harness.ts

@@ -22,7 +22,7 @@ import { getContract } from 'viem';
 export interface IGasBridgingTestHarness {
   getL1FeeJuiceBalance(address: EthAddress): Promise<bigint>;
   prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress): Promise<L2AmountClaim>;
-  bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress): Promise<void>;
+  bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress, claimer: AztecAddress): Promise<void>;
   feeJuice: FeeJuiceContract;
   l1FeeJuiceAddress: EthAddress;
 }
@@ -141,14 +141,14 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     return this.feeJuicePortalManager.bridgeTokensPublic(l2Address, bridgeAmount, false);
   }
 
-  async consumeMessageOnAztecAndClaimPrivately(owner: AztecAddress, claim: L2AmountClaim) {
+  async consumeMessageOnAztecAndClaimPrivately(owner: AztecAddress, claimer: AztecAddress, claim: L2AmountClaim) {
     this.logger.info('Consuming messages on L2 Privately');
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
-    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send().wait();
+    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send({ from: claimer }).wait();
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {
-    return await this.feeJuice.methods.balance_of_public(owner).simulate();
+    return await this.feeJuice.methods.balance_of_public(owner).simulate({ from: owner });
   }
 
   async expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {
@@ -170,12 +170,12 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     return claim;
   }
 
-  async bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress) {
+  async bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress, claimer: AztecAddress) {
     // Prepare the tokens on the L1 side
     const claim = await this.prepareTokensOnL1(bridgeAmount, owner);
 
     // Consume L1 -> L2 message and claim tokens privately on L2
-    await this.consumeMessageOnAztecAndClaimPrivately(owner, claim);
+    await this.consumeMessageOnAztecAndClaimPrivately(owner, claimer, claim);
   }
 
   private async advanceL2Block() {