@aztec/end-to-end 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/forward-compatibility/wallet_rpc_client.ts

@@ -0,0 +1,14 @@
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+
+/**
+ * Creates a JSON-RPC client that connects to a remote wallet service.
+ * The returned object implements the {@link Wallet} interface, proxying all calls over HTTP to the specified URL.
+ */
+export function createWalletClient(url: string): Wallet {
+  return createSafeJsonRpcClient<Wallet>(url, WalletSchema, {
+    namespaceMethods: 'wallet',
+    fetch: makeFetch([1, 2, 3], false),
+  });
+}

package/src/forward-compatibility/wallet_service.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env -S node --no-warnings
+/**
+ * Standalone entrypoint that spins up a local Aztec network (L1 + node) and exposes a {@link NodeEmbeddedWallet} over
+ * JSON-RPC.
+ *
+ * Intended for forward-compatibility testing: an **old** release image runs this script so that **new** tests can send
+ * new artifacts to old runtime code (loadContractArtifact, ACIR simulator, class-ID computation, entrypoint encoding,
+ * etc.).
+ */
+import { getSchnorrAccountContractAddress } from '@aztec/accounts/schnorr';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { createLocalNetwork } from '@aztec/aztec';
+import { Fr } from '@aztec/aztec.js/fields';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createLogger } from '@aztec/foundation/log';
+import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+
+const logger = createLogger('wallet-service');
+
+const { ETHEREUM_HOSTS = 'http://localhost:8545', NODE_PORT = '8080', WALLET_PORT = '8081' } = process.env;
+
+async function main() {
+  const l1RpcUrls = ETHEREUM_HOSTS.split(',').map(url => url.trim());
+
+  // Some tests (e.g. AMM) need 4 accounts but only 3 are funded via genesis. Generate deterministic keys for a 4th
+  // account so we can compute its address before network startup and include it in genesis funding. We cannot do this
+  // in the test because Wallet interface does not expose account creation functionality (only TestWallet exposes that
+  // but that's not used in forward compatibility testing).
+  const extraAccountSecret = Fr.fromHexString('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+  const extraAccountSalt = Fr.ZERO;
+  const extraAccountSigningKey = GrumpkinScalar.random();
+  const extraAccountAddress = await getSchnorrAccountContractAddress(
+    extraAccountSecret,
+    extraAccountSalt,
+    extraAccountSigningKey,
+  );
+
+  logger.info('Starting wallet service...', { l1RpcUrls });
+
+  // createLocalNetwork deploys L1 contracts, starts the node, and optionally deploys funded test accounts (when
+  // TEST_ACCOUNTS=true via env). We are not proving anything just like is done when local network is started by
+  // the `aztecStart` function. The extra account address is passed via prefundAddresses so it gets fee juice at genesis.
+  const { node, stop: stopNetwork } = await createLocalNetwork(
+    { l1RpcUrls, realProofs: false, prefundAddresses: [extraAccountAddress.toString()] },
+    logger.info,
+  );
+
+  // Create an ephemeral embedded wallet backed by the local node.
+  const wallet = await EmbeddedWallet.create(node, { ephemeral: true });
+
+  // Re-register the initial test accounts so they are available via wallet.getAccounts(). createLocalNetwork deploys
+  // them onchain but uses a temporary wallet that is then stopped.
+  //
+  // We use the non-lazy import path (@aztec/accounts/testing, not /lazy) to avoid the dynamic JSON import that is
+  // incompatible with Node.js import attribute enforcement.
+  const testAccountsData = await getInitialTestAccountsData();
+  const accounts = await Promise.all(
+    testAccountsData.map(({ secret, salt, signingKey }) => wallet.createSchnorrAccount(secret, salt, signingKey)),
+  );
+
+  // Register and deploy the 4th account.
+  const extraAccount = await wallet.createSchnorrAccount(extraAccountSecret, extraAccountSalt, extraAccountSigningKey);
+  const deployMethod = await extraAccount.getDeployMethod();
+  await deployMethod.send({ from: accounts[0].address });
+
+  logger.info('Embedded wallet created', {
+    accounts: [...accounts, extraAccount].map(a => a.address.toString()),
+  });
+
+  // Contract artifacts are large, so allow generous body sizes for RPC requests.
+  const rpcOptions = { maxBodySizeBytes: '50mb' };
+
+  // Serve node RPC
+  const nodeRpcServer = createNamespacedSafeJsonRpcServer({ node: [node, AztecNodeApiSchema] }, rpcOptions);
+  const nodeHttpServer = await startHttpRpcServer(nodeRpcServer, { port: NODE_PORT });
+  logger.info(`Node JSON-RPC server listening on port ${nodeHttpServer.port}`);
+
+  // Serve wallet RPC
+  const walletRpcServer = createNamespacedSafeJsonRpcServer({ wallet: [wallet, WalletSchema] }, rpcOptions);
+  const walletHttpServer = await startHttpRpcServer(walletRpcServer, { port: WALLET_PORT });
+  logger.info(`Wallet JSON-RPC server listening on port ${walletHttpServer.port}`);
+
+  const shutdown = async () => {
+    logger.info('Shutting down...');
+    nodeHttpServer.close();
+    walletHttpServer.close();
+    await wallet.stop();
+    await stopNetwork();
+    process.exit(0);
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGINT', shutdown);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGTERM', shutdown);
+}
+
+main().catch(err => {
+  logger.error('Wallet service failed to start', err);
+  process.exit(1);
+});

package/src/guides/up_quick_start.sh

@@ -18,10 +18,10 @@ aztec-wallet() {
 
 aztec-wallet import-test-accounts
 
-# docs:start:declare-accounts
 aztec-wallet create-account -a alice -f test0
 aztec-wallet create-account -a bob -f test0
-# docs:end:declare-accounts
+
+aztec-wallet bridge-fee-juice 1000000000000000000000 accounts:alice --mint --no-wait
 
 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)
@@ -38,9 +38,7 @@ 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 send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -aw authwits:last -f test0
+aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 0 -f alice --payment method=fee_juice,claim
 
 # Test end result
 ALICE_BALANCE=$(aztec-wallet simulate balance_of_private -ca last --args accounts:alice -f alice)

package/src/install_legacy_contracts.cjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// Installs pinned legacy @aztec/* contract-artifact packages into .legacy-contracts/<version>/.
+//
+// Called from two places:
+//   - bootstrap.sh ci-compat-e2e: pre-populates the cache on the host before hermetic test
+//     containers launch. The containers run with --net=none (see ci3/docker_isolate), so on-demand
+//     installs from inside them fail with EAI_AGAIN.
+//   - legacy-jest-resolver.cjs: on-demand install for local dev, where jest runs with network.
+//
+// Idempotent: no-op when all packages are already present.
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const path = require('path');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+
+const REDIRECTED = ['@aztec/noir-contracts.js', '@aztec/noir-test-contracts.js', '@aztec/accounts'];
+
+const e2eRoot = path.resolve(__dirname, '..');
+
+function cacheRoot(version) {
+  return path.join(e2eRoot, '.legacy-contracts', version);
+}
+
+function pkgJsonPath(version, pkg) {
+  return path.join(cacheRoot(version), 'node_modules', pkg, 'package.json');
+}
+
+function installLegacyContracts(version) {
+  if (!version) {
+    throw new Error('installLegacyContracts: version is required');
+  }
+  if (REDIRECTED.every(pkg => fs.existsSync(pkgJsonPath(version, pkg)))) {
+    return;
+  }
+
+  const cacheDir = cacheRoot(version);
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  // Seed a standalone package.json so `npm install --prefix` treats cacheRoot as its own project. Without this, npm
+  // walks up and finds the yarn-project workspace root, which breaks on `workspace:` protocol deps and risks
+  // clobbering the monorepo's node_modules.
+  const seed = path.join(cacheDir, 'package.json');
+  if (!fs.existsSync(seed)) {
+    fs.writeFileSync(seed, JSON.stringify({ name: 'legacy-contracts-cache', private: true }));
+  }
+
+  const specs = REDIRECTED.map(pkg => `${pkg}@${version}`);
+  process.stderr.write(`[legacy-contracts] installing ${specs.join(' ')} into ${cacheDir}\n`);
+  // --prefix: install into cacheRoot instead of cwd, so the cache is isolated from the monorepo.
+  // --no-save: don't write the installed packages back to the seeded package.json.
+  // --ignore-scripts: skip lifecycle scripts (preinstall/postinstall) of the legacy packages and their transitive
+  //   deps; we only want the files on disk, not to run any build steps.
+  // --legacy-peer-deps: tolerate peer-dependency mismatches between the pinned legacy @aztec/* graph and whatever
+  //   current versions npm would otherwise try to reconcile.
+  execFileSync(
+    'npm',
+    ['install', '--prefix', cacheDir, '--no-save', '--ignore-scripts', '--legacy-peer-deps', ...specs],
+    { stdio: 'inherit' },
+  );
+
+  // Verify versions on disk match the requested version.
+  for (const pkg of REDIRECTED) {
+    const onDisk = JSON.parse(fs.readFileSync(pkgJsonPath(version, pkg), 'utf8')).version;
+    if (onDisk !== version) {
+      throw new Error(`[legacy-contracts] ${pkg} on disk is ${onDisk}, expected ${version}`);
+    }
+  }
+}
+
+module.exports = { installLegacyContracts, REDIRECTED, cacheRoot };
+
+if (require.main === module) {
+  installLegacyContracts(process.argv[2]);
+}

package/src/legacy-jest-resolver.cjs

@@ -0,0 +1,112 @@
+// Custom Jest resolver. When CONTRACT_ARTIFACTS_VERSION is set, redirects *only* JSON artifact files under
+// @aztec/noir-contracts.js/artifacts/, @aztec/noir-test-contracts.js/artifacts/, and @aztec/accounts/artifacts/ to a local cache of the pinned
+// legacy versions. TypeScript wrapper classes (e.g. Token.ts) continue to load from the current workspace and use the
+// current @aztec/aztec.js — only the artifact JSON (the deployed-contract ABI / bytecode / notes surface) is swapped.
+//
+// Why JSON-only: the JSON artifact is the actual interchange surface a "deployed contract" exposes. The TS wrapper is
+// generated client-side ergonomics that's tightly coupled to the current @aztec/aztec.js API. Redirecting the wrapper
+// would couple this test to a moving aztec.js surface and break at import time on unrelated breaking changes; we want
+// to fail only on actual artifact-compat regressions.
+//
+// Cache population lives in install_legacy_contracts.cjs — invoked lazily here for local dev, and eagerly
+// by bootstrap.sh ci-compat-e2e before hermetic test containers (which run with --net=none) launch.
+//
+// Missing artifacts: legacy version directories are immutable, so an artifact missing from the cache means the
+// contract was added after the pinned release — there's nothing to compat-test. Rather than failing or silently
+// falling back to the workspace artifact (which would turn the compat run into a regular e2e run that always
+// passes), we log the miss and exit the process cleanly with code 0. The test never runs, but the per-test CI
+// log captures the explanatory line so the reason is auditable. This keeps the change scoped to this resolver,
+// avoiding a new exit-code contract in the shared ci3 test runner.
+//
+// Activated by env var; passthrough otherwise.
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const path = require('path');
+const fs = require('fs');
+const { installLegacyContracts, REDIRECTED, cacheRoot } = require('./install_legacy_contracts.cjs');
+
+const version = process.env.CONTRACT_ARTIFACTS_VERSION;
+const cacheDir = version ? cacheRoot(version) : null;
+
+function pkgJsonPath(name) {
+  return path.join(cacheDir, 'node_modules', name, 'package.json');
+}
+
+// Kept in a separate module (not inlined) because bootstrap.sh ci-compat-e2e also calls it directly
+// via `node .../install_legacy_contracts.cjs <version>` to pre-populate the cache on the host before
+// hermetic --net=none test containers launch. Inlining here would force us to duplicate the logic
+// in bash or re-run jest just to trigger the install.
+if (version) {
+  installLegacyContracts(version);
+}
+
+let bannerPrinted = false;
+const seen = new Set();
+
+function printBannerOnce() {
+  if (bannerPrinted || !version) {
+    return;
+  }
+  bannerPrinted = true;
+  const lines = ['='.repeat(60), `[legacy-contracts][jest] CONTRACT_ARTIFACTS_VERSION=${version}`];
+  for (const p of REDIRECTED) {
+    const v = JSON.parse(fs.readFileSync(pkgJsonPath(p), 'utf8')).version;
+    if (v !== version) {
+      throw new Error(`[legacy-contracts] ${p} on disk is ${v}, expected ${version}`);
+    }
+    lines.push(`[legacy-contracts][jest] redirecting ${p}/artifacts/*.json -> .legacy-contracts/${version}/...`);
+  }
+  lines.push('='.repeat(60));
+  process.stderr.write(lines.join('\n') + '\n');
+}
+
+// Match a resolved absolute path against the workspace artifacts dirs and return the legacy cache equivalent, or null
+// if it's not an artifact path we should redirect.
+function legacyArtifactPath(resolved) {
+  if (!resolved.endsWith('.json')) {
+    return null;
+  }
+  for (const pkg of REDIRECTED) {
+    // pkg = '@aztec/noir-contracts.js' -> match '/noir-contracts.js/artifacts/'
+    const dirName = pkg.split('/')[1];
+    const marker = `/${dirName}/artifacts/`;
+    const idx = resolved.indexOf(marker);
+    if (idx === -1) {
+      continue;
+    }
+    const basename = resolved.slice(idx + marker.length);
+    return path.join(cacheDir, 'node_modules', pkg, 'artifacts', basename);
+  }
+  return null;
+}
+
+module.exports = function legacyResolver(request, options) {
+  // Always run the default resolver first. We only inspect (and possibly rewrite) the *result*; this catches both
+  // bare-specifier imports of `@aztec/noir-contracts.js/artifacts/foo.json` and the relative `../artifacts/foo.json`
+  // imports inside the workspace TS wrapper classes — both resolve to the same workspace artifact path that we then
+  // redirect.
+  const resolved = options.defaultResolver(request, options);
+  if (!version) {
+    return resolved;
+  }
+  printBannerOnce();
+  const legacy = legacyArtifactPath(resolved);
+  if (!legacy) {
+    return resolved;
+  }
+  if (!fs.existsSync(legacy)) {
+    // Contract was added after this historical release, there is nothing to compat-test for it. Exit the process
+    // cleanly with code 0 so the test runner reports the run as passed.
+    fs.writeSync(
+      2,
+      `[legacy-contracts][jest] artifact ${path.basename(legacy)} not in legacy cache @${version}; ` +
+        `assumed added after this release. No compat coverage applicable for this version, treating as passed.\n`,
+    );
+    process.exit(0);
+  }
+  if (!seen.has(resolved)) {
+    seen.add(resolved);
+    process.stderr.write(`[legacy-contracts][jest] redirected ${path.basename(legacy)} -> ${legacy}\n`);
+  }
+  return legacy;
+};

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

@@ -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

@@ -13,12 +13,11 @@ 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 { OutboxContract } from '@aztec/ethereum/contracts';
 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 { BlockNumber } from '@aztec/foundation/branded-types';
-import { retryUntil } from '@aztec/foundation/retry';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -26,6 +25,7 @@ import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import { type Hex, getContract } from 'viem';
 
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
+import { waitForL1ToL2MessageSeen } from './wait_for_l1_to_l2_message.js';
 
 /**
  * Deploy L1 token and portal, initialize portal, deploy a non native l2 token contract, its L2 bridge contract and attach is to the portal.
@@ -74,26 +74,26 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   });
 
   // deploy l2 token
-  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: owner })
-    .deployed();
+  const { contract: 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({ from: owner })
-    .deployed();
+  const { contract: bridge } = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress).send({
+    from: owner,
+  });
 
-  if ((await token.methods.get_admin().simulate({ from: owner })) !== owner.toBigInt()) {
+  if ((await token.methods.get_admin().simulate({ from: owner })).result !== owner.toBigInt()) {
     throw new Error(`Token admin is not ${owner}`);
   }
 
-  if (!(await bridge.methods.get_config().simulate({ from: owner })).token.equals(token.address)) {
+  if (!(await bridge.methods.get_config().simulate({ from: owner })).result.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({ from: owner }).wait();
-  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
+  await token.methods.set_minter(bridge.address, true).send({ from: owner });
+  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })).result === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
 
@@ -167,6 +167,7 @@ export class CrossChainTestHarness {
 
   private readonly l1TokenManager: L1TokenManager;
   private readonly l1TokenPortalManager: L1TokenPortalManager;
+  public readonly outboxContract: OutboxContract;
 
   constructor(
     /** Aztec node instance. */
@@ -207,6 +208,7 @@ export class CrossChainTestHarness {
       this.logger,
     );
     this.l1TokenManager = this.l1TokenPortalManager.getTokenManager();
+    this.outboxContract = new OutboxContract(this.l1Client, this.l1ContractAddresses.outboxAddress);
   }
 
   async mintTokensOnL1(amount: bigint) {
@@ -235,7 +237,7 @@ 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({ from: this.ownerAddress }).wait();
+    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress });
   }
 
   async mintTokensPrivateOnL2(amount: bigint) {
@@ -246,8 +248,7 @@ export class CrossChainTestHarness {
     // 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({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async consumeMessageOnAztecAndMintPrivately(
@@ -257,8 +258,7 @@ export class CrossChainTestHarness {
     const { recipient, claimAmount, claimSecret: secretForL2MessageConsumption, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_private(recipient, claimAmount, secretForL2MessageConsumption, messageLeafIndex)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async consumeMessageOnAztecAndMintPublicly(
@@ -268,34 +268,31 @@ export class CrossChainTestHarness {
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_public(this.ownerAddress, claimAmount, claimSecret, messageLeafIndex)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   async withdrawPrivateFromAztecToL1(
     withdrawAmount: bigint,
     authwitNonce: Fr = Fr.ZERO,
     authWitness: AuthWitness,
-  ): Promise<FieldsOf<TxReceipt>> {
-    const withdrawReceipt = await this.l2Bridge.methods
+  ): Promise<TxReceipt> {
+    const { receipt: withdrawReceipt } = await this.l2Bridge.methods
       .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ authWitnesses: [authWitness], from: this.ownerAddress })
-      .wait();
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress });
 
     return withdrawReceipt;
   }
 
-  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
-    const withdrawReceipt = await this.l2Bridge.methods
+  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<TxReceipt> {
+    const { receipt: withdrawReceipt } = await this.l2Bridge.methods
       .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
 
     return withdrawReceipt;
   }
 
   async getL2PrivateBalanceOf(owner: AztecAddress) {
-    return await this.l2Token.methods.balance_of_private(owner).simulate({ from: owner });
+    return (await this.l2Token.methods.balance_of_private(owner).simulate({ from: owner })).result;
   }
 
   async expectPrivateBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {
@@ -305,7 +302,7 @@ export class CrossChainTestHarness {
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {
-    return await this.l2Token.methods.balance_of_public(owner).simulate({ from: this.ownerAddress });
+    return (await this.l2Token.methods.balance_of_public(owner).simulate({ from: this.ownerAddress })).result;
   }
 
   async expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {
@@ -324,14 +321,16 @@ export class CrossChainTestHarness {
 
   withdrawFundsFromBridgeOnL1(
     amount: bigint,
-    blockNumber: BlockNumber,
+    epochNumber: EpochNumber,
+    numCheckpointsInEpoch: number,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
     return this.l1TokenPortalManager.withdrawFunds(
       amount,
       this.ethAccount,
-      BigInt(blockNumber),
+      epochNumber,
+      numCheckpointsInEpoch,
       messageIndex,
       siblingPath,
     );
@@ -339,18 +338,14 @@ 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({ from: this.ownerAddress })
-      .wait();
+    await this.l2Token.methods.transfer_to_private(this.ownerAddress, shieldAmount).send({ from: this.ownerAddress });
   }
 
   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({ from: this.ownerAddress })
-      .wait();
+      .send({ from: this.ownerAddress });
   }
 
   /**
@@ -362,8 +357,7 @@ export class CrossChainTestHarness {
    */
   async makeMessageConsumable(msgHash: Fr | Hex) {
     const frMsgHash = typeof msgHash === 'string' ? Fr.fromHexString(msgHash) : msgHash;
-    // We poll isL1ToL2MessageSynced endpoint until the message is available
-    await retryUntil(async () => await this.aztecNode.isL1ToL2MessageSynced(frMsgHash), 'message sync', 10);
+    await waitForL1ToL2MessageSeen(this.aztecNode, frMsgHash, { timeoutSeconds: 10 });
 
     await this.mintTokensPublicOnL2(0n);
     await this.mintTokensPublicOnL2(0n);