@aztec/test-wallet 0.0.1-commit.0208eb9

package/dest/wallet/test_wallet.d.ts

@@ -0,0 +1,163 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { type Account, type AccountContract } from '@aztec/aztec.js/account';
+import { type CallIntent, type ContractFunctionInteractionCallIntent, type IntentInnerHash, SetPublicAuthwitContractInteraction } from '@aztec/aztec.js/authorization';
+import { AccountManager, type SendOptions, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { NoteDao, NotesFilter } from '@aztec/stdlib/note';
+import type { BlockHeader, TxHash, TxReceipt, TxSimulationResult } from '@aztec/stdlib/tx';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+import { ProvenTx } from '../utils.js';
+/**
+ * Data for generating an account.
+ */
+export interface AccountData {
+    /**
+     * Secret to derive the keys for the account.
+     */
+    secret: Fr;
+    /**
+     * Contract address salt.
+     */
+    salt: Fr;
+    /**
+     * Contract that backs the account.
+     */
+    contract: AccountContract;
+}
+/**
+ * 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 declare abstract class BaseTestWallet extends BaseWallet {
+    protected accounts: Map<string, Account>;
+    /**
+     * 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.
+     */
+    private simulatedSimulations;
+    /** Enable the "simulated simulation" path for simulateTx. */
+    enableSimulatedSimulations(): void;
+    /** Disable the "simulated simulation" path for simulateTx. */
+    disableSimulatedSimulations(): void;
+    setMinFeePadding(value?: number): void;
+    protected getAccountFromAddress(address: AztecAddress): Promise<Account>;
+    getAccounts(): Promise<{
+        alias: string;
+        item: AztecAddress;
+    }[]>;
+    /**
+     * 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
+     */
+    createAccount(accountData?: AccountData): Promise<AccountManager>;
+    abstract createSchnorrAccount(secret: Fr, salt: Fr, signingKey?: Fq): Promise<AccountManager>;
+    abstract createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager>;
+    abstract createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<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: AztecAddress, intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, witness: AuthWitness): Promise<{
+        /** boolean flag indicating if the authwit is valid in private context */
+        isValidInPrivate: boolean;
+        /** boolean flag indicating if the authwit is valid in public context */
+        isValidInPublic: boolean;
+    }>;
+    /**
+     * 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: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, authorized: boolean): Promise<SetPublicAuthwitContractInteraction>;
+    /**
+     * 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 intent - The action to authorize
+     */
+    createAuthWit(from: AztecAddress, intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent): Promise<AuthWitness>;
+    /**
+     * Creates a stub account that impersonates the given address, allowing kernelless simulations
+     * to bypass the account's authorization mechanisms via contract overrides.
+     * @param address - The address of the account to impersonate
+     * @returns The stub account, contract instance, and artifact for simulation
+     */
+    abstract getFakeAccountDataFor(address: AztecAddress): Promise<{
+        account: Account;
+        instance: ContractInstanceWithAddress;
+        artifact: ContractArtifact;
+    }>;
+    simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
+    /**
+     * 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
+     */
+    proveTx(exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>): Promise<ProvenTx>;
+    /**
+     * Retrieves the transaction receipt for a given transaction hash.
+     * This is a passthrough to the underlying node, provided for convenience in testing.
+     * @param txHash - The hash of the transaction.
+     * @returns The transaction receipt.
+     */
+    getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
+    /**
+     * 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: NotesFilter): Promise<NoteDao[]>;
+    /** Returns the block header up to which the wallet has synced. */
+    getSyncedBlockHeader(): Promise<BlockHeader>;
+    /**
+     * Triggers a sync of the wallet with the node to update the latest block header.
+     * Blocks until the sync is complete.
+     */
+    sync(): Promise<void>;
+    /**
+     * Stops the internal job queue.
+     *
+     * This function is typically used when tearing down tests.
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/wallet/test_wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_wallet.d.ts","sourceRoot":"","sources":["../../src/wallet/test_wallet.ts"],"names":[],"mappings":"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"}

package/dest/wallet/test_wallet.js

@@ -0,0 +1,202 @@
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { SignerlessAccount } from '@aztec/aztec.js/account';
+import { SetPublicAuthwitContractInteraction, computeInnerAuthWitHashFromAction, isContractFunctionInteractionCallIntent, lookupValidity } from '@aztec/aztec.js/authorization';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+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;
+    }
+    setMinFeePadding(value) {
+        this.minFeePadding = value ?? 0.5;
+    }
+    getAccountFromAddress(address) {
+        let account;
+        if (address.equals(AztecAddress.ZERO)) {
+            account = new SignerlessAccount();
+        } else {
+            account = this.accounts.get(address?.toString() ?? '');
+        }
+        if (!account) {
+            throw new Error(`Account not found in wallet for address: ${address}`);
+        }
+        return Promise.resolve(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 intent - The action to authorize
+   */ async createAuthWit(from, intent) {
+        const account = await this.getAccountFromAddress(from);
+        const chainInfo = await this.getChainInfo();
+        let intentInnerHash;
+        if ('caller' in intent) {
+            const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+            const innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+            intentInnerHash = {
+                innerHash,
+                consumer: call.to
+            };
+        } else {
+            intentInnerHash = intent;
+        }
+        return account.createAuthWit(intentInnerHash, chainInfo);
+    }
+    async simulateTx(executionPayload, opts) {
+        if (!this.simulatedSimulations) {
+            return super.simulateTx(executionPayload, opts);
+        } else {
+            const feeOptions = opts.fee?.estimateGas ? await this.completeFeeOptionsForEstimation(opts.from, executionPayload.feePayer, opts.fee?.gasSettings) : await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+            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 chainInfo = await this.getChainInfo();
+            const txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, 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.completeFeeOptions(opts.from, exec.feePayer, opts.fee?.gasSettings);
+        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);
+    }
+    /**
+   * Retrieves the transaction receipt for a given transaction hash.
+   * This is a passthrough to the underlying node, provided for convenience in testing.
+   * @param txHash - The hash of the transaction.
+   * @returns The transaction receipt.
+   */ getTxReceipt(txHash) {
+        return this.aztecNode.getTxReceipt(txHash);
+    }
+    /**
+   * 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.debug.getNotes(filter);
+    }
+    /** Returns the block header up to which the wallet has synced. */ getSyncedBlockHeader() {
+        return this.pxe.debug.getSyncedBlockHeader();
+    }
+    /**
+   * Triggers a sync of the wallet with the node to update the latest block header.
+   * Blocks until the sync is complete.
+   */ sync() {
+        return this.pxe.debug.sync();
+    }
+    /**
+   * 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,97 @@
+{
+  "name": "@aztec/test-wallet",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/test-wallet",
+  "version": "0.0.1-commit.0208eb9",
+  "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 && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "build:ts": "../scripts/tsc.sh",
+    "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": "0.0.1-commit.0208eb9",
+    "@aztec/aztec.js": "0.0.1-commit.0208eb9",
+    "@aztec/entrypoints": "0.0.1-commit.0208eb9",
+    "@aztec/foundation": "0.0.1-commit.0208eb9",
+    "@aztec/noir-contracts.js": "0.0.1-commit.0208eb9",
+    "@aztec/pxe": "0.0.1-commit.0208eb9",
+    "@aztec/stdlib": "0.0.1-commit.0208eb9",
+    "@aztec/wallet-sdk": "0.0.1-commit.0208eb9"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.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,
+  registerInitialLocalNetworkAccountsInWallet,
+  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,
+  registerInitialLocalNetworkAccountsInWallet,
+  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,
+  registerInitialLocalNetworkAccountsInWallet,
+  ProvenTx,
+  proveInteraction,
+} from './utils.js';

package/src/utils.ts

@@ -0,0 +1,146 @@
+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,
+  NO_WAIT,
+  type NoWait,
+  type SendInteractionOptions,
+  type WaitOpts,
+  toSendOptions,
+} from '@aztec/aztec.js/contracts';
+import { type AztecNode, waitForTx } from '@aztec/aztec.js/node';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { type OffchainEffect, type ProvingStats, Tx, TxHash, type TxReceipt } from '@aztec/stdlib/tx';
+
+import { inspect } from 'util';
+
+import type { BaseTestWallet } from './wallet/test_wallet.js';
+
+/**
+ * Options for sending a proven transaction.
+ */
+export type ProvenTxSendOpts = {
+  /**
+   * Whether to wait for the transaction to be mined.
+   * - undefined (default): wait with default options and return TxReceipt
+   * - WaitOpts object: wait with custom options and return TxReceipt
+   * - NO_WAIT: return txHash immediately without waiting
+   */
+  wait?: NoWait | WaitOpts;
+};
+
+/**
+ * Return type for ProvenTx.send based on wait option.
+ */
+export type ProvenTxSendReturn<T extends NoWait | WaitOpts | undefined> = T extends NoWait ? TxHash : TxReceipt;
+
+/**
+ * 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,
+  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 local network accounts in the wallet.
+ * @param wallet - Test wallet to use to register the accounts.
+ * @returns Addresses of the registered accounts.
+ */
+export async function registerInitialLocalNetworkAccountsInWallet(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.chonkProof, tx.contractClassLogFields, tx.publicFunctionCalldata);
+  }
+
+  /**
+   * Sends the transaction to the network.
+   * @param options - Send options including whether to wait.
+   * @returns The transaction receipt if waiting, or the transaction hash if not.
+   */
+  send(options?: Omit<ProvenTxSendOpts, 'wait'>): Promise<TxReceipt>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  send<W extends ProvenTxSendOpts['wait']>(options: ProvenTxSendOpts & { wait: W }): Promise<ProvenTxSendReturn<W>>;
+  async send(options?: ProvenTxSendOpts): Promise<TxHash | TxReceipt> {
+    const txHash = this.getTxHash();
+    await this.node.sendTx(this).catch(err => {
+      throw this.contextualizeError(err, inspect(this));
+    });
+
+    if (options?.wait === NO_WAIT) {
+      return txHash;
+    }
+
+    const waitOpts = typeof options?.wait === 'object' ? options.wait : undefined;
+    return await waitForTx(this.node, txHash, waitOpts);
+  }
+
+  private contextualizeError(err: Error, ...context: string[]): Error {
+    let contextStr = '';
+    if (context.length > 0) {
+      contextStr = `\nContext:\n${context.join('\n')}`;
+    }
+    if (err instanceof SimulationError) {
+      err.setAztecContext(contextStr);
+    }
+    return err;
+  }
+}
+
+/**
+ * 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, toSendOptions(options));
+}