@aztec/test-wallet 3.0.0-devnet.2

package/dest/wallet/test_wallet.js

@@ -0,0 +1,174 @@
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { SignerlessAccount } from '@aztec/aztec.js/account';
+import { SetPublicAuthwitContractInteraction, getMessageHashFromIntent, lookupValidity } from '@aztec/aztec.js/authorization';
+import { BaseWallet } from '@aztec/aztec.js/wallet';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ProvenTx } from '../utils.js';
+/**
+ * Wallet implementation that stores accounts in memory and allows allows their creation
+ * from the outside (which is something actual wallets shouldn't allow!)
+ * It is intended to be used in e2e tests.
+ */ export class BaseTestWallet extends BaseWallet {
+    accounts = new Map();
+    /**
+   * Toggle for running "simulated simulations" when calling simulateTx.
+   *
+   * Terminology:
+   * - "simulation": run private circuits normally and then run the kernel in a simulated (brillig) mode on ACVM.
+   *   No kernel witnesses are generated, but protocol rules are checked.
+   * - "simulated simulation": skip running kernels in ACVM altogether and emulate their behavior in TypeScript
+   *   (akin to generateSimulatedProvingResult). We mutate public inputs like the kernels would and can swap in
+   *   fake/private bytecode or accounts for tests. This is much faster but is not usable in situations where we
+   *   need kernel witnesses.
+   *
+   * When this flag is true, simulateTx constructs a request using a fake account (and accepts contract overrides
+   * on the input) and the PXE emulates kernel effects without generating kernel witnesses. When false, simulateTx
+   * defers to the standard simulation path.
+   */ simulatedSimulations = false;
+    /** Enable the "simulated simulation" path for simulateTx. */ enableSimulatedSimulations() {
+        this.simulatedSimulations = true;
+    }
+    /** Disable the "simulated simulation" path for simulateTx. */ disableSimulatedSimulations() {
+        this.simulatedSimulations = false;
+    }
+    setBaseFeePadding(value) {
+        this.baseFeePadding = value ?? 0.5;
+    }
+    async getAccountFromAddress(address) {
+        let account;
+        if (address.equals(AztecAddress.ZERO)) {
+            const chainInfo = await this.getChainInfo();
+            account = new SignerlessAccount(chainInfo);
+        } else {
+            account = this.accounts.get(address?.toString() ?? '');
+        }
+        if (!account) {
+            throw new Error(`Account not found in wallet for address: ${address}`);
+        }
+        return account;
+    }
+    getAccounts() {
+        return Promise.resolve(Array.from(this.accounts.values()).map((acc)=>({
+                alias: '',
+                item: acc.getAddress()
+            })));
+    }
+    /**
+   * Creates a new account with the provided account data or generates random values and uses SchnorrAccountContract
+   * if not provided.
+   *
+   * @param accountData - Optional account configuration containing secret, salt and account contract.
+   * @returns A new AccountManager instance for the created account
+   */ async createAccount(accountData) {
+        // Generate random values if not provided
+        const secret = accountData?.secret ?? Fr.random();
+        const salt = accountData?.salt ?? Fr.random();
+        // Use SchnorrAccountContract if not provided
+        const contract = accountData?.contract ?? new SchnorrAccountContract(GrumpkinScalar.random());
+        const accountManager = await AccountManager.create(this, secret, contract, salt);
+        const instance = accountManager.getInstance();
+        const artifact = await contract.getContractArtifact();
+        await this.registerContract(instance, artifact, secret);
+        this.accounts.set(accountManager.address.toString(), await accountManager.getAccount());
+        return accountManager;
+    }
+    /**
+   * Lookup the validity of an authwit in private and public contexts.
+   *
+   * Uses the chain id and version of the wallet.
+   *
+   * @param wallet - The wallet use to simulate and read the public data
+   * @param onBehalfOf - The address of the "approver"
+   * @param intent - The consumer and inner hash or the caller and action to lookup
+   * @param witness - The computed authentication witness to check
+   * @returns - A struct containing the validity of the authwit in private and public contexts.
+   */ lookupValidity(onBehalfOf, intent, witness) {
+        return lookupValidity(this, onBehalfOf, intent, witness);
+    }
+    /**
+   * Returns an interaction that can be used to set the authorization status
+   * of an intent
+   * @param from - The address authorizing/revoking the action
+   * @param messageHashOrIntent - The action to authorize/revoke
+   * @param authorized - Whether the action can be performed or not
+   */ setPublicAuthWit(from, messageHashOrIntent, authorized) {
+        return SetPublicAuthwitContractInteraction.create(this, from, messageHashOrIntent, authorized);
+    }
+    /**
+   * Creates and returns an authwit according the the rules
+   * of the provided account. This authwit can be verified
+   * by the account contract
+   * @param from - The address authorizing the action
+   * @param messageHashOrIntent - The action to authorize
+   */ async createAuthWit(from, messageHashOrIntent) {
+        const account = await this.getAccountFromAddress(from);
+        const chainInfo = await this.getChainInfo();
+        const messageHash = await getMessageHashFromIntent(messageHashOrIntent, chainInfo);
+        return account.createAuthWit(messageHash);
+    }
+    async simulateTx(executionPayload, opts) {
+        if (!this.simulatedSimulations) {
+            return super.simulateTx(executionPayload, opts);
+        } else {
+            const feeOptions = opts.fee?.estimateGas ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee) : await this.getDefaultFeeOptions(opts.from, opts.fee);
+            const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+            const executionOptions = {
+                txNonce: Fr.random(),
+                cancellable: this.cancellableTransactions,
+                feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+            };
+            const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+                feeExecutionPayload,
+                executionPayload
+            ]) : executionPayload;
+            const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(opts.from);
+            const txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, executionOptions);
+            const contractOverrides = {
+                [opts.from.toString()]: {
+                    instance,
+                    artifact
+                }
+            };
+            return this.pxe.simulateTx(txRequest, true, true, true, {
+                contracts: contractOverrides
+            });
+        }
+    }
+    /**
+   * A utility to prove a transaction using this wallet and return it to be sent by a different entity on their own accord
+   *
+   * Note that this should not be used in production code since a proven transaction could be sent to a malicious
+   * node to index and track. It also makes it very difficult for the wallet to keep track of the interaction.
+   * @param exec - The execution payload to prove.
+   * @param opts - The options to configure the interaction
+   * @returns - A proven tx ready to be sent to the network
+   */ async proveTx(exec, opts) {
+        const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(exec, opts.from, fee);
+        const txProvingResult = await this.pxe.proveTx(txRequest);
+        return new ProvenTx(this.aztecNode, await txProvingResult.toTx(), txProvingResult.getOffchainEffects(), txProvingResult.stats);
+    }
+    /**
+   * A debugging utility to get notes based on the provided filter.
+   *
+   * Note that this should not be used in production code because the structure of notes is considered to be
+   * an implementation detail of contracts. This is only meant to be used for debugging purposes. If you need to obtain
+   * note-related information in production code, please implement a custom utility function on your contract and call
+   * that function instead (e.g. `get_balance(owner: AztecAddress) -> u128` utility function on a Token contract).
+   *
+   * @param filter - The filter to apply to the notes.
+   * @returns The requested notes.
+   */ getNotes(filter) {
+        return this.pxe.getNotes(filter);
+    }
+    /**
+   * Stops the internal job queue.
+   *
+   * This function is typically used when tearing down tests.
+   */ stop() {
+        return this.pxe.stop();
+    }
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@aztec/test-wallet",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/test-wallet",
+  "version": "3.0.0-devnet.2",
+  "type": "module",
+  "exports": {
+    "./client/bundle": "./dest/bundle.js",
+    "./client/lazy": "./dest/lazy.js",
+    "./server": "./dest/server.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "build:ts": "tsc -b",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/accounts": "3.0.0-devnet.2",
+    "@aztec/aztec.js": "3.0.0-devnet.2",
+    "@aztec/entrypoints": "3.0.0-devnet.2",
+    "@aztec/foundation": "3.0.0-devnet.2",
+    "@aztec/noir-contracts.js": "3.0.0-devnet.2",
+    "@aztec/pxe": "3.0.0-devnet.2",
+    "@aztec/stdlib": "3.0.0-devnet.2"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "jest": "^30.0.0",
+    "resolve-typescript-plugin": "^2.0.1",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3",
+    "util": "^0.12.5"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*",
+    "artifacts"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,8 @@
+export { TestWallet } from './wallet/bundle.js';
+export { type AccountData } from './wallet/test_wallet.js';
+export {
+  deployFundedSchnorrAccounts,
+  registerInitialSandboxAccountsInWallet,
+  ProvenTx,
+  proveInteraction,
+} from './utils.js';

package/src/lazy.ts

@@ -0,0 +1,8 @@
+export { TestWallet } from './wallet/lazy.js';
+export { type AccountData } from './wallet/test_wallet.js';
+export {
+  deployFundedSchnorrAccounts,
+  registerInitialSandboxAccountsInWallet,
+  ProvenTx,
+  proveInteraction,
+} from './utils.js';

package/src/server.ts

@@ -0,0 +1,8 @@
+export { TestWallet } from './wallet/server.js';
+export { type AccountData } from './wallet/test_wallet.js';
+export {
+  deployFundedSchnorrAccounts,
+  registerInitialSandboxAccountsInWallet,
+  ProvenTx,
+  proveInteraction,
+} from './utils.js';

package/src/utils.ts

@@ -0,0 +1,101 @@
+import type { InitialAccountData } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing/lazy';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import {
+  ContractFunctionInteraction,
+  DeployMethod,
+  type DeployOptions,
+  type SendInteractionOptions,
+  SentTx,
+  type WaitOpts,
+  toSendOptions,
+} from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { type OffchainEffect, type ProvingStats, Tx } from '@aztec/stdlib/tx';
+
+import type { BaseTestWallet } from './wallet/test_wallet.js';
+
+/**
+ * Deploys the SchnorrAccount contracts backed by prefunded addresses
+ * at genesis. This can be directly used to pay for transactions in FeeJuice.
+ */
+export async function deployFundedSchnorrAccounts(
+  wallet: BaseTestWallet,
+  aztecNode: AztecNode,
+  accountsData: InitialAccountData[],
+  waitOptions?: WaitOpts,
+) {
+  const accountManagers = [];
+  // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
+  for (let i = 0; i < accountsData.length; i++) {
+    const { secret, salt, signingKey } = accountsData[i];
+    const accountManager = await wallet.createSchnorrAccount(secret, salt, signingKey);
+    const deployMethod = await accountManager.getDeployMethod();
+    await deployMethod
+      .send({
+        from: AztecAddress.ZERO,
+        skipClassPublication: i !== 0, // Publish the contract class at most once.
+      })
+      .wait(waitOptions);
+    accountManagers.push(accountManager);
+  }
+  return accountManagers;
+}
+
+/**
+ * Registers the initial sandbox accounts in the wallet.
+ * @param wallet - Test wallet to use to register the accounts.
+ * @returns Addresses of the registered accounts.
+ */
+export async function registerInitialSandboxAccountsInWallet(wallet: BaseTestWallet): Promise<AztecAddress[]> {
+  const testAccounts = await getInitialTestAccountsData();
+  return Promise.all(
+    testAccounts.map(async account => {
+      return (await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey)).address;
+    }),
+  );
+}
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of the test wallet
+ */
+export class ProvenTx extends Tx {
+  constructor(
+    private node: AztecNode,
+    tx: Tx,
+    /** The offchain effects emitted during the execution of the transaction. */
+    public offchainEffects: OffchainEffect[],
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    public stats?: ProvingStats,
+  ) {
+    super(tx.getTxHash(), tx.data, tx.clientIvcProof, tx.contractClassLogFields, tx.publicFunctionCalldata);
+  }
+
+  send() {
+    const sendTx = async () => {
+      await this.node.sendTx(this);
+      return this.getTxHash();
+    };
+    return new SentTx(this.node, sendTx);
+  }
+}
+
+/**
+ * Helper function to prove an interaction via a TestWallet
+ * @param wallet - The TestWallet to use
+ * @param interaction - The interaction to prove
+ * @param options - Either SendInteractionOptions (for ContractFunctionInteraction) or DeployOptions (for DeployMethod)
+ * @returns - A proven transaction ready do be sent to the network
+ */
+export async function proveInteraction(
+  wallet: BaseTestWallet,
+  interaction: ContractFunctionInteraction | DeployMethod,
+  options: SendInteractionOptions | DeployOptions,
+) {
+  let execPayload;
+  if (interaction instanceof DeployMethod) {
+    execPayload = await interaction.request(interaction.convertDeployOptionsToRequestOptions(options));
+  } else {
+    execPayload = await interaction.request(options);
+  }
+  return wallet.proveTx(execPayload, await toSendOptions(options));
+}

package/src/wallet/bundle.ts

@@ -0,0 +1,79 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fq, Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { type PXEConfig, type PXECreationOptions, createPXE, getPXEConfig } from '@aztec/pxe/client/bundle';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { BaseTestWallet } from './test_wallet.js';
+
+/**
+ * A TestWallet implementation that loads the account contract artifacts eagerly
+ * Note that the only difference from `lazy` and `server` test wallets is that it uses the `createPXE` function
+ * from the `pxe/client/bundle` package.
+ */
+export class TestWallet extends BaseTestWallet {
+  static async create(
+    node: AztecNode,
+    overridePXEConfig?: Partial<PXEConfig>,
+    options: PXECreationOptions = { loggers: {} },
+  ): Promise<TestWallet> {
+    const pxeConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: overridePXEConfig?.proverEnabled ?? false,
+      ...overridePXEConfig,
+    });
+    const pxe = await createPXE(node, pxeConfig, options);
+    return new TestWallet(pxe, node);
+  }
+
+  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);
+  }
+
+  createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaRAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaKAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  async getFakeAccountDataFor(address: AztecAddress) {
+    const chainInfo = await this.getChainInfo();
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const { contractInstance } = await this.pxe.getContractMetadata(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress, chainInfo);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+}

package/src/wallet/lazy.ts

@@ -0,0 +1,80 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa/lazy';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr/lazy';
+import { createStubAccount, getStubAccountContractArtifact } from '@aztec/accounts/stub/lazy';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fq, Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { type PXEConfig, type PXECreationOptions, createPXE, getPXEConfig } from '@aztec/pxe/client/lazy';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { BaseTestWallet } from './test_wallet.js';
+
+/**
+ * A TestWallet implementation that loads the account contract artifacts lazily
+ * Note that the only difference from `server` and `bundle` test wallets is that it uses the `createPXE` function
+ * from the `pxe/client/lazy` package.
+ */
+export class TestWallet extends BaseTestWallet {
+  static async create(
+    node: AztecNode,
+    overridePXEConfig?: Partial<PXEConfig>,
+    options: PXECreationOptions = { loggers: {} },
+  ): Promise<TestWallet> {
+    const pxeConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: overridePXEConfig?.proverEnabled ?? false,
+      ...overridePXEConfig,
+    });
+    const pxe = await createPXE(node, pxeConfig, options);
+    return new TestWallet(pxe, node);
+  }
+
+  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);
+  }
+
+  createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaRAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaKAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  async getFakeAccountDataFor(address: AztecAddress) {
+    const chainInfo = await this.getChainInfo();
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const { contractInstance } = await this.pxe.getContractMetadata(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress, chainInfo);
+    const StubAccountContractArtifact = await getStubAccountContractArtifact();
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+}

package/src/wallet/server.ts

@@ -0,0 +1,79 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fq, Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { type PXEConfig, type PXECreationOptions, createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { BaseTestWallet } from './test_wallet.js';
+
+/**
+ * A TestWallet implementation to be used in server settings (e.g. e2e tests).
+ * Note that the only difference from `lazy` and `bundle` test wallets is that it uses the `createPXE` function
+ * from the `pxe/server` package.
+ */
+export class TestWallet extends BaseTestWallet {
+  static async create(
+    node: AztecNode,
+    overridePXEConfig?: Partial<PXEConfig>,
+    options: PXECreationOptions = { loggers: {} },
+  ): Promise<TestWallet> {
+    const pxeConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: overridePXEConfig?.proverEnabled ?? false,
+      ...overridePXEConfig,
+    });
+    const pxe = await createPXE(node, pxeConfig, options);
+    return new TestWallet(pxe, node);
+  }
+
+  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);
+  }
+
+  createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaRAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaKAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  async getFakeAccountDataFor(address: AztecAddress) {
+    const chainInfo = await this.getChainInfo();
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const { contractInstance } = await this.pxe.getContractMetadata(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress, chainInfo);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+}