@aztec/end-to-end 0.0.1-commit.3d8f95d → 0.0.1-commit.3e3d0c9cd

package/src/fixtures/setup.ts

@@ -1,6 +1,5 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
 import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
-import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import {
@@ -16,7 +15,6 @@ import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
-import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
 import { SPONSORED_FPC_SALT } from '@aztec/constants';
 import { isAnvilTestChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
@@ -30,13 +28,9 @@ import {
   type ZKPassportArgs,
   deployAztecL1Contracts,
 } from '@aztec/ethereum/deploy-aztec-l1-contracts';
-import {
-  DelayedTxUtils,
-  EthCheatCodes,
-  EthCheatCodesWithState,
-  createDelayedL1TxUtilsFromViemWallet,
-  startAnvil,
-} from '@aztec/ethereum/test';
+import type { Delayer } from '@aztec/ethereum/l1-tx-utils';
+import { EthCheatCodes, EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
+import type { Anvil } from '@aztec/ethereum/test';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
@@ -45,20 +39,17 @@ import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { P2PClientDeps } from '@aztec/p2p';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { type ProverNode, type ProverNodeConfig, type ProverNodeDeps, createProverNode } from '@aztec/prover-node';
+import type { ProverNodeConfig } from '@aztec/prover-node';
 import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { TestSequencerClient } from '@aztec/sequencer-client/test';
 import { type ContractInstanceWithAddress, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import type { P2PClientType } from '@aztec/stdlib/p2p';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
@@ -67,10 +58,9 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import type { Anvil } from '@viem/anvil';
 import fs from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
@@ -84,6 +74,7 @@ import {
 } from 'viem/accounts';
 import { type Chain, foundry } from 'viem/chains';
 
+import { TestWallet } from '../test-wallet/test_wallet.js';
 import { MNEMONIC, TEST_MAX_PENDING_TX_POOL_COUNT, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
@@ -194,6 +185,11 @@ export type SetupOptions = {
   anvilAccounts?: number;
   /** Port to start anvil (defaults to 8545) */
   anvilPort?: number;
+  /**
+   * Number of slots per epoch for Anvil's finality simulation.
+   * Anvil reports `finalized = latest - slotsInAnEpoch * 2`.
+   */
+  anvilSlotsInAnEpoch?: number;
   /** Key to use for publishing L1 contracts */
   l1PublisherKey?: SecretValue<`0x${string}`>;
   /** ZkPassport configuration (domain, scope, mock verifier) */
@@ -218,8 +214,8 @@ export type EndToEndContext = {
   aztecNodeService: AztecNodeService;
   /** Client to the Aztec Node admin interface. */
   aztecNodeAdmin: AztecNodeAdmin;
-  /** The prover node service (only set if startProverNode is true) */
-  proverNode: ProverNode | undefined;
+  /** The aztec node running the prover node subsystem (only set if startProverNode is true). */
+  proverNode: AztecNodeService | undefined;
   /** A client to the sequencer service. */
   sequencer: SequencerClient | undefined;
   /** Return values from deployAztecL1Contracts function. */
@@ -248,6 +244,10 @@ export type EndToEndContext = {
   telemetryClient: TelemetryClient;
   /** Mock gossip sub network used for gossipping messages (only if mockGossipSubNetwork was set to true in opts) */
   mockGossipSubNetwork: MockGossipSubNetwork | undefined;
+  /** Delayer for sequencer L1 txs (only when enableDelayer is true). */
+  sequencerDelayer: Delayer | undefined;
+  /** Delayer for prover node L1 txs (only when enableDelayer and startProverNode are true). */
+  proverDelayer: Delayer | undefined;
   /** Prefilled public data used for setting up nodes. */
   prefilledPublicData: PublicDataTreeLeaf[] | undefined;
   /** ACVM config (only set if running locally). */
@@ -287,8 +287,12 @@ export async function setup(
     config.realProofs = !!opts.realProofs;
     // Only enforce the time table if requested
     config.enforceTimeTable = !!opts.enforceTimeTable;
+    // Enable the tx delayer for tests (default config has it disabled, so we force-enable it here)
+    config.enableDelayer = true;
     config.listenAddress = '127.0.0.1';
 
+    config.minTxPoolAgeMs = opts.minTxPoolAgeMs ?? 0;
+
     const logger = getLogger();
 
     // Create a temp directory for any services that need it and cleanup later
@@ -306,6 +310,7 @@ export async function setup(
         l1BlockTime: opts.ethereumSlotDuration,
         accounts: opts.anvilAccounts,
         port: opts.anvilPort ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : undefined),
+        slotsInAnEpoch: opts.anvilSlotsInAnEpoch,
       });
       anvil = res.anvil;
       config.l1RpcUrls = [res.rpcUrl];
@@ -336,11 +341,11 @@ export async function setup(
       publisherPrivKeyHex = opts.l1PublisherKey.getValue();
       publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (
-      config.publisherPrivateKeys &&
-      config.publisherPrivateKeys.length > 0 &&
-      config.publisherPrivateKeys[0].getValue() != NULL_KEY
+      config.sequencerPublisherPrivateKeys &&
+      config.sequencerPublisherPrivateKeys.length > 0 &&
+      config.sequencerPublisherPrivateKeys[0].getValue() != NULL_KEY
     ) {
-      publisherPrivKeyHex = config.publisherPrivateKeys[0].getValue();
+      publisherPrivKeyHex = config.sequencerPublisherPrivateKeys[0].getValue();
       publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (!MNEMONIC) {
       throw new Error(`Mnemonic not provided and no publisher private key`);
@@ -349,7 +354,7 @@ export async function setup(
       const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
       const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
       publisherPrivKeyHex = `0x${publisherPrivKey!.toString('hex')}` as const;
-      config.publisherPrivateKeys = [new SecretValue(publisherPrivKeyHex)];
+      config.sequencerPublisherPrivateKeys = [new SecretValue(publisherPrivKeyHex)];
     }
 
     if (config.coinbase === undefined) {
@@ -412,9 +417,14 @@ export async function setup(
     if (enableAutomine) {
       await ethCheatCodes.setAutomine(false);
       await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
-      dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
     }
 
+    // Always sync dateProvider to L1 time after deploying L1 contracts, regardless of mining mode.
+    // In compose mode, L1 time may have drifted ahead of system time due to the local-network watcher
+    // warping time forward on each filled slot. Without this sync, the sequencer computes the wrong
+    // slot from its dateProvider and cannot propose blocks.
+    dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
+
     if (opts.l2StartTime) {
       await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
     }
@@ -451,7 +461,7 @@ export async function setup(
     }
 
     let mockGossipSubNetwork: MockGossipSubNetwork | undefined;
-    let p2pClientDeps: P2PClientDeps<P2PClientType.Full> | undefined = undefined;
+    let p2pClientDeps: P2PClientDeps | undefined = undefined;
 
     if (opts.mockGossipSubNetwork) {
       mockGossipSubNetwork = new MockGossipSubNetwork();
@@ -491,36 +501,33 @@ export async function setup(
     );
     const sequencerClient = aztecNodeService.getSequencer();
 
-    if (sequencerClient) {
-      const publisher = (sequencerClient as TestSequencerClient).sequencer.publisher;
-      publisher.l1TxUtils = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, config.ethereumSlotDuration, l1Client);
-    }
-
-    let proverNode: ProverNode | undefined = undefined;
+    let proverNode: AztecNodeService | undefined = undefined;
     if (opts.startProverNode) {
       logger.verbose('Creating and syncing a simulated prover node...');
       const proverNodePrivateKey = getPrivateKeyFromIndex(2);
       const proverNodePrivateKeyHex: Hex = `0x${proverNodePrivateKey!.toString('hex')}`;
       const proverNodeDataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
-      const proverNodeConfig = {
-        ...config.proverNodeConfig,
-        dataDirectory: proverNodeDataDirectory,
-        p2pEnabled: !!mockGossipSubNetwork,
+
+      const p2pClientDeps: Partial<P2PClientDeps> = {
+        p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork!),
+        rpcTxProviders: [aztecNodeService],
       };
-      proverNode = await createAndSyncProverNode(
+
+      ({ proverNode } = await createAndSyncProverNode(
         proverNodePrivateKeyHex,
         config,
-        proverNodeConfig,
-        aztecNodeService,
-        prefilledPublicData,
         {
-          p2pClientDeps: mockGossipSubNetwork
-            ? { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) }
-            : undefined,
+          ...config.proverNodeConfig,
+          dataDirectory: proverNodeDataDirectory,
         },
-      );
+        { dateProvider, p2pClientDeps, telemetry: telemetryClient },
+        { prefilledPublicData },
+      ));
     }
 
+    const sequencerDelayer = sequencerClient?.getDelayer();
+    const proverDelayer = proverNode?.getProverNode()?.getDelayer();
+
     logger.verbose('Creating a pxe...');
     const pxeConfig = { ...getPXEConfig(), ...pxeOpts };
     pxeConfig.dataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
@@ -621,6 +628,8 @@ export async function setup(
       mockGossipSubNetwork,
       prefilledPublicData,
       proverNode,
+      sequencerDelayer,
+      proverDelayer,
       sequencer: sequencerClient,
       teardown,
       telemetryClient,
@@ -704,93 +713,55 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: BlockNum
   );
 }
 
+/**
+ * Creates an AztecNodeService with the prover node enabled as a subsystem.
+ * Returns both the aztec node service (for lifecycle management) and the prover node (for test internals access).
+ */
 export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
-  aztecNodeConfig: AztecNodeConfig,
-  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'> & { dontStart?: boolean },
-  aztecNode: AztecNode | undefined,
-  prefilledPublicData: PublicDataTreeLeaf[] = [],
-  proverNodeDeps: ProverNodeDeps = {},
-) {
+  baseConfig: AztecNodeConfig,
+  configOverrides: Pick<AztecNodeConfig, 'dataDirectory'>,
+  deps: {
+    telemetry?: TelemetryClient;
+    dateProvider: DateProvider;
+    p2pClientDeps?: P2PClientDeps;
+  },
+  options: { prefilledPublicData: PublicDataTreeLeaf[]; dontStart?: boolean },
+): Promise<{ proverNode: AztecNodeService }> {
   return withLoggerBindings({ actor: 'prover-0' }, async () => {
-    const aztecNodeTxProvider = aztecNode && {
-      getTxByHash: aztecNode.getTxByHash.bind(aztecNode),
-      getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
-      stop: () => Promise.resolve(),
-    };
-
-    const blobClient = await createBlobClientWithFileStores(aztecNodeConfig, createLogger('blob-client:prover-node'));
-
-    const archiverConfig = { ...aztecNodeConfig, dataDirectory: proverNodeConfig.dataDirectory };
-    const archiver = await createArchiver(
-      archiverConfig,
-      { blobClient, dateProvider: proverNodeDeps.dateProvider },
-      { blockUntilSync: true },
-    );
-
-    const proverConfig: ProverNodeConfig = {
-      ...aztecNodeConfig,
-      txCollectionNodeRpcUrls: [],
-      realProofs: false,
-      proverAgentCount: 2,
-      publisherPrivateKeys: [new SecretValue(proverNodePrivateKey)],
-      proverNodeMaxPendingJobs: 10,
-      proverNodeMaxParallelBlocksPerEpoch: 32,
-      proverNodePollingIntervalMs: 200,
-      txGatheringIntervalMs: 1000,
-      txGatheringBatchSize: 10,
-      txGatheringMaxParallelRequestsPerNode: 10,
-      txGatheringTimeoutMs: 24_000,
-      proverNodeFailedEpochStore: undefined,
-      proverId: EthAddress.fromNumber(1),
-      proverNodeEpochProvingDelayMs: undefined,
-      ...proverNodeConfig,
-    };
-
-    const l1TxUtils = createDelayedL1TxUtils(
-      aztecNodeConfig,
-      proverNodePrivateKey,
-      'prover-node',
-      proverNodeDeps.dateProvider,
+    const proverNode = await AztecNodeService.createAndSync(
+      {
+        ...baseConfig,
+        ...configOverrides,
+        p2pPort: 0,
+        enableProverNode: true,
+        disableValidator: true,
+        proverPublisherPrivateKeys: [new SecretValue(proverNodePrivateKey)],
+      },
+      deps,
+      { ...options, dontStartProverNode: options.dontStart },
     );
 
-    const proverNode = await createProverNode(
-      proverConfig,
-      { ...proverNodeDeps, aztecNodeTxProvider, archiver: archiver as Archiver, l1TxUtils },
-      { prefilledPublicData },
-    );
-    getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
-    if (!proverNodeConfig.dontStart) {
-      await proverNode.start();
+    if (!proverNode.getProverNode()) {
+      throw new Error('Prover node subsystem was not created despite enableProverNode being set');
     }
-    return proverNode;
-  });
-}
 
-function createDelayedL1TxUtils(
-  aztecNodeConfig: AztecNodeConfig,
-  privateKey: `0x${string}`,
-  logName: string,
-  dateProvider?: DateProvider,
-) {
-  const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, privateKey, foundry);
-
-  const log = createLogger(logName);
-  const l1TxUtils = createDelayedL1TxUtilsFromViemWallet(l1Client, log, dateProvider, aztecNodeConfig);
-  l1TxUtils.enableDelayer(aztecNodeConfig.ethereumSlotDuration);
-  return l1TxUtils;
+    getLogger().info(`Created and synced prover node`);
+    return { proverNode };
+  });
 }
 
 export type BalancesFn = ReturnType<typeof getBalancesFn>;
 export function getBalancesFn(
   symbol: string,
   method: ContractMethod,
-  from: AztecAddress,
   logger: any,
 ): (...addresses: (AztecAddress | { address: AztecAddress })[]) => Promise<bigint[]> {
   const balances = async (...addressLikes: (AztecAddress | { address: AztecAddress })[]) => {
     const addresses = addressLikes.map(addressLike => ('address' in addressLike ? addressLike.address : addressLike));
-    const b = await Promise.all(addresses.map(address => method(address).simulate({ from })));
+    const b = await Promise.all(
+      addresses.map(async address => (await method(address).simulate({ from: address })).result),
+    );
     const debugString = `${symbol} balances: ${addresses.map((address, i) => `${address}: ${b[i]}`).join(', ')}`;
     logger.verbose(debugString);
     return b;
@@ -908,7 +879,7 @@ export async function publicDeployAccounts(
 
   const batch = new BatchCall(wallet, calls);
 
-  const txReceipt = await batch.send({ from: accountsToDeploy[0] });
+  const { receipt: txReceipt } = await batch.send({ from: accountsToDeploy[0] });
   if (waitUntilProven) {
     if (!node) {
       throw new Error('Need to provide an AztecNode to wait for proven.');

package/src/fixtures/setup_p2p_test.ts

@@ -7,7 +7,6 @@ import { SecretValue } from '@aztec/foundation/config';
 import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 
 import getPort from 'get-port';
@@ -131,7 +130,7 @@ export async function createNonValidatorNode(
       ...p2pConfig,
       disableValidator: true,
       validatorPrivateKeys: undefined,
-      publisherPrivateKeys: [],
+      sequencerPublisherPrivateKeys: [],
     };
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
     return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { prefilledPublicData });
@@ -143,31 +142,24 @@ export async function createProverNode(
   tcpPort: number,
   bootstrapNode: string | undefined,
   addressIndex: number,
-  proverNodeDeps: ProverNodeDeps & Required<Pick<ProverNodeDeps, 'dateProvider'>>,
+  deps: { dateProvider: DateProvider },
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
-) {
+): Promise<{ proverNode: AztecNodeService }> {
   const actorIndex = proverCounter++;
   return await withLoggerBindings({ actor: `prover-${actorIndex}` }, async () => {
     const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
 
-    const proverConfig: Partial<ProverNodeConfig> = await createP2PConfig(
-      config,
-      bootstrapNode,
-      tcpPort,
-      dataDirectory,
-    );
+    const p2pConfig = await createP2PConfig(config, bootstrapNode, tcpPort, dataDirectory);
 
-    const aztecNodeRpcTxProvider = undefined;
     return await createAndSyncProverNode(
       bufferToHex(proverNodePrivateKey),
-      config,
-      { ...proverConfig, dataDirectory },
-      aztecNodeRpcTxProvider,
-      prefilledPublicData,
-      { ...proverNodeDeps, telemetry },
+      { ...config, ...p2pConfig },
+      { dataDirectory },
+      { ...deps, telemetry },
+      { prefilledPublicData: prefilledPublicData ?? [] },
     );
   });
 }
@@ -215,7 +207,7 @@ export async function createValidatorConfig(
     ...config,
     ...p2pConfig,
     validatorPrivateKeys: new SecretValue(attesterPrivateKeys),
-    publisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
+    sequencerPublisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
   };
 
   return nodeConfig;

package/src/fixtures/token_utils.ts

@@ -6,7 +6,9 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+  const {
+    receipt: { contract, instance },
+  } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
     from: admin,
     wait: { returnReceipt: true },
   });
@@ -25,8 +27,9 @@ export async function mintTokensToPrivate(
   minter: AztecAddress,
   recipient: AztecAddress,
   amount: bigint,
+  additionalScopes?: AztecAddress[],
 ) {
-  await token.methods.mint_to_private(recipient, amount).send({ from: minter });
+  await token.methods.mint_to_private(recipient, amount).send({ from: minter, additionalScopes });
 }
 
 export async function expectTokenBalance(
@@ -38,7 +41,7 @@ export async function expectTokenBalance(
 ) {
   // Then check the balance
   const contractWithWallet = TokenContract.at(token.address, wallet);
-  const balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
+  const { result: balance } = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);
 }

package/src/guides/up_quick_start.sh

@@ -23,6 +23,8 @@ 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)
 echo "Deployed contract at $TOKEN_ADDRESS"
@@ -38,9 +40,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/shared/cross_chain_test_harness.ts

@@ -73,22 +73,26 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   });
 
   // deploy l2 token
-  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18).send({ from: owner });
+  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 });
+  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 });
-  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
+  if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })).result === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
 
@@ -269,7 +273,7 @@ export class CrossChainTestHarness {
     authwitNonce: Fr = Fr.ZERO,
     authWitness: AuthWitness,
   ): Promise<TxReceipt> {
-    const withdrawReceipt = await this.l2Bridge.methods
+    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 });
 
@@ -277,7 +281,7 @@ export class CrossChainTestHarness {
   }
 
   async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<TxReceipt> {
-    const withdrawReceipt = await this.l2Bridge.methods
+    const { receipt: withdrawReceipt } = await this.l2Bridge.methods
       .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
       .send({ from: this.ownerAddress });
 
@@ -285,7 +289,7 @@ export class CrossChainTestHarness {
   }
 
   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) {
@@ -295,7 +299,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) {

package/src/shared/gas_portal_test_harness.ts

@@ -131,7 +131,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {
-    return await this.feeJuice.methods.balance_of_public(owner).simulate({ from: owner });
+    return (await this.feeJuice.methods.balance_of_public(owner).simulate({ from: owner })).result;
   }
 
   async expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint) {

package/src/shared/index.ts

@@ -1 +1,2 @@
 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/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`,
+    );
+  }
 });