@aztec/end-to-end 0.0.1-commit.1bea0213 → 0.0.1-commit.21ecf947b

package/src/fixtures/e2e_prover_test.ts

@@ -20,13 +20,13 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type Hex, getContract } from 'viem';
 import { privateKeyToAddress } from 'viem/accounts';
 
 import { TokenSimulator } from '../simulators/token_simulator.js';
+import { TestWallet } from '../test-wallet/test_wallet.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import {
@@ -144,7 +144,7 @@ export class FullProverTest {
     this.logger.info(`Enabling proving`, { realProofs: this.realProofs });
 
     // We don't wish to mark as proven automatically, so we set the flag to false
-    this.context.watcher!.setIsMarkingAsProven(false);
+    this.context.watcher.setIsMarkingAsProven(false);
 
     this.simulatedProverNode = this.context.proverNode!;
     ({
@@ -152,7 +152,7 @@ export class FullProverTest {
       deployL1ContractsValues: this.l1Contracts,
       cheatCodes: this.cheatCodes,
     } = this.context);
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
 
     const config = this.context.aztecNodeConfig;
     const blobClient = await createBlobClientWithFileStores(config, this.logger);
@@ -198,7 +198,7 @@ export class FullProverTest {
       this.aztecNode,
       { proverEnabled: this.realProofs },
       undefined,
-      true,
+      'pxe-proven',
     );
     this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
     await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
@@ -225,7 +225,7 @@ export class FullProverTest {
     this.logger.verbose('Starting archiver for new prover node');
     const archiver = await createArchiver(
       { ...this.context.aztecNodeConfig, dataDirectory: undefined },
-      { blobClient, dateProvider: this.context.dateProvider! },
+      { blobClient, dateProvider: this.context.dateProvider },
       { blockUntilSync: true },
     );
 

package/src/fixtures/ha_setup.ts

@@ -0,0 +1,186 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Logger } from '@aztec/aztec.js/log';
+import { SecretValue } from '@aztec/foundation/config';
+
+import { Pool } from 'pg';
+import { privateKeyToAccount } from 'viem/accounts';
+
+/**
+ * Configuration for HA database connection
+ */
+export interface HADatabaseConfig {
+  /** PostgreSQL connection URL */
+  databaseUrl: string;
+  /** Node ID for HA coordination */
+  nodeId: string;
+  /** Enable HA signing */
+  haSigningEnabled: boolean;
+  /** Polling interval in ms */
+  pollingIntervalMs: number;
+  /** Signing timeout in ms */
+  signingTimeoutMs: number;
+  /** Max stuck duties age in ms */
+  maxStuckDutiesAgeMs: number;
+}
+
+/**
+ * Get database configuration from environment variables
+ */
+export function createHADatabaseConfig(nodeId: string): HADatabaseConfig {
+  const databaseUrl = process.env.DATABASE_URL || 'postgresql://aztec:aztec@localhost:5432/aztec_ha_test';
+
+  return {
+    databaseUrl,
+    nodeId,
+    haSigningEnabled: true,
+    pollingIntervalMs: 100,
+    signingTimeoutMs: 3000,
+    maxStuckDutiesAgeMs: 72000,
+  };
+}
+
+/**
+ * Setup PostgreSQL database connection pool for HA tests
+ *
+ * Note: Database migrations should be run separately before starting tests,
+ * either via docker-compose entrypoint or manually with: aztec migrate-ha-db up
+ */
+export function setupHADatabase(databaseUrl: string, logger?: Logger): Pool {
+  try {
+    // Create connection pool for test usage
+    // Migrations are already run by docker-compose entrypoint before tests start
+    const pool = new Pool({ connectionString: databaseUrl });
+
+    logger?.info('Connected to HA database (migrations should already be applied)');
+
+    return pool;
+  } catch (error) {
+    logger?.error(`Failed to connect to HA database: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Clean up HA database - drop all tables
+ * Use this between tests to ensure clean state
+ */
+export async function cleanupHADatabase(pool: Pool, logger?: Logger): Promise<void> {
+  try {
+    // Drop all HA tables
+    await pool.query('DROP TABLE IF EXISTS validator_duties CASCADE');
+    await pool.query('DROP TABLE IF EXISTS schema_version CASCADE');
+    // Drop migration tracking table (node-pg-migrate uses 'pgmigrations' by default)
+    // This ensures migrations will run fresh on next startup
+    await pool.query('DROP TABLE IF EXISTS pgmigrations CASCADE');
+
+    logger?.info('HA database cleaned up successfully');
+  } catch (error) {
+    logger?.error(`Failed to cleanup HA database: ${error}`);
+    throw error;
+  }
+}
+
+/**
+ * Query validator duties from the database
+ */
+export async function getValidatorDuties(
+  pool: Pool,
+  slot: bigint,
+  dutyType?: 'ATTESTATION' | 'BLOCK_PROPOSAL' | 'GOVERNANCE_VOTE' | 'SLASHING_VOTE',
+): Promise<
+  Array<{
+    slot: string;
+    dutyType: string;
+    validatorAddress: string;
+    nodeId: string;
+    startedAt: Date;
+    completedAt: Date | undefined;
+  }>
+> {
+  const query = dutyType
+    ? 'SELECT slot, duty_type, validator_address, node_id, started_at, completed_at FROM validator_duties WHERE slot = $1 AND duty_type = $2 ORDER BY started_at'
+    : 'SELECT slot, duty_type, validator_address, node_id, started_at, completed_at FROM validator_duties WHERE slot = $1 ORDER BY started_at';
+
+  const params = dutyType ? [slot.toString(), dutyType] : [slot.toString()];
+
+  const result = await pool.query<{
+    slot: string;
+    duty_type: string;
+    validator_address: string;
+    node_id: string;
+    started_at: Date;
+    completed_at: Date | undefined;
+  }>(query, params);
+
+  return result.rows.map(row => ({
+    slot: row.slot,
+    dutyType: row.duty_type,
+    validatorAddress: row.validator_address,
+    nodeId: row.node_id,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+  }));
+}
+
+/**
+ * Convert private keys to Ethereum addresses
+ */
+export function getAddressesFromPrivateKeys(privateKeys: `0x${string}`[]): string[] {
+  return privateKeys.map(pk => {
+    const account = privateKeyToAccount(pk);
+    return account.address;
+  });
+}
+
+/**
+ * Create initial validators from private keys for L1 contract deployment
+ */
+export function createInitialValidatorsFromPrivateKeys(attesterPrivateKeys: `0x${string}`[]): Array<{
+  attester: EthAddress;
+  withdrawer: EthAddress;
+  privateKey: `0x${string}`;
+  bn254SecretKey: SecretValue<bigint>;
+}> {
+  return attesterPrivateKeys.map(pk => {
+    const account = privateKeyToAccount(pk);
+    return {
+      attester: EthAddress.fromString(account.address),
+      withdrawer: EthAddress.fromString(account.address),
+      privateKey: pk,
+      bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+    };
+  });
+}
+
+/**
+ * Verify no duplicate attestations per validator (HA coordination check)
+ * Groups duties by validator address and verifies each validator attested exactly once
+ */
+export function verifyNoDuplicateAttestations(
+  attestationDuties: Array<{
+    validatorAddress: string;
+    nodeId: string;
+    completedAt: Date | undefined;
+  }>,
+  logger?: Logger,
+): Map<string, typeof attestationDuties> {
+  const dutiesByValidator = new Map<string, typeof attestationDuties>();
+  for (const duty of attestationDuties) {
+    const existing = dutiesByValidator.get(duty.validatorAddress) || [];
+    existing.push(duty);
+    dutiesByValidator.set(duty.validatorAddress, existing);
+  }
+
+  for (const [validatorAddress, validatorDuties] of dutiesByValidator.entries()) {
+    if (validatorDuties.length !== 1) {
+      throw new Error(`Validator ${validatorAddress} attested ${validatorDuties.length} times (expected exactly once)`);
+    }
+    if (!validatorDuties[0].completedAt) {
+      throw new Error(`Validator ${validatorAddress} attestation duty not completed`);
+    }
+    logger?.info(`Validator ${validatorAddress} attested once via node ${validatorDuties[0].nodeId}`);
+  }
+
+  return dutiesByValidator;
+}

package/src/fixtures/index.ts

@@ -1,4 +1,5 @@
 export * from './fixtures.js';
+export * from './ha_setup.js';
 export * from './logging.js';
 export * from './utils.js';
 export * from './token_utils.js';

package/src/fixtures/setup.ts

@@ -1,5 +1,5 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
+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';
@@ -13,7 +13,7 @@ import {
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
 import { Fr } from '@aztec/aztec.js/fields';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import { type AztecNode, createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+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';
@@ -41,7 +41,7 @@ import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { tryRmDir } from '@aztec/foundation/fs';
-import { withLogNameSuffix } from '@aztec/foundation/log';
+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';
@@ -67,7 +67,7 @@ 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';
@@ -84,6 +84,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';
@@ -92,9 +93,6 @@ import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 export { startAnvil };
 
-const { AZTEC_NODE_URL = '' } = process.env;
-const getAztecUrl = () => AZTEC_NODE_URL;
-
 let telemetry: TelemetryClient | undefined = undefined;
 async function getTelemetryClient(partialConfig: Partial<TelemetryClientConfig> & { benchmark?: boolean } = {}) {
   if (!telemetry) {
@@ -125,14 +123,14 @@ export async function setupSharedBlobStorage(config: { dataDirectory?: string }
  * @param aztecNode - An instance of Aztec Node.
  * @param opts - Partial configuration for the PXE.
  * @param logger - The logger to be used.
- * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
+ * @param actor - Actor label to include in log output (e.g., 'pxe-test').
  * @returns A test wallet, logger and teardown function.
  */
 export async function setupPXEAndGetWallet(
   aztecNode: AztecNode,
   opts: Partial<PXEConfig> = {},
   logger = getLogger(),
-  useLogSuffix = false,
+  actor?: string,
 ): Promise<{
   wallet: TestWallet;
   logger: Logger;
@@ -150,9 +148,7 @@ export async function setupPXEAndGetWallet(
 
   const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(PXEConfig.dataDirectory!);
 
-  const wallet = await TestWallet.create(aztecNode, PXEConfig, {
-    useLogSuffix,
-  });
+  const wallet = await TestWallet.create(aztecNode, PXEConfig, { loggerActorLabel: actor });
 
   return {
     wallet,
@@ -219,13 +215,13 @@ export type EndToEndContext = {
   anvil: Anvil | undefined;
   /** The Aztec Node service or client a connected to it. */
   aztecNode: AztecNode;
-  /** The Aztec Node as a service (only set if running locally). */
-  aztecNodeService: AztecNodeService | undefined;
-  /** Client to the Aztec Node admin interface (undefined if connected to remote environment) */
-  aztecNodeAdmin: AztecNodeAdmin | undefined;
+  /** The Aztec Node as a service. */
+  aztecNodeService: AztecNodeService;
+  /** Client to the Aztec Node admin interface. */
+  aztecNodeAdmin: AztecNodeAdmin;
   /** The prover node service (only set if startProverNode is true) */
   proverNode: ProverNode | undefined;
-  /** A client to the sequencer service (undefined if connected to remote environment) */
+  /** A client to the sequencer service. */
   sequencer: SequencerClient | undefined;
   /** Return values from deployAztecL1Contracts function. */
   deployL1ContractsValues: DeployAztecL1ContractsReturnType;
@@ -245,12 +241,12 @@ export type EndToEndContext = {
   cheatCodes: CheatCodes;
   /** The cheat codes for L1 */
   ethCheatCodes: EthCheatCodes;
-  /** The anvil test watcher (undefined if connected to remote environment) */
-  watcher: AnvilTestWatcher | undefined;
-  /** Allows tweaking current system time, used by the epoch cache only (undefined if connected to remote environment) */
-  dateProvider: TestDateProvider | undefined;
+  /** The anvil test watcher. */
+  watcher: AnvilTestWatcher;
+  /** Allows tweaking current system time, used by the epoch cache only. */
+  dateProvider: TestDateProvider;
   /** Telemetry client */
-  telemetryClient: TelemetryClient | undefined;
+  telemetryClient: TelemetryClient;
   /** Mock gossip sub network used for gossipping messages (only if mockGossipSubNetwork was set to true in opts) */
   mockGossipSubNetwork: MockGossipSubNetwork | undefined;
   /** Prefilled public data used for setting up nodes. */
@@ -260,87 +256,11 @@ export type EndToEndContext = {
   /** BB config (only set if running locally). */
   bbConfig: Awaited<ReturnType<typeof getBBConfig>>;
   /** Directory to cleanup on teardown. */
-  directoryToCleanup: string | undefined;
+  directoryToCleanup: string;
   /** Function to stop the started services. */
   teardown: () => Promise<void>;
 };
 
-/**
- * Function to setup the test against a remote deployment. It is assumed that L1 contract are already deployed
- */
-async function setupWithRemoteEnvironment(
-  account: HDAccount | PrivateKeyAccount,
-  config: AztecNodeConfig & SetupOptions,
-  logger: Logger,
-  numberOfAccounts: number,
-): Promise<EndToEndContext> {
-  const aztecNodeUrl = getAztecUrl();
-  logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
-  const aztecNode = createAztecNodeClient(aztecNodeUrl);
-  await waitForNode(aztecNode, logger);
-  logger.verbose('JSON RPC client connected to Aztec Node');
-  logger.verbose(`Retrieving contract addresses from ${aztecNodeUrl}`);
-  const { l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
-
-  const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
-
-  const deployL1ContractsValues: DeployAztecL1ContractsReturnType = {
-    l1ContractAddresses,
-    l1Client,
-    rollupVersion,
-  };
-  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, new DateProvider());
-  const wallet = await TestWallet.create(aztecNode);
-
-  if (config.walletMinFeePadding !== undefined) {
-    wallet.setMinFeePadding(config.walletMinFeePadding);
-  }
-
-  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, new DateProvider());
-  const teardown = () => Promise.resolve();
-
-  logger.verbose('Populating wallet from already registered accounts...');
-  const initialFundedAccounts = await getInitialTestAccountsData();
-
-  if (initialFundedAccounts.length < numberOfAccounts) {
-    throw new Error(`Required ${numberOfAccounts} accounts. Found ${initialFundedAccounts.length}.`);
-  }
-
-  const testAccounts = await Promise.all(
-    initialFundedAccounts.slice(0, numberOfAccounts).map(async account => {
-      const accountManager = await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey);
-      return accountManager.address;
-    }),
-  );
-
-  return {
-    anvil: undefined,
-    aztecNode,
-    aztecNodeService: undefined,
-    aztecNodeAdmin: undefined,
-    sequencer: undefined,
-    proverNode: undefined,
-    deployL1ContractsValues,
-    config,
-    aztecNodeConfig: config,
-    initialFundedAccounts,
-    wallet,
-    accounts: testAccounts,
-    logger,
-    cheatCodes,
-    ethCheatCodes,
-    prefilledPublicData: undefined,
-    mockGossipSubNetwork: undefined,
-    watcher: undefined,
-    dateProvider: undefined,
-    telemetryClient: undefined,
-    acvmConfig: undefined,
-    bbConfig: undefined,
-    directoryToCleanup: undefined,
-    teardown,
-  };
-}
-
 /**
  * Sets up the environment for the end-to-end tests.
  * @param numberOfAccounts - The number of new accounts to be created once the PXE is initiated.
@@ -370,6 +290,8 @@ export async function setup(
     config.enforceTimeTable = !!opts.enforceTimeTable;
     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
@@ -383,16 +305,10 @@ export async function setup(
       if (!isAnvilTestChain(chain.id)) {
         throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
       }
-      if (AZTEC_NODE_URL) {
-        throw new Error(
-          `AZTEC_NODE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
-        );
-      }
-
       const res = await startAnvil({
         l1BlockTime: opts.ethereumSlotDuration,
         accounts: opts.anvilAccounts,
-        port: opts.anvilPort,
+        port: opts.anvilPort ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : undefined),
       });
       anvil = res.anvil;
       config.l1RpcUrls = [res.rpcUrl];
@@ -443,11 +359,6 @@ export async function setup(
       config.coinbase = EthAddress.fromString(publisherHdAccount.address);
     }
 
-    if (AZTEC_NODE_URL) {
-      // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
-      return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
-    }
-
     // Determine which addresses to fund in genesis
     const initialFundedAccounts =
       opts.initialFundedAccounts ??
@@ -504,9 +415,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 });
     }
@@ -574,10 +490,12 @@ export async function setup(
       }
     }
 
-    const aztecNodeService = await AztecNodeService.createAndSync(
-      config,
-      { dateProvider, telemetry: telemetryClient, p2pClientDeps, logger: createLogger('node:MAIN-aztec-node') },
-      { prefilledPublicData },
+    const aztecNodeService = await withLoggerBindings({ actor: 'node-0' }, () =>
+      AztecNodeService.createAndSync(
+        config,
+        { dateProvider, telemetry: telemetryClient, p2pClientDeps },
+        { prefilledPublicData },
+      ),
     );
     const sequencerClient = aztecNodeService.getSequencer();
 
@@ -595,7 +513,7 @@ export async function setup(
       const proverNodeConfig = {
         ...config.proverNodeConfig,
         dataDirectory: proverNodeDataDirectory,
-        p2pEnabled: false,
+        p2pEnabled: !!mockGossipSubNetwork,
       };
       proverNode = await createAndSyncProverNode(
         proverNodePrivateKeyHex,
@@ -603,6 +521,11 @@ export async function setup(
         proverNodeConfig,
         aztecNodeService,
         prefilledPublicData,
+        {
+          p2pClientDeps: mockGossipSubNetwork
+            ? { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) }
+            : undefined,
+        },
       );
     }
 
@@ -611,7 +534,7 @@ export async function setup(
     pxeConfig.dataDirectory = path.join(directoryToCleanup, randomBytes(8).toString('hex'));
     // For tests we only want proving enabled if specifically requested
     pxeConfig.proverEnabled = !!pxeOpts.proverEnabled;
-    const wallet = await TestWallet.create(aztecNodeService, pxeConfig);
+    const wallet = await TestWallet.create(aztecNodeService, pxeConfig, { loggerActorLabel: 'pxe-0' });
 
     if (opts.walletMinFeePadding !== undefined) {
       wallet.setMinFeePadding(opts.walletMinFeePadding);
@@ -683,7 +606,7 @@ export async function setup(
         logger.error(`Error during e2e test teardown`, err);
       } finally {
         try {
-          await telemetryClient?.stop();
+          await telemetryClient.stop();
         } catch (err) {
           logger.error(`Error during telemetry client stop`, err);
         }
@@ -797,7 +720,7 @@ export function createAndSyncProverNode(
   prefilledPublicData: PublicDataTreeLeaf[] = [],
   proverNodeDeps: ProverNodeDeps = {},
 ) {
-  return withLogNameSuffix('prover-node', async () => {
+  return withLoggerBindings({ actor: 'prover-0' }, async () => {
     const aztecNodeTxProvider = aztecNode && {
       getTxByHash: aztecNode.getTxByHash.bind(aztecNode),
       getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
@@ -870,12 +793,11 @@ 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(address => method(address).simulate({ from: address })));
     const debugString = `${symbol} balances: ${addresses.map((address, i) => `${address}: ${b[i]}`).join(', ')}`;
     logger.verbose(debugString);
     return b;