@aztec/end-to-end 0.0.1-commit.f5d02921e → 0.0.1-commit.f7ea82942

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

package/src/legacy-jest-resolver.cjs

@@ -0,0 +1,135 @@
+// 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.
+//
+// The cache is populated on demand by running `npm install` into .legacy-contracts/<version>/.
+//
+// Activated by env var; passthrough otherwise.
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const version = process.env.CONTRACT_ARTIFACTS_VERSION;
+const REDIRECTED = ['@aztec/noir-contracts.js', '@aztec/noir-test-contracts.js', '@aztec/accounts'];
+
+// Jest sets rootDir to <e2e>/src; this file lives there too.
+const e2eRoot = path.resolve(__dirname, '..');
+const cacheRoot = version ? path.join(e2eRoot, '.legacy-contracts', version) : null;
+
+function pkgJsonPath(name) {
+  return path.join(cacheRoot, 'node_modules', name, 'package.json');
+}
+
+function ensureCache() {
+  const missing = REDIRECTED.some(p => !fs.existsSync(pkgJsonPath(p)));
+  if (!missing) {
+    return;
+  }
+  fs.mkdirSync(cacheRoot, { 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(cacheRoot, 'package.json');
+  if (!fs.existsSync(seed)) {
+    fs.writeFileSync(seed, JSON.stringify({ name: 'legacy-contracts-cache', private: true }));
+  }
+
+  const specs = REDIRECTED.map(p => `${p}@${version}`).join(' ');
+  process.stderr.write(`[legacy-contracts] installing ${specs} into ${cacheRoot}\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.
+  execSync(`npm install --prefix "${cacheRoot}" --no-save --ignore-scripts --legacy-peer-deps ${specs}`, {
+    stdio: 'inherit',
+  });
+
+  // Verify versions on disk match the requested version.
+  for (const p of REDIRECTED) {
+    const onDisk = JSON.parse(fs.readFileSync(pkgJsonPath(p), 'utf8')).version;
+    if (onDisk !== version) {
+      throw new Error(`[legacy-contracts] ${p} on disk is ${onDisk}, expected ${version}`);
+    }
+  }
+}
+
+if (version) {
+  ensureCache();
+}
+
+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(cacheRoot, '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)) {
+    throw new Error(
+      `[legacy-contracts] artifact ${path.basename(legacy)} not present in legacy cache @${version}; ` +
+        `the contract may have been added after that release. Pin a newer CONTRACT_ARTIFACTS_VERSION or skip this test.`,
+    );
+  }
+  if (!seen.has(resolved)) {
+    seen.add(resolved);
+    process.stderr.write(`[legacy-contracts][jest] redirected ${path.basename(legacy)} -> ${legacy}\n`);
+  }
+  return legacy;
+};

package/src/shared/gas_portal_test_harness.ts

@@ -178,4 +178,3 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     }
   }
 }
-// docs:end:cross_chain_test_harness

package/src/shared/uniswap_l1_l2.ts

@@ -154,7 +154,6 @@ export const uniswapL1L2TestSuite = (
       await cleanup();
     });
 
-    // docs:start:uniswap_private
     it('should uniswap trade on L1 from L2 funds privately (swaps WETH -> DAI)', async () => {
       const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
 
@@ -345,10 +344,8 @@ export const uniswapL1L2TestSuite = (
       logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
       logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
     });
-    // docs:end:uniswap_private
 
     // TODO(#7463): reenable look into this failure https://github.com/AztecProtocol/aztec-packages/actions/runs/9912612912/job/27388320150?pr=7462
-    // // docs:start:uniswap_public
     // it('should uniswap trade on L1 from L2 funds publicly (swaps WETH -> DAI)', async () => {
     //   const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
 
@@ -581,7 +578,6 @@ export const uniswapL1L2TestSuite = (
     //   logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
     //   logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
     // });
-    // // docs:end:uniswap_public
 
     // Edge cases for the private flow:
     // note - tests for uniswapPortal.sol and minting asset on L2 are covered in other tests.

package/src/spartan/setup_test_wallets.ts

@@ -138,37 +138,11 @@ async function deployAccountWithDiagnostics(
   estimateGas?: boolean,
 ): Promise<void> {
   const deployMethod = await account.getDeployMethod();
-  let txHash;
   let gasSettings: any;
-  try {
-    if (estimateGas) {
-      const sim = await deployMethod.simulate({ from: NO_FROM, fee: { paymentMethod } });
-      gasSettings = sim.estimatedGas;
-      logger.info(`${accountLabel} estimated gas: DA=${gasSettings.gasLimits.daGas} L2=${gasSettings.gasLimits.l2Gas}`);
-    }
-    const deployResult = await deployMethod.send({
-      from: NO_FROM,
-      fee: { paymentMethod, gasSettings },
-      wait: NO_WAIT,
-    });
-    txHash = deployResult.txHash;
-    await waitForTx(aztecNode, txHash, { timeout: 2400 });
-    logger.info(`${accountLabel} deployed at ${account.address}`);
-  } catch (error) {
-    const blockNumber = await aztecNode.getBlockNumber();
-    let receipt;
-    try {
-      receipt = await aztecNode.getTxReceipt(txHash);
-    } catch {
-      receipt = 'unavailable';
-    }
-    logger.error(`${accountLabel} deployment failed`, {
-      txHash: txHash.toString(),
-      receipt: JSON.stringify(receipt),
-      currentBlockNumber: blockNumber,
-      error: String(error),
-    });
-    throw error;
+  if (estimateGas) {
+    const sim = await deployMethod.simulate({ from: NO_FROM, fee: { paymentMethod } });
+    gasSettings = sim.estimatedGas;
+    logger.info(`${accountLabel} estimated gas: DA=${gasSettings.gasLimits.daGas} L2=${gasSettings.gasLimits.l2Gas}`);
   }
 
   // Track the tx hash across retries so we don't re-send when the previous tx is still pending.
@@ -196,7 +170,7 @@ async function deployAccountWithDiagnostics(
 
       if (!sentTxHash) {
         const deployResult = await deployMethod.send({
-          from: AztecAddress.ZERO,
+          from: NO_FROM,
           fee: { paymentMethod, gasSettings },
           wait: NO_WAIT,
         });

package/src/test-wallet/test_wallet.ts

@@ -1,7 +1,9 @@
 import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
 import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/stub/ecdsa';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/stub/schnorr';
 import { type Account, type AccountContract, NO_FROM } from '@aztec/aztec.js/account';
+import type { CompleteAddress } from '@aztec/aztec.js/addresses';
 import {
   type CallIntent,
   type ContractFunctionInteractionCallIntent,
@@ -13,6 +15,7 @@ import {
 } from '@aztec/aztec.js/authorization';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import { AccountManager, type SendOptions } from '@aztec/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
 import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
 import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { Fq, Fr } from '@aztec/foundation/curves/bn254';
@@ -25,17 +28,19 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 import type { NoteDao } from '@aztec/stdlib/note';
-import type {
-  BlockHeader,
+import {
+  type BlockHeader,
+  type ContractOverrides,
   SimulationOverrides,
-  TxExecutionRequest,
-  TxHash,
-  TxReceipt,
-  TxSimulationResult,
+  type TxExecutionRequest,
+  type TxHash,
+  type TxReceipt,
 } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
+import type { AccountType } from '@aztec/wallets/embedded';
 
+import { DEFAULT_MIN_FEE_PADDING } from '../fixtures/fixtures.js';
 import { AztecNodeProxy, ProvenTx } from './utils.js';
 
 /**
@@ -44,6 +49,7 @@ import { AztecNodeProxy, ProvenTx } from './utils.js';
 export interface AccountData {
   secret: Fr;
   salt: Fr;
+  type?: AccountType;
   contract: AccountContract;
 }
 
@@ -58,6 +64,7 @@ export class TestWallet extends BaseWallet {
     private readonly nodeRef: AztecNodeProxy,
   ) {
     super(pxe, nodeRef);
+    this.minFeePadding = DEFAULT_MIN_FEE_PADDING;
   }
 
   static async create(
@@ -84,50 +91,81 @@ export class TestWallet extends BaseWallet {
 
   createSchnorrAccount(secret: Fr, salt: Fr, signingKey?: Fq): Promise<AccountManager> {
     signingKey = signingKey ?? deriveSigningKey(secret);
-    const accountData = {
-      secret,
-      salt,
-      contract: new SchnorrAccountContract(signingKey),
-    };
-    return this.createAccount(accountData);
+    return this.createAccount({ secret, salt, type: 'schnorr', contract: new SchnorrAccountContract(signingKey) });
   }
 
   createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
-    const accountData = {
+    return this.createAccount({
       secret,
       salt,
+      type: 'ecdsasecp256r1',
       contract: new EcdsaRAccountContract(signingKey),
-    };
-    return this.createAccount(accountData);
+    });
   }
 
   createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
-    const accountData = {
+    return this.createAccount({
       secret,
       salt,
+      type: 'ecdsasecp256k1',
       contract: new EcdsaKAccountContract(signingKey),
-    };
-    return this.createAccount(accountData);
+    });
   }
 
-  async getFakeAccountDataFor(address: AztecAddress) {
-    const originalAccount = await this.getAccountFromAddress(address);
-    const originalAddress = originalAccount.getCompleteAddress();
-    const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
-    if (!contractInstance) {
-      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+  /**
+   * Builds contract overrides for all provided addresses by replacing their account contracts with stub implementations.
+   */
+  protected async buildAccountOverrides(addresses: AztecAddress[]): Promise<ContractOverrides> {
+    const accounts = await this.getAccounts();
+    const contracts: ContractOverrides = {};
+
+    const filtered = accounts.filter(acc => addresses.some(addr => addr.equals(acc.item)));
+
+    for (const account of filtered) {
+      const address = account.item;
+      const originalAccount = await this.getAccountFromAddress(address);
+      const completeAddress = originalAccount.getCompleteAddress();
+      const contractInstance = await this.pxe.getContractInstance(completeAddress.address);
+      if (!contractInstance) {
+        throw new Error(
+          `No contract instance found for address: ${completeAddress.address} during account override building. This is a bug!`,
+        );
+      }
+
+      const stubArtifact = this.getStubArtifactFor(address);
+      const stubConstructorArgs =
+        this.getTypeFor(address) === 'schnorr' ? [Fr.ZERO, Fr.ZERO] : [Buffer.alloc(32), Buffer.alloc(32)];
+      const stubInstance = await getContractInstanceFromInstantiationParams(stubArtifact, {
+        salt: Fr.random(),
+        constructorArgs: stubConstructorArgs,
+      });
+
+      contracts[address.toString()] = {
+        instance: stubInstance,
+        artifact: stubArtifact,
+      };
     }
-    const stubAccount = createStubAccount(originalAddress);
-    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
-      salt: Fr.random(),
-    });
-    return {
-      account: stubAccount,
-      instance,
-      artifact: StubAccountContractArtifact,
-    };
+
+    return contracts;
+  }
+
+  protected accounts: Map<string, { account: Account; type: AccountType }> = new Map();
+
+  private getTypeFor(address: AztecAddress): AccountType {
+    return this.accounts.get(address.toString())?.type ?? 'schnorr';
+  }
+
+  private getStubArtifactFor(address: AztecAddress) {
+    return this.getTypeFor(address) === 'schnorr'
+      ? StubSchnorrAccountContractArtifact
+      : StubEcdsaAccountContractArtifact;
+  }
+
+  private getStubAccountFor(address: AztecAddress, completeAddress: CompleteAddress) {
+    return this.getTypeFor(address) === 'schnorr'
+      ? createStubSchnorrAccount(completeAddress)
+      : createStubEcdsaAccount(completeAddress);
   }
-  protected accounts: Map<string, Account> = new Map();
 
   /**
    * Controls how the test wallet simulates transactions:
@@ -142,26 +180,29 @@ export class TestWallet extends BaseWallet {
   }
 
   setMinFeePadding(value?: number) {
-    this.minFeePadding = value ?? 0.5;
+    this.minFeePadding = value ?? DEFAULT_MIN_FEE_PADDING;
   }
 
   protected getAccountFromAddress(address: AztecAddress): Promise<Account> {
-    const account = this.accounts.get(address?.toString() ?? '');
+    const entry = this.accounts.get(address?.toString() ?? '');
 
-    if (!account) {
+    if (!entry) {
       throw new Error(`Account not found in wallet for address: ${address}`);
     }
 
-    return Promise.resolve(account);
+    return Promise.resolve(entry.account);
   }
 
   getAccounts() {
-    return Promise.resolve(Array.from(this.accounts.values()).map(acc => ({ alias: '', item: acc.getAddress() })));
+    return Promise.resolve(
+      Array.from(this.accounts.values()).map(entry => ({ alias: '', item: entry.account.getAddress() })),
+    );
   }
 
   async createAccount(accountData?: AccountData): Promise<AccountManager> {
     const secret = accountData?.secret ?? Fr.random();
     const salt = accountData?.salt ?? Fr.random();
+    const type = accountData?.type ?? 'schnorr';
     const contract = accountData?.contract ?? new SchnorrAccountContract(GrumpkinScalar.random());
 
     const accountManager = await AccountManager.create(this, secret, contract, salt);
@@ -171,7 +212,8 @@ export class TestWallet extends BaseWallet {
 
     await this.registerContract(instance, artifact, secret);
 
-    this.accounts.set(accountManager.address.toString(), await accountManager.getAccount());
+    const address = accountManager.address.toString();
+    this.accounts.set(address, { account: await accountManager.getAccount(), type });
 
     return accountManager;
   }
@@ -217,9 +259,12 @@ export class TestWallet extends BaseWallet {
   protected override async simulateViaEntrypoint(
     executionPayload: ExecutionPayload,
     opts: SimulateViaEntrypointOptions,
-  ): Promise<TxSimulationResult> {
-    const { from, feeOptions, scopes, skipTxValidation, skipFeeEnforcement } = opts;
+  ): Promise<TxSimulationResultWithAppOffset> {
+    const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement } = opts;
+    const scopes = this.scopesFrom(from, additionalScopes);
     const skipKernels = this.simulationMode !== 'full';
+    const useOverride = this.simulationMode === 'kernelless-override';
+
     const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
     const finalExecutionPayload = feeExecutionPayload
       ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
@@ -228,18 +273,19 @@ export class TestWallet extends BaseWallet {
 
     let overrides: SimulationOverrides | undefined;
     let txRequest: TxExecutionRequest;
+    if (useOverride) {
+      const accountOverrides = await this.buildAccountOverrides(scopes);
+      overrides = new SimulationOverrides(accountOverrides);
+    }
+
     if (from === NO_FROM) {
       const entrypoint = new DefaultEntrypoint();
       txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
     } else {
-      const useOverride = this.simulationMode === 'kernelless-override';
       let fromAccount: Account;
       if (useOverride) {
-        const { account, instance, artifact } = await this.getFakeAccountDataFor(from);
-        fromAccount = account;
-        overrides = {
-          contracts: { [from.toString()]: { instance, artifact } },
-        };
+        const originalAccount = await this.getAccountFromAddress(from);
+        fromAccount = this.getStubAccountFor(from, originalAccount.getCompleteAddress());
       } else {
         fromAccount = await this.getAccountFromAddress(from);
       }
@@ -257,7 +303,7 @@ export class TestWallet extends BaseWallet {
       );
     }
 
-    return this.pxe.simulateTx(txRequest, {
+    const result = await this.pxe.simulateTx(txRequest, {
       simulatePublic: true,
       skipKernels,
       skipFeeEnforcement,
@@ -265,10 +311,16 @@ export class TestWallet extends BaseWallet {
       overrides,
       scopes,
     });
+    const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+    return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
   }
 
   async proveTx(exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>): Promise<ProvenTx> {
-    const fee = await this.completeFeeOptions(opts.from, exec.feePayer, opts.fee?.gasSettings);
+    const fee = await this.completeFeeOptions({
+      from: opts.from,
+      feePayer: exec.feePayer,
+      gasSettings: opts.fee?.gasSettings,
+    });
     const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(exec, opts.from, fee);
     const txProvingResult = await this.pxe.proveTx(txRequest, this.scopesFrom(opts.from, opts.additionalScopes));
     return new ProvenTx(

package/src/test-wallet/worker_wallet.ts

@@ -13,6 +13,7 @@ import type {
   ProfileOptions,
   SendOptions,
   SimulateOptions,
+  TxSimulationResultWithAppOffset,
   Wallet,
   WalletCapabilities,
 } from '@aztec/aztec.js/wallet';
@@ -29,7 +30,7 @@ import type { ContractArtifact, EventMetadataDefinition, FunctionCall } from '@a
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { ExecutionPayload, TxProfileResult, TxSimulationResult, UtilityExecutionResult } from '@aztec/stdlib/tx';
+import type { ExecutionPayload, TxProfileResult, UtilityExecutionResult } from '@aztec/stdlib/tx';
 import { Tx } from '@aztec/stdlib/tx';
 
 import { Worker } from 'worker_threads';
@@ -165,7 +166,7 @@ export class WorkerWallet implements Wallet {
     return this.call('registerContract', instance, artifact, secretKey);
   }
 
-  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResultWithAppOffset> {
     return this.call('simulateTx', exec, opts);
   }