@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/shared/gas_portal_test_harness.ts

@@ -1,33 +1,27 @@
-import {
-  type AztecAddress,
-  type AztecNode,
-  EthAddress,
-  Fr,
-  L1FeeJuicePortalManager,
-  type L1TokenManager,
-  type L2AmountClaim,
-  type Logger,
-  type PXE,
-  type Wallet,
-  retryUntil,
-} from '@aztec/aztec.js';
-import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { L1FeeJuicePortalManager, type L1TokenManager, type L2AmountClaim } 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 { Wallet } from '@aztec/aztec.js/wallet';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { retryUntil } from '@aztec/foundation/retry';
 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;
-  pxeService: PXE;
-  publicClient: ViemPublicClient;
-  walletClient: ViemWalletClient;
+  aztecNodeAdmin?: AztecNodeAdmin;
+  l1Client: ExtendedViemWalletClient;
   wallet: Wallet;
   logger: Logger;
   mockL1?: boolean;
@@ -37,10 +31,10 @@ export class FeeJuicePortalTestingHarnessFactory {
   private constructor(private config: FeeJuicePortalTestingHarnessFactoryConfig) {}
 
   private async createReal() {
-    const { aztecNode, pxeService, publicClient, walletClient, wallet, logger } = this.config;
+    const { aztecNode, aztecNodeAdmin, l1Client, wallet, logger } = this.config;
 
-    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;
 
     const feeJuiceAddress = l1ContractAddresses.feeJuiceAddress;
     const feeJuicePortalAddress = l1ContractAddresses.feeJuicePortalAddress;
@@ -49,18 +43,19 @@ export class FeeJuicePortalTestingHarnessFactory {
       throw new Error('Fee Juice portal not deployed on L1');
     }
 
-    const gasL2 = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
+    const gasL2 = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
 
     return new GasBridgingTestHarness(
       aztecNode,
-      pxeService,
+      aztecNodeAdmin,
+      wallet,
       logger,
       gasL2,
       ethAccount,
       feeJuicePortalAddress,
       feeJuiceAddress,
-      publicClient,
-      walletClient,
+      l1ContractAddresses.feeAssetHandlerAddress!,
+      l1Client,
     );
   }
 
@@ -81,8 +76,10 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   constructor(
     /** Aztec node */
     public aztecNode: AztecNode,
-    /** Private eXecution Environment (PXE). */
-    public pxeService: PXE,
+    /** Aztec node admin interface */
+    public aztecNodeAdmin: AztecNodeAdmin | undefined,
+    /** Wallet. */
+    public wallet: Wallet,
     /** Logger. */
     public logger: Logger,
 
@@ -96,44 +93,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 });
   }
 
   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 })).result;
   }
 
   async expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {
@@ -141,8 +139,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 +154,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

package/src/shared/index.ts

@@ -1 +1,2 @@
-export { uniswapL1L2TestSuite, type UniswapSetupContext } from './uniswap_l1_l2.js';
+export { uniswapL1L2TestSuite } from './uniswap_l1_l2.js';
+export { MockStateView, diffInBps } from './mock_state_view.js';

package/src/shared/jest_setup.ts

@@ -1,8 +1,19 @@
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 
-import { beforeEach, expect } from '@jest/globals';
+import { afterAll, afterEach, beforeEach, expect } from '@jest/globals';
+import { readlinkSync } from 'fs';
 import { basename } from 'path';
 
+import { EluMonitor } from '../fixtures/elu_monitor.js';
+
+const eluMonitor = process.env.ELU_MONITOR_FILE
+  ? new EluMonitor(process.env.ELU_MONITOR_FILE, Number(process.env.ELU_MONITOR_INTERVAL_MS) || undefined)
+  : undefined;
+
+if (eluMonitor) {
+  process.on('exit', () => eluMonitor.stop());
+}
+
 beforeEach(() => {
   const { testPath, currentTestName } = expect.getState();
   if (!testPath || !currentTestName) {
@@ -10,4 +21,43 @@ beforeEach(() => {
   }
   const logger = createLogger(`e2e:${basename(testPath).replace('.test.ts', '')}`);
   logger.info(`Running test: ${currentTestName}`);
+  eluMonitor?.startTest(currentTestName);
+});
+
+afterEach(() => {
+  eluMonitor?.stopTest();
+});
+
+// Log leaked handles after all tests complete. This runs after test-level afterAll hooks,
+// so any handles still alive at this point were not properly cleaned up during teardown.
+// This diagnostic helps identify the source of exit hangs without masking them.
+afterAll(() => {
+  const handles = (process as any)._getActiveHandles();
+  if (handles.length > 0) {
+    const details = handles.map((h: any) => {
+      const type = h?.constructor?.name ?? typeof h;
+      const fd = h?.fd ?? h?._handle?.fd ?? '?';
+      const destroyed = h?.destroyed ?? '?';
+      const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : '?';
+      const localAddr = h?.localAddress ?? '';
+      const remoteAddr = h?.remoteAddress ?? '';
+      const localPort = h?.localPort ?? '';
+      const remotePort = h?.remotePort ?? '';
+      const proto = Object.getPrototypeOf(h)?.constructor?.name ?? '?';
+      const keys = Object.keys(h).slice(0, 10).join(',');
+      let fdTarget = '';
+      if (typeof fd === 'number') {
+        try {
+          fdTarget = ` -> ${readlinkSync(`/proc/self/fd/${fd}`)}`;
+        } catch {
+          // ignore
+        }
+      }
+      return `  ${type}(fd=${fd}, destroyed=${destroyed}, hasRef=${hasRef}${fdTarget}) proto=${proto} addr=${localAddr}:${localPort}->${remoteAddr}:${remotePort} keys=[${keys}]`;
+    });
+    process.stderr.write(
+      `\n[jest_setup] WARNING: ${handles.length} handle(s) still active after teardown:\n${details.join('\n')}\n` +
+        `These may prevent Jest from exiting. Investigate and fix the leak.\n\n`,
+    );
+  }
 });

package/src/shared/mock_state_view.ts

@@ -0,0 +1,188 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { EthCheatCodes } from '@aztec/aztec/testing';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+
+import { getContract } from 'viem';
+
+/**
+ * Mock StateView contract for testing the Uniswap price oracle.
+ *
+ * Wraps a compiled Solidity contract that mimics the Uniswap V4 StateView's getSlot0 function.
+ * The mock allows setting return values dynamically for testing different price scenarios.
+ *
+ * Solidity source:
+ * ```solidity
+ * // SPDX-License-Identifier: Apache-2.0
+ * pragma solidity >=0.8.27;
+ *
+ * contract MockStateView {
+ *     uint160 public sqrtPriceX96;
+ *     int24 public tick;
+ *     uint24 public protocolFee;
+ *     uint24 public lpFee;
+ *
+ *     function setReturnValues(
+ *         uint160 _sqrtPriceX96,
+ *         int24 _tick,
+ *         uint24 _protocolFee,
+ *         uint24 _lpFee
+ *     ) external {
+ *         sqrtPriceX96 = _sqrtPriceX96;
+ *         tick = _tick;
+ *         protocolFee = _protocolFee;
+ *         lpFee = _lpFee;
+ *     }
+ *
+ *     function getSlot0(bytes32 poolId) external view returns (uint160, int24, uint24, uint24) {
+ *         return (sqrtPriceX96, tick, protocolFee, lpFee);
+ *     }
+ * }
+ * ```
+ */
+export class MockStateView {
+  private static readonly BYTECODE: `0x${string}` =
+    '0x608060405234801561000f575f5ffd5b5060043610610060575f3560e01c80633eaf5d9f14610064578063704ce43e146100825780638db791d2146100a0578063b0e21e8a146100be578063b52e4bdd146100dc578063c815641c146100f8575b5f5ffd5b61006c61012b565b60405161007991906102ab565b60405180910390f35b61008a61013d565b60405161009791906102e1565b60405180910390f35b6100a8610151565b6040516100b59190610328565b60405180910390f35b6100c6610175565b6040516100d391906102e1565b60405180910390f35b6100f660048036038101906100f191906103c3565b610189565b005b610112600480360381019061010d919061045a565b61022b565b6040516101229493929190610485565b60405180910390f35b5f60149054906101000a900460020b81565b5f601a9054906101000a900462ffffff1681565b5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f60179054906101000a900462ffffff1681565b835f5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550825f60146101000a81548162ffffff021916908360020b62ffffff160217905550815f60176101000a81548162ffffff021916908362ffffff160217905550805f601a6101000a81548162ffffff021916908362ffffff16021790555050505050565b5f5f5f5f5f5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff165f60149054906101000a900460020b5f60179054906101000a900462ffffff165f601a9054906101000a900462ffffff1693509350935093509193509193565b5f8160020b9050919050565b6102a581610290565b82525050565b5f6020820190506102be5f83018461029c565b92915050565b5f62ffffff82169050919050565b6102db816102c4565b82525050565b5f6020820190506102f45f8301846102d2565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b610322816102fa565b82525050565b5f60208201905061033b5f830184610319565b92915050565b5f5ffd5b61034e816102fa565b8114610358575f5ffd5b50565b5f8135905061036981610345565b92915050565b61037881610290565b8114610382575f5ffd5b50565b5f813590506103938161036f565b92915050565b6103a2816102c4565b81146103ac575f5ffd5b50565b5f813590506103bd81610399565b92915050565b5f5f5f5f608085870312156103db576103da610341565b5b5f6103e88782880161035b565b94505060206103f987828801610385565b935050604061040a878288016103af565b925050606061041b878288016103af565b91505092959194509250565b5f819050919050565b61043981610427565b8114610443575f5ffd5b50565b5f8135905061045481610430565b92915050565b5f6020828403121561046f5761046e610341565b5b5f61047c84828501610446565b91505092915050565b5f6080820190506104985f830187610319565b6104a5602083018661029c565b6104b260408301856102d2565b6104bf60608301846102d2565b9594505050505056fea2646970667358221220f8b1bfff284535bc078368ed34bd5e78981644845f3c9c1f5a4b8448c976805464736f6c634300081f0033';
+  private static readonly ABI = [
+    {
+      type: 'function',
+      name: 'setReturnValues',
+      inputs: [
+        { name: '_sqrtPriceX96', type: 'uint160' },
+        { name: '_tick', type: 'int24' },
+        { name: '_protocolFee', type: 'uint24' },
+        { name: '_lpFee', type: 'uint24' },
+      ],
+      outputs: [],
+      stateMutability: 'nonpayable',
+    },
+    {
+      inputs: [
+        {
+          internalType: 'bytes32',
+          name: 'poolId',
+          type: 'bytes32',
+        },
+      ],
+      name: 'getSlot0',
+      outputs: [
+        {
+          internalType: 'uint160',
+          name: '',
+          type: 'uint160',
+        },
+        {
+          internalType: 'int24',
+          name: '',
+          type: 'int24',
+        },
+        {
+          internalType: 'uint24',
+          name: '',
+          type: 'uint24',
+        },
+        {
+          internalType: 'uint24',
+          name: '',
+          type: 'uint24',
+        },
+      ],
+      stateMutability: 'view',
+      type: 'function',
+    },
+  ] as const;
+
+  private constructor(
+    private readonly address: EthAddress,
+    private readonly walletClient: ExtendedViemWalletClient,
+    private readonly log: Logger = createLogger('mock-state-view'),
+  ) {}
+
+  /**
+   * Deploys the mock StateView contract at the specified address using etch.
+   * @param ethCheatCodes - Cheat codes for etching bytecode
+   * @param walletClient - Wallet client for sending transactions
+   * @param address - Address to deploy the mock at (typically the real StateView address)
+   */
+  static async deploy(
+    ethCheatCodes: EthCheatCodes,
+    walletClient: ExtendedViemWalletClient,
+    address: EthAddress,
+  ): Promise<MockStateView> {
+    await ethCheatCodes.etch(address, MockStateView.BYTECODE);
+    return new MockStateView(address, walletClient);
+  }
+
+  /**
+   * Sets the price using the ethPerFeeAssetE12 format (same as rollup contract).
+   * Computes the corresponding sqrtPriceX96 internally.
+   *
+   * Math (from fee_asset_price_oracle.ts):
+   *   ethPerFeeAssetE12 = 1e12 * 2^192 / sqrtPriceX96^2
+   *
+   * Inverted:
+   *   sqrtPriceX96^2 = 1e12 * 2^192 / ethPerFeeAssetE12
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   *
+   * @param ethPerFeeAssetE12 - The price in ETH per fee asset, scaled by 1e12
+   */
+  async setEthPerFeeAsset(ethPerFeeAssetE12: bigint) {
+    const sqrtPriceX96 = this.ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12);
+    return await this.setSqrtPriceX96(sqrtPriceX96);
+  }
+
+  /**
+   * Sets the sqrtPriceX96 value directly (Uniswap's price encoding).
+   * @param sqrtPriceX96 - The sqrtPriceX96 value
+   * @param tick - The tick value (default 10)
+   * @param protocolFee - The protocol fee (default 0)
+   * @param lpFee - The LP fee (default 500)
+   */
+  async setSqrtPriceX96(sqrtPriceX96: bigint, tick: number = 10, protocolFee: number = 0, lpFee: number = 500) {
+    const contract = getContract({
+      address: this.address.toString() as `0x${string}`,
+      abi: MockStateView.ABI,
+      client: this.walletClient,
+    });
+
+    const hash = await contract.write.setReturnValues([sqrtPriceX96, tick, protocolFee, lpFee]);
+    this.log.info(`Set sqrtPriceX96 to ${sqrtPriceX96}`);
+    return await this.walletClient.waitForTransactionReceipt({ hash });
+  }
+
+  /**
+   * Converts ethPerFeeAssetE12 to sqrtPriceX96 (inverse of sqrtPriceX96ToEthPerFeeAssetE12).
+   *
+   * Math:
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   */
+  ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12: bigint): bigint {
+    if (ethPerFeeAssetE12 === 0n) {
+      throw new Error('Cannot convert zero ethPerFeeAssetE12');
+    }
+    const Q192 = 2n ** 192n;
+    const sqrtPriceSquared = (10n ** 12n * Q192) / ethPerFeeAssetE12;
+    return this.bigintSqrt(sqrtPriceSquared);
+  }
+
+  /** Integer square root using Newton's method */
+  bigintSqrt(n: bigint): bigint {
+    if (n < 0n) {
+      throw new Error('Cannot compute sqrt of negative number');
+    }
+    if (n === 0n) {
+      return 0n;
+    }
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+      x = y;
+      y = (x + n / x) / 2n;
+    }
+    return x;
+  }
+}
+
+export function diffInBps(a: bigint, b: bigint): bigint {
+  return ((a - b) * 10000n) / b;
+}

package/src/shared/submit-transactions.ts

@@ -1,33 +1,32 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { Fr, GrumpkinScalar, type Logger, type SentTx, TxStatus, type Wallet } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
+import { Fr, GrumpkinScalar } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { TxHash, type TxReceipt, TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
-import type { PXEService } from '@aztec/pxe/server';
 
-// submits a set of transactions to the provided Private eXecution Environment (PXE)
+import type { TestWallet } from '../test-wallet/test_wallet.js';
+
+// submits a set of transactions to the provided Wallet
 export const submitTxsTo = async (
-  pxe: PXEService,
+  wallet: TestWallet,
+  submitter: AztecAddress,
   numTxs: number,
-  wallet: Wallet,
   logger: Logger,
-): Promise<SentTx[]> => {
-  const txs: SentTx[] = [];
+): Promise<TxHash[]> => {
+  const txHashes: TxHash[] = [];
   await Promise.all(
     times(numTxs, async () => {
-      const accountManager = await getSchnorrAccount(pxe, Fr.random(), GrumpkinScalar.random(), Fr.random());
-      const tx = accountManager.deploy({ deployWallet: wallet });
-      const txHash = await tx.getTxHash();
+      const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
+      const deployMethod = await accountManager.getDeployMethod();
+      const { txHash } = await deployMethod.send({ from: submitter, wait: NO_WAIT });
 
       logger.info(`Tx sent with hash ${txHash}`);
-      const receipt = await tx.getReceipt();
-      expect(receipt).toEqual(
-        expect.objectContaining({
-          status: TxStatus.PENDING,
-          error: '',
-        }),
-      );
+      const receipt: TxReceipt = await wallet.getTxReceipt(txHash);
+      expect(receipt.status).toBe(TxStatus.PENDING);
       logger.info(`Receipt received for ${txHash}`);
-      txs.push(tx);
+      txHashes.push(txHash);
     }),
   );
-  return txs;
+  return txHashes;
 };