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

package/src/fixtures/web3signer.ts

@@ -0,0 +1,46 @@
+import { sleep } from '@aztec/aztec.js';
+import { randomBytes } from '@aztec/foundation/crypto';
+
+import { mkdirSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export async function createWeb3SignerKeystore(dir: string, ...privateKeys: string[]) {
+  const yaml = privateKeys
+    .map(
+      pk => `\
+type: file-raw
+keyType: SECP256K1
+privateKey: ${pk}`,
+    )
+    .join('\n---\n');
+
+  // NOTE: nodejs stdlib can only create temp directories, not temp files!
+  // this write uses wx (write-exclusive) so it'll throw if the file already exists
+  const path = join(dir, `keystore-${randomBytes(4).toString('hex')}.yaml`);
+  await writeFile(path, yaml, { flag: 'wx' });
+}
+
+export async function refreshWeb3Signer(url: string) {
+  await fetch(new URL('reload', url), { method: 'POST' });
+  // give the service a chance to load up the new files
+  // 1s might not be enough if there are a lot of files to scan
+  await sleep(1000);
+}
+
+export function getWeb3SignerTestKeystoreDir(): string {
+  if (process.env.WEB3_SIGNER_TEST_KEYSTORE_DIR) {
+    mkdirSync(process.env.WEB3_SIGNER_TEST_KEYSTORE_DIR, { recursive: true });
+    return process.env.WEB3_SIGNER_TEST_KEYSTORE_DIR;
+  } else {
+    throw new Error('Web3signer not running');
+  }
+}
+
+export function getWeb3SignerUrl(): string {
+  if (process.env.WEB3_SIGNER_URL) {
+    return process.env.WEB3_SIGNER_URL;
+  } else {
+    throw new Error('Web3signer not running');
+  }
+}

package/src/guides/up_quick_start.sh

@@ -1,9 +1,10 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Run locally from end-to-end folder while running anvil and sandbox with:
 # PATH=$PATH:../node_modules/.bin ./src/guides/up_quick_start.sh
 set -eux
 
 export WALLET_DATA_DIRECTORY=$(mktemp -d)/up_quick_start
+export PXE_PROVER="none"
 
 function on_exit {
   echo "Cleaning up $WALLET_DATA_DIRECTORY..."
@@ -30,7 +31,7 @@ echo "Deployed contract at $TOKEN_ADDRESS"
 
 # docs:start:mint-private
 MINT_AMOUNT=69
-aztec-wallet send mint_to_private -ca last --args accounts:test0 accounts:alice $MINT_AMOUNT -f test0
+aztec-wallet send mint_to_private -ca last --args accounts:alice $MINT_AMOUNT -f test0
 # docs:end:mint-private
 
 # docs:start:get-balance
@@ -45,9 +46,8 @@ fi
 TRANSFER_AMOUNT=42
 
 aztec-wallet create-authwit transfer_in_private accounts:test0 -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -f alice
-aztec-wallet add-authwit authwits:last alice -f test0
 
-aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -f test0
+aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -aw authwits:last -f test0
 # docs:end:transfer
 
 # Test end result

package/src/shared/cross_chain_test_harness.ts

@@ -1,6 +1,7 @@
 // docs:start:cross_chain_test_harness
 import {
   type AccountWallet,
+  AuthWitness,
   type AztecAddress,
   type AztecNode,
   EthAddress,
@@ -15,10 +16,9 @@ import {
   type SiblingPath,
   type TxReceipt,
   type Wallet,
-  deployL1Contract,
   retryUntil,
 } from '@aztec/aztec.js';
-import type { L1ContractAddresses, ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { type ExtendedViemWalletClient, type L1ContractAddresses, deployL1Contract } from '@aztec/ethereum';
 import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -40,8 +40,7 @@ import { mintTokensToPrivate } from '../fixtures/token_utils.js';
  */
 export async function deployAndInitializeTokenAndBridgeContracts(
   wallet: Wallet,
-  walletClient: ViemWalletClient,
-  publicClient: ViemPublicClient,
+  l1Client: ExtendedViemWalletClient,
   rollupRegistryAddress: EthAddress,
   owner: AztecAddress,
   underlyingERC20Address: EthAddress,
@@ -68,35 +67,34 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   underlyingERC20: any;
 }> {
   // deploy the token portal
-  const { address: tokenPortalAddress } = await deployL1Contract(
-    walletClient,
-    publicClient,
-    TokenPortalAbi,
-    TokenPortalBytecode,
-  );
+  const { address: tokenPortalAddress } = await deployL1Contract(l1Client, TokenPortalAbi, TokenPortalBytecode);
   const tokenPortal = getContract({
     address: tokenPortalAddress.toString(),
     abi: TokenPortalAbi,
-    client: walletClient,
+    client: l1Client,
   });
 
   // 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`);
   }
 
@@ -109,13 +107,24 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   const underlyingERC20 = getContract({
     address: underlyingERC20Address.toString(),
     abi: TestERC20Abi,
-    client: walletClient,
+    client: l1Client,
   });
 
   return { token, bridge, tokenPortalAddress, tokenPortal, underlyingERC20 };
 }
 // docs:end:deployAndInitializeTokenAndBridgeContracts
 
+export type CrossChainContext = {
+  l2Token: AztecAddress;
+  l2Bridge: AztecAddress;
+  tokenPortal: EthAddress;
+  underlying: EthAddress;
+  ethAccount: EthAddress;
+  ownerAddress: AztecAddress;
+  inbox: EthAddress;
+  outbox: EthAddress;
+};
+
 /**
  * A Class for testing cross chain interactions, contains common interactions
  * shared between cross chain tests.
@@ -124,21 +133,20 @@ export class CrossChainTestHarness {
   static async new(
     aztecNode: AztecNode,
     pxeService: PXE,
-    publicClient: ViemPublicClient,
-    walletClient: ViemWalletClient,
+    l1Client: ExtendedViemWalletClient,
     wallet: AccountWallet,
+    ownerAddress: AztecAddress,
     logger: Logger,
     underlyingERC20Address: EthAddress,
   ): Promise<CrossChainTestHarness> {
-    const ethAccount = EthAddress.fromString((await walletClient.getAddresses())[0]);
+    const ethAccount = EthAddress.fromString((await l1Client.getAddresses())[0]);
     const l1ContractAddresses = (await pxeService.getNodeInfo()).l1ContractAddresses;
 
     // Deploy and initialize all required contracts
     logger.info('Deploying and initializing token, portal and its bridge...');
     const { token, bridge, tokenPortalAddress, underlyingERC20 } = await deployAndInitializeTokenAndBridgeContracts(
       wallet,
-      walletClient,
-      publicClient,
+      l1Client,
       l1ContractAddresses.registryAddress,
       wallet.getAddress(),
       underlyingERC20Address,
@@ -154,18 +162,16 @@ export class CrossChainTestHarness {
       ethAccount,
       tokenPortalAddress,
       underlyingERC20.address,
-      publicClient,
-      walletClient,
+      l1Client,
       l1ContractAddresses,
       wallet,
+      ownerAddress,
     );
   }
 
   private readonly l1TokenManager: L1TokenManager;
   private readonly l1TokenPortalManager: L1TokenPortalManager;
 
-  public readonly ownerAddress: AztecAddress;
-
   constructor(
     /** Aztec node instance. */
     public aztecNode: AztecNode,
@@ -186,23 +192,24 @@ export class CrossChainTestHarness {
     public tokenPortalAddress: EthAddress,
     /** Underlying token for portal tests. */
     public underlyingERC20Address: EthAddress,
-    /** Viem Public client instance. */
-    public publicClient: ViemPublicClient,
-    /** Viem Wallet Client instance. */
-    public walletClient: ViemWalletClient,
+    /** Viem Extended client instance. */
+    public l1Client: ExtendedViemWalletClient,
 
     /** Deployment addresses for all L1 contracts */
     public readonly l1ContractAddresses: L1ContractAddresses,
 
     /** 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,
       this.underlyingERC20Address,
+      this.l1ContractAddresses.feeAssetHandlerAddress,
       this.l1ContractAddresses.outboxAddress,
-      this.publicClient,
-      this.walletClient,
+      this.l1Client,
       this.logger,
     );
     this.l1TokenManager = this.l1TokenPortalManager.getTokenManager();
@@ -210,8 +217,15 @@ export class CrossChainTestHarness {
   }
 
   async mintTokensOnL1(amount: bigint) {
-    await this.l1TokenManager.mint(amount, this.ethAccount.toString());
-    expect(await this.l1TokenManager.getL1TokenBalance(this.ethAccount.toString())).toEqual(amount);
+    const contract = getContract({
+      abi: TestERC20Abi,
+      address: this.l1TokenManager.tokenAddress.toString(),
+      client: this.l1Client,
+    });
+    const balanceBefore = await this.l1TokenManager.getL1TokenBalance(this.ethAccount.toString());
+    const hash = await contract.write.mint([this.ethAccount.toString(), amount]);
+    await this.l1Client.waitForTransactionReceipt({ hash });
+    expect(await this.l1TokenManager.getL1TokenBalance(this.ethAccount.toString())).toEqual(balanceBefore + amount);
   }
 
   getL1BalanceOf(address: EthAddress) {
@@ -228,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(
@@ -247,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();
   }
 
@@ -258,23 +275,27 @@ 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();
   }
 
-  async withdrawPrivateFromAztecToL1(withdrawAmount: bigint, nonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  async withdrawPrivateFromAztecToL1(
+    withdrawAmount: bigint,
+    authwitNonce: Fr = Fr.ZERO,
+    authWitness: AuthWitness,
+  ): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
-      .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, nonce)
-      .send()
+      .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress })
       .wait();
 
     return withdrawReceipt;
   }
 
-  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, nonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  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, nonce)
-      .send()
+      .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
+      .send({ from: this.ownerAddress })
       .wait();
 
     return withdrawReceipt;
@@ -291,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) {
@@ -299,8 +320,8 @@ export class CrossChainTestHarness {
     expect(balance).toBe(expectedBalance);
   }
 
-  getL2ToL1MessageLeaf(withdrawAmount: bigint, callerOnL1: EthAddress = EthAddress.ZERO): Fr {
-    return this.l1TokenPortalManager.getL2ToL1MessageLeaf(
+  async getL2ToL1MessageLeaf(withdrawAmount: bigint, callerOnL1: EthAddress = EthAddress.ZERO): Promise<Fr> {
+    return await this.l1TokenPortalManager.getL2ToL1MessageLeaf(
       withdrawAmount,
       this.ethAccount,
       this.l2Bridge.address,
@@ -325,12 +346,18 @@ 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, nonce = Fr.ZERO) {
+  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, nonce).send().wait();
+    await this.l2Token.methods
+      .transfer_to_public(this.ownerAddress, this.ownerAddress, amount, authwitNonce)
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   /**
@@ -348,5 +375,18 @@ export class CrossChainTestHarness {
     await this.mintTokensPublicOnL2(0n);
     await this.mintTokensPublicOnL2(0n);
   }
+
+  toCrossChainContext(): CrossChainContext {
+    return {
+      l2Token: this.l2Token.address,
+      l2Bridge: this.l2Bridge.address,
+      tokenPortal: this.tokenPortalAddress,
+      underlying: this.underlyingERC20Address,
+      ethAccount: this.ethAccount,
+      ownerAddress: this.ownerAddress,
+      inbox: this.l1ContractAddresses.inboxAddress,
+      outbox: this.l1ContractAddresses.outboxAddress,
+    };
+  }
 }
 // docs:end:cross_chain_test_harness

package/src/shared/gas_portal_test_harness.ts

@@ -11,23 +11,24 @@ import {
   type Wallet,
   retryUntil,
 } from '@aztec/aztec.js';
-import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 export interface IGasBridgingTestHarness {
   getL1FeeJuiceBalance(address: EthAddress): Promise<bigint>;
-  prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress): Promise<L2AmountClaim>;
-  bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress): Promise<void>;
+  prepareTokensOnL1(owner: AztecAddress): Promise<L2AmountClaim>;
+  bridgeFromL1ToL2(owner: AztecAddress, claimer: AztecAddress): Promise<void>;
   feeJuice: FeeJuiceContract;
   l1FeeJuiceAddress: EthAddress;
 }
 
 export interface FeeJuicePortalTestingHarnessFactoryConfig {
   aztecNode: AztecNode;
+  aztecNodeAdmin?: AztecNodeAdmin;
   pxeService: PXE;
-  publicClient: ViemPublicClient;
-  walletClient: ViemWalletClient;
+  l1Client: ExtendedViemWalletClient;
   wallet: Wallet;
   logger: Logger;
   mockL1?: boolean;
@@ -37,9 +38,9 @@ export class FeeJuicePortalTestingHarnessFactory {
   private constructor(private config: FeeJuicePortalTestingHarnessFactoryConfig) {}
 
   private async createReal() {
-    const { aztecNode, pxeService, publicClient, walletClient, wallet, logger } = this.config;
+    const { aztecNode, aztecNodeAdmin, pxeService, l1Client, wallet, logger } = this.config;
 
-    const ethAccount = EthAddress.fromString((await walletClient.getAddresses())[0]);
+    const ethAccount = EthAddress.fromString((await l1Client.getAddresses())[0]);
     const l1ContractAddresses = (await pxeService.getNodeInfo()).l1ContractAddresses;
 
     const feeJuiceAddress = l1ContractAddresses.feeJuiceAddress;
@@ -53,14 +54,15 @@ export class FeeJuicePortalTestingHarnessFactory {
 
     return new GasBridgingTestHarness(
       aztecNode,
+      aztecNodeAdmin,
       pxeService,
       logger,
       gasL2,
       ethAccount,
       feeJuicePortalAddress,
       feeJuiceAddress,
-      publicClient,
-      walletClient,
+      l1ContractAddresses.feeAssetHandlerAddress!,
+      l1Client,
     );
   }
 
@@ -81,6 +83,8 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   constructor(
     /** Aztec node */
     public aztecNode: AztecNode,
+    /** Aztec node admin interface */
+    public aztecNodeAdmin: AztecNodeAdmin | undefined,
     /** Private eXecution Environment (PXE). */
     public pxeService: PXE,
     /** Logger. */
@@ -96,44 +100,45 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     public feeJuicePortalAddress: EthAddress,
     /** Underlying token for portal tests. */
     public l1FeeJuiceAddress: EthAddress,
-    /** Viem Public client instance. */
-    public publicClient: ViemPublicClient,
-    /** Viem Wallet Client instance. */
-    public walletClient: ViemWalletClient,
+    /** Fee asset handler address. */
+    public feeAssetHandlerAddress: EthAddress,
+    /** Viem Extended client instance. */
+    public l1Client: ExtendedViemWalletClient,
   ) {
     this.feeJuicePortalManager = new L1FeeJuicePortalManager(
       this.feeJuicePortalAddress,
       this.l1FeeJuiceAddress,
-      this.publicClient,
-      this.walletClient,
+      this.feeAssetHandlerAddress,
+      this.l1Client,
       this.logger,
     );
 
     this.l1TokenManager = this.feeJuicePortalManager.getTokenManager();
   }
 
-  async mintTokensOnL1(amount: bigint, to: EthAddress = this.ethAccount) {
-    const balanceBefore = await this.l1TokenManager.getL1TokenBalance(to.toString());
-    await this.l1TokenManager.mint(amount, to.toString());
-    expect(await this.l1TokenManager.getL1TokenBalance(to.toString())).toEqual(balanceBefore + amount);
+  async mintTokensOnL1(to: EthAddress = this.ethAccount) {
+    // const balanceBefore = await this.l1TokenManager.getL1TokenBalance(to.toString());
+    await this.l1TokenManager.mint(to.toString());
+
+    // expect(await this.l1TokenManager.getL1TokenBalance(to.toString())).toEqual(balanceBefore + amount);
   }
 
   async getL1FeeJuiceBalance(address: EthAddress) {
     return await this.l1TokenManager.getL1TokenBalance(address.toString());
   }
 
-  sendTokensToPortalPublic(bridgeAmount: bigint, l2Address: AztecAddress, mint = false) {
-    return this.feeJuicePortalManager.bridgeTokensPublic(l2Address, bridgeAmount, mint);
+  sendTokensToPortalPublic(bridgeAmount: bigint, l2Address: AztecAddress) {
+    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) {
@@ -141,8 +146,10 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     expect(balance).toBe(expectedBalance);
   }
 
-  async prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress) {
-    const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner, true);
+  async prepareTokensOnL1(owner: AztecAddress) {
+    const bridgeAmount = await this.l1TokenManager.getMintAmount();
+    await this.mintTokensOnL1();
+    const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner);
 
     const isSynced = async () => await this.aztecNode.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
     await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
@@ -154,19 +161,28 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     return claim;
   }
 
-  async bridgeFromL1ToL2(bridgeAmount: bigint, owner: AztecAddress) {
+  async bridgeFromL1ToL2(owner: AztecAddress, claimer: AztecAddress) {
     // Prepare the tokens on the L1 side
-    const claim = await this.prepareTokensOnL1(bridgeAmount, owner);
+    const claim = await this.prepareTokensOnL1(owner);
 
     // Consume L1 -> L2 message and claim tokens privately on L2
-    await this.consumeMessageOnAztecAndClaimPrivately(owner, claim);
-    await this.expectPublicBalanceOnL2(owner, bridgeAmount);
+    await this.consumeMessageOnAztecAndClaimPrivately(owner, claimer, claim);
   }
 
   private async advanceL2Block() {
     const initialBlockNumber = await this.aztecNode.getBlockNumber();
-    await this.aztecNode.flushTxs();
+
+    let minTxsPerBlock = undefined;
+    if (this.aztecNodeAdmin) {
+      ({ minTxsPerBlock } = await this.aztecNodeAdmin.getConfig());
+      await this.aztecNodeAdmin.setConfig({ minTxsPerBlock: 0 }); // Set to 0 to ensure we can advance the block
+    }
+
     await retryUntil(async () => (await this.aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
+
+    if (this.aztecNodeAdmin && minTxsPerBlock !== undefined) {
+      await this.aztecNodeAdmin.setConfig({ minTxsPerBlock });
+    }
   }
 }
 // docs:end:cross_chain_test_harness