@aztec/end-to-end 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/fixtures/web3signer.ts

@@ -0,0 +1,63 @@
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { retryUntil } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
+import { RemoteSigner } from '@aztec/node-keystore';
+
+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, ...expectedAddresses: string[]) {
+  await fetch(new URL('reload', url), { method: 'POST' });
+
+  if (expectedAddresses.length > 0) {
+    await retryUntil(
+      async () => {
+        try {
+          await RemoteSigner.validateAccess(url, expectedAddresses);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      'web3signer refresh',
+      10,
+      0.5,
+    );
+  } else {
+    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/fixtures/with_telemetry_utils.ts

@@ -7,12 +7,12 @@ import {
 } from '@aztec/telemetry-client';
 import { OTelPinoStream } from '@aztec/telemetry-client/otel-pino-stream';
 
-export function getEndToEndTestTelemetryClient(metricsPort?: number): TelemetryClient {
+export async function getEndToEndTestTelemetryClient(metricsPort?: number): Promise<TelemetryClient> {
   if (metricsPort) {
     const otelStream = new OTelPinoStream({ levels });
     registerLoggingStream(otelStream);
   }
-  return initTelemetryClient(getEndToEndTestTelemetryConfig(metricsPort));
+  return await initTelemetryClient(getEndToEndTestTelemetryConfig(metricsPort));
 }
 
 /**

package/src/guides/up_quick_start.sh

@@ -1,9 +1,10 @@
-#!/bin/bash
-# Run locally from end-to-end folder while running anvil and sandbox with:
+#!/usr/bin/env bash
+# Run locally from end-to-end folder while running anvil and local network 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..."
@@ -18,37 +19,28 @@ aztec-wallet() {
 aztec-wallet import-test-accounts
 
 # docs:start:declare-accounts
-aztec-wallet create-account -a alice --payment method=fee_juice,feePayer=test0
-aztec-wallet create-account -a bob --payment method=fee_juice,feePayer=test0
+aztec-wallet create-account -a alice -f test0
+aztec-wallet create-account -a bob -f test0
 # docs:end:declare-accounts
 
-# docs:start:deploy
 DEPLOY_OUTPUT=$(aztec-wallet deploy ../noir-contracts.js/artifacts/token_contract-Token.json --args accounts:test0 Test TST 18 -f test0)
 TOKEN_ADDRESS=$(echo "$DEPLOY_OUTPUT" | grep -oE 'Contract deployed at 0x[0-9a-fA-F]+' | cut -d ' ' -f4)
 echo "Deployed contract at $TOKEN_ADDRESS"
-# docs:end:deploy
 
-# docs:start:mint-private
 MINT_AMOUNT=69
-aztec-wallet send mint_to_private -ca last --args accounts:test0 accounts:alice $MINT_AMOUNT -f test0
-# docs:end:mint-private
+aztec-wallet send mint_to_private -ca last --args accounts:alice $MINT_AMOUNT -f test0
 
-# docs:start:get-balance
 ALICE_BALANCE=$(aztec-wallet simulate balance_of_private -ca last --args accounts:alice -f alice)
 if ! echo $ALICE_BALANCE | grep -q $MINT_AMOUNT; then
   echo "Incorrect Alice balance after transaction (expected $MINT_AMOUNT but got $ALICE_BALANCE)"
   exit 1
 fi
-# docs:end:get-balance
 
-# docs:start:transfer
 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
-# docs:end:transfer
+aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -aw authwits:last -f test0
 
 # Test end result
 ALICE_BALANCE=$(aztec-wallet simulate balance_of_private -ca last --args accounts:alice -f alice)

package/src/quality_of_service/{alert_checker.ts → grafana_client.ts}

@@ -1,4 +1,4 @@
-import type { Logger } from '@aztec/aztec.js';
+import type { Logger } from '@aztec/aztec.js/log';
 
 import * as fs from 'fs';
 import * as yaml from 'js-yaml';
@@ -25,7 +25,7 @@ const DEFAULT_CONFIG: AlertCheckerConfig = {
   grafanaCredentials: 'admin:admin',
 };
 
-export class AlertChecker {
+export class GrafanaClient {
   private config: AlertCheckerConfig;
   private logger: Logger;
 

package/src/quality_of_service/prometheus_client.ts

@@ -0,0 +1,113 @@
+export type PromteheusClientOptions = {
+  server: URL;
+};
+
+export class PrometheusClient {
+  constructor(
+    private config: PromteheusClientOptions,
+    private httpClient: typeof fetch = fetch,
+  ) {}
+
+  public async querySingleValue(query: string, time = new Date()): Promise<number> {
+    const resp = await this.queryRaw(query, time);
+    if (resp.status === 'success') {
+      if (resp.data.resultType === 'vector') {
+        if (resp.data.result.length === 0) {
+          return 0;
+        }
+        const [_, value] = resp.data.result[0].value;
+        return parseFloat(value);
+      }
+    }
+
+    throw new TypeError('Unsupported response body', { cause: JSON.stringify(resp) });
+  }
+
+  public queryRaw(query: string, time = new Date()): Promise<PrometheusResponse> {
+    const searchParams = new URLSearchParams();
+    searchParams.set('query', query);
+    searchParams.set('time', String(Math.trunc(time.getTime() / 1000)));
+    searchParams.set('limit', '10');
+
+    return this.callPrometheus('query', searchParams);
+  }
+
+  public queryRangeRaw(
+    query: string,
+    step: PrometheusDuration,
+    start: Date,
+    end = new Date(),
+  ): Promise<PrometheusResponse> {
+    const searchParams = new URLSearchParams();
+    searchParams.set('query', query);
+    searchParams.set('step', step);
+    searchParams.set('start', String(Math.trunc(start.getTime() / 1000)));
+    searchParams.set('end', String(Math.trunc(end.getTime() / 1000)));
+    searchParams.set('limit', '10');
+
+    return this.callPrometheus('query_range', searchParams);
+  }
+
+  private async callPrometheus(api: string, searchParams: URLSearchParams): Promise<PrometheusResponse> {
+    const url = new URL('api/v1/' + api, this.config.server);
+    for (const [name, value] of searchParams) {
+      url.searchParams.append(name, value);
+    }
+
+    const resp = await this.httpClient(url, { method: 'GET' });
+    if (!resp.ok || resp.status !== 200) {
+      throw new Error('Invalid HTTP response from Prometheus', {
+        cause: {
+          url,
+          status: resp.status,
+          statusText: resp.statusText,
+        },
+      });
+    }
+
+    const body = await resp.json();
+    if ('status' in body && (body.status === 'error' || body.status === 'success')) {
+      return body;
+    }
+
+    throw new Error('Invalid response from Prometheus', {
+      cause: {
+        url,
+        body,
+      },
+    });
+  }
+}
+
+export type PrometheusDuration = `${number}s` | `${number}m` | `${number}h`;
+
+export type PrometheusData =
+  | {
+      resultType: 'vector';
+      result: Array<{
+        metric: unknown;
+        value: [unixTimestamp: number, value: string];
+      }>;
+    }
+  | {
+      resultType: 'matrix';
+      result: Array<{
+        metric: unknown;
+        values: [unixTimestamp: number, value: string];
+      }>;
+    }
+  | {
+      resultType: 'scalar' | 'string';
+      result: unknown;
+    };
+
+export type PrometheusResponse =
+  | {
+      status: 'error';
+      errorType: string;
+      error: string;
+    }
+  | {
+      status: 'success';
+      data: PrometheusData;
+    };

package/src/shared/cross_chain_test_harness.ts

@@ -1,24 +1,23 @@
-// docs:start:cross_chain_test_harness
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
 import {
-  type AccountWallet,
-  type AztecAddress,
-  type AztecNode,
-  EthAddress,
-  type FieldsOf,
-  Fr,
   type L1TokenManager,
   L1TokenPortalManager,
   type L2AmountClaim,
   type L2AmountClaimWithRecipient,
-  type Logger,
-  type PXE,
-  type SiblingPath,
-  type TxReceipt,
-  type Wallet,
-  deployL1Contract,
-  retryUntil,
-} from '@aztec/aztec.js';
-import type { L1ContractAddresses, ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+} from '@aztec/aztec.js/ethereum';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { SiblingPath } from '@aztec/aztec.js/trees';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { retryUntil } from '@aztec/foundation/retry';
 import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -27,7 +26,6 @@ import { type Hex, getContract } from 'viem';
 
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 
-// docs:start:deployAndInitializeTokenAndBridgeContracts
 /**
  * Deploy L1 token and portal, initialize portal, deploy a non native l2 token contract, its L2 bridge contract and attach is to the portal.
  * @param wallet - the wallet instance
@@ -40,8 +38,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 +65,30 @@ 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 });
 
   // 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 });
 
-  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 });
+  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
 
@@ -109,12 +101,22 @@ 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
@@ -123,54 +125,47 @@ export async function deployAndInitializeTokenAndBridgeContracts(
 export class CrossChainTestHarness {
   static async new(
     aztecNode: AztecNode,
-    pxeService: PXE,
-    publicClient: ViemPublicClient,
-    walletClient: ViemWalletClient,
-    wallet: AccountWallet,
+    l1Client: ExtendedViemWalletClient,
+    wallet: Wallet,
+    ownerAddress: AztecAddress,
     logger: Logger,
     underlyingERC20Address: EthAddress,
   ): Promise<CrossChainTestHarness> {
-    const ethAccount = EthAddress.fromString((await walletClient.getAddresses())[0]);
-    const l1ContractAddresses = (await pxeService.getNodeInfo()).l1ContractAddresses;
+    const ethAccount = EthAddress.fromString((await l1Client.getAddresses())[0]);
+    const l1ContractAddresses = (await aztecNode.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(),
+      ownerAddress,
       underlyingERC20Address,
     );
     logger.info('Deployed and initialized token, portal and its bridge.');
 
     return new CrossChainTestHarness(
       aztecNode,
-      pxeService,
       logger,
       token,
       bridge,
       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,
-    /** Private eXecution Environment (PXE). */
-    public pxeService: PXE,
     /** Logger. */
     public logger: Logger,
 
@@ -186,32 +181,39 @@ 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,
+    /** Wallet to simulate and send txs from. */
+    public readonly wallet: Wallet,
+
+    /** 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();
-    this.ownerAddress = this.ownerWallet.getAddress();
   }
 
   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 +230,18 @@ 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 });
   }
 
   async mintTokensPrivateOnL2(amount: bigint) {
-    await mintTokensToPrivate(this.l2Token, this.ownerWallet, this.ownerAddress, amount);
+    await mintTokensToPrivate(this.l2Token, this.ownerAddress, 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 });
   }
 
   async consumeMessageOnAztecAndMintPrivately(
@@ -247,8 +251,7 @@ export class CrossChainTestHarness {
     const { recipient, claimAmount, claimSecret: secretForL2MessageConsumption, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_private(recipient, claimAmount, secretForL2MessageConsumption, messageLeafIndex)
-      .send()
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async consumeMessageOnAztecAndMintPublicly(
@@ -258,24 +261,25 @@ export class CrossChainTestHarness {
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_public(this.ownerAddress, claimAmount, claimSecret, messageLeafIndex)
-      .send()
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
-  async withdrawPrivateFromAztecToL1(withdrawAmount: bigint, nonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  async withdrawPrivateFromAztecToL1(
+    withdrawAmount: bigint,
+    authwitNonce: Fr = Fr.ZERO,
+    authWitness: AuthWitness,
+  ): Promise<TxReceipt> {
     const withdrawReceipt = await this.l2Bridge.methods
-      .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, nonce)
-      .send()
-      .wait();
+      .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress });
 
     return withdrawReceipt;
   }
 
-  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, nonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<TxReceipt> {
     const withdrawReceipt = await this.l2Bridge.methods
-      .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, nonce)
-      .send()
-      .wait();
+      .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
+      .send({ from: this.ownerAddress });
 
     return withdrawReceipt;
   }
@@ -291,7 +295,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 +303,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,
@@ -310,27 +314,23 @@ export class CrossChainTestHarness {
 
   withdrawFundsFromBridgeOnL1(
     amount: bigint,
-    blockNumber: number | bigint,
+    epochNumber: EpochNumber,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
-    return this.l1TokenPortalManager.withdrawFunds(
-      amount,
-      this.ethAccount,
-      BigInt(blockNumber),
-      messageIndex,
-      siblingPath,
-    );
+    return this.l1TokenPortalManager.withdrawFunds(amount, this.ethAccount, epochNumber, messageIndex, siblingPath);
   }
 
   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 });
   }
 
-  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 });
   }
 
   /**
@@ -348,5 +348,17 @@ 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