@aztec/wallets 0.0.1-commit.033589e

package/dest/embedded/wallet_db.js

@@ -0,0 +1,120 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export const AccountTypes = [
+    'schnorr',
+    'ecdsasecp256r1',
+    'ecdsasecp256k1'
+];
+function accountKey(field, address) {
+    return `${field}:${address.toString()}`;
+}
+export class WalletDB {
+    accounts;
+    aliases;
+    userLog;
+    constructor(accounts, aliases, userLog){
+        this.accounts = accounts;
+        this.aliases = aliases;
+        this.userLog = userLog;
+    }
+    static init(store, userLog) {
+        const accounts = store.openMap('accounts');
+        const aliases = store.openMap('aliases');
+        return new WalletDB(accounts, aliases, userLog);
+    }
+    async storeAccount(address, { type, secretKey, salt, alias, signingKey }, log = this.userLog) {
+        if (alias) {
+            await this.aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+        }
+        await this.accounts.set(accountKey('type', address), Buffer.from(type));
+        await this.accounts.set(accountKey('sk', address), secretKey.toBuffer());
+        await this.accounts.set(accountKey('salt', address), salt.toBuffer());
+        await this.accounts.set(accountKey('signingKey', address), 'toBuffer' in signingKey ? signingKey.toBuffer() : signingKey);
+        log(`Account stored in database${alias ? ` with alias ${alias}` : ''}`);
+    }
+    async storeSender(address, alias, log = this.userLog) {
+        await this.aliases.set(`senders:${alias}`, Buffer.from(address.toString()));
+        log(`Sender stored in database with alias ${alias}`);
+    }
+    async retrieveAccount(address) {
+        const secretKeyBuffer = await this.accounts.getAsync(accountKey('sk', address));
+        if (!secretKeyBuffer) {
+            throw new Error(`Account "${address.toString()}" does not exist on this wallet.`);
+        }
+        const [saltBuffer, typeBuffer, signingKey] = await Promise.all([
+            this.accounts.getAsync(accountKey('salt', address)),
+            this.accounts.getAsync(accountKey('type', address)),
+            this.accounts.getAsync(accountKey('signingKey', address))
+        ]);
+        const secretKey = Fr.fromBuffer(secretKeyBuffer);
+        const salt = Fr.fromBuffer(saltBuffer);
+        const type = typeBuffer.toString('utf8');
+        return {
+            address,
+            secretKey,
+            salt,
+            type,
+            signingKey: signingKey
+        };
+    }
+    async listAccounts() {
+        // Read aliases and account addresses in parallel using range queries
+        const [aliasesByAddress, accountAddresses] = await Promise.all([
+            this.#readAccountAliases(),
+            this.#readAccountAddresses()
+        ]);
+        return accountAddresses.map((addressStr)=>({
+                alias: aliasesByAddress.get(addressStr) ?? '',
+                item: AztecAddress.fromString(addressStr)
+            }));
+    }
+    async listSenders() {
+        const result = [];
+        for await (const [alias, item] of this.aliases.entriesAsync({
+            start: 'senders:',
+            end: 'senders:\uffff'
+        })){
+            result.push({
+                alias: alias.slice('senders:'.length),
+                item: AztecAddress.fromString(item.toString())
+            });
+        }
+        return result;
+    }
+    async #readAccountAliases() {
+        const aliasesByAddress = new Map();
+        for await (const [alias, item] of this.aliases.entriesAsync({
+            start: 'accounts:',
+            end: 'accounts:\uffff'
+        })){
+            const address = item.toString();
+            aliasesByAddress.set(address, alias.slice('accounts:'.length));
+        }
+        return aliasesByAddress;
+    }
+    async #readAccountAddresses() {
+        const addresses = [];
+        // Range query on 'type:' prefix — one entry per account, avoids scanning sk/salt/signingKey entries
+        for await (const [key] of this.accounts.entriesAsync({
+            start: 'type:',
+            end: 'type:\uffff'
+        })){
+            addresses.push(key.slice('type:'.length));
+        }
+        return addresses;
+    }
+    async deleteAccount(address) {
+        await Promise.all([
+            this.accounts.delete(accountKey('sk', address)),
+            this.accounts.delete(accountKey('salt', address)),
+            this.accounts.delete(accountKey('type', address)),
+            this.accounts.delete(accountKey('signingKey', address))
+        ]);
+        // Clean up alias if one exists
+        const aliasesByAddress = await this.#readAccountAliases();
+        const alias = aliasesByAddress.get(address.toString());
+        if (alias) {
+            await this.aliases.delete(`accounts:${alias}`);
+        }
+    }
+}

package/dest/testing.d.ts

@@ -0,0 +1,12 @@
+import type { InitialAccountData } from '@aztec/accounts/testing';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import type { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+interface WalletWithSchnorrAccounts {
+    createSchnorrAccount(secret: Fr, salt: Fr, signingKey?: Fq, alias?: string): Promise<AccountManager>;
+}
+export declare function deployFundedSchnorrAccounts(wallet: WalletWithSchnorrAccounts, accountsData: InitialAccountData[], waitOptions?: WaitOpts): Promise<AccountManager[]>;
+export declare function registerInitialLocalNetworkAccountsInWallet(wallet: WalletWithSchnorrAccounts): Promise<AztecAddress[]>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3Rlc3RpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVsRSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMxRCxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM3RCxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDN0QsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTNELFVBQVUseUJBQXlCO0lBQ2pDLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxVQUFVLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztDQUN0RztBQUVELHdCQUFzQiwyQkFBMkIsQ0FDL0MsTUFBTSxFQUFFLHlCQUF5QixFQUNqQyxZQUFZLEVBQUUsa0JBQWtCLEVBQUUsRUFDbEMsV0FBVyxDQUFDLEVBQUUsUUFBUSw2QkFnQnZCO0FBRUQsd0JBQXNCLDJDQUEyQyxDQUMvRCxNQUFNLEVBQUUseUJBQXlCLEdBQ2hDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQU96QiJ9

package/dest/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,UAAU,yBAAyB;IACjC,oBAAoB,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,UAAU,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtG;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,yBAAyB,EACjC,YAAY,EAAE,kBAAkB,EAAE,EAClC,WAAW,CAAC,EAAE,QAAQ,6BAgBvB;AAED,wBAAsB,2CAA2C,CAC/D,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,YAAY,EAAE,CAAC,CAOzB"}

package/dest/testing.js

@@ -0,0 +1,24 @@
+import { getInitialTestAccountsData } from '@aztec/accounts/testing/lazy';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export async function deployFundedSchnorrAccounts(wallet, accountsData, waitOptions) {
+    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,
+            wait: waitOptions
+        });
+        accountManagers.push(accountManager);
+    }
+    return accountManagers;
+}
+export async function registerInitialLocalNetworkAccountsInWallet(wallet) {
+    const testAccounts = await getInitialTestAccountsData();
+    return Promise.all(testAccounts.map(async (account)=>{
+        return (await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey)).address;
+    }));
+}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@aztec/wallets",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/wallets",
+  "version": "0.0.1-commit.033589e",
+  "type": "module",
+  "exports": {
+    "./embedded": {
+      "browser": {
+        "types": "./dest/embedded/entrypoints/browser.d.ts",
+        "default": "./dest/embedded/entrypoints/browser.js"
+      },
+      "default": {
+        "types": "./dest/embedded/entrypoints/node.d.ts",
+        "default": "./dest/embedded/entrypoints/node.js"
+      }
+    },
+    "./testing": "./dest/testing.js"
+  },
+  "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"
+  ],
+  "dependencies": {
+    "@aztec/accounts": "0.0.1-commit.033589e",
+    "@aztec/aztec.js": "0.0.1-commit.033589e",
+    "@aztec/entrypoints": "0.0.1-commit.033589e",
+    "@aztec/foundation": "0.0.1-commit.033589e",
+    "@aztec/kv-store": "0.0.1-commit.033589e",
+    "@aztec/protocol-contracts": "0.0.1-commit.033589e",
+    "@aztec/pxe": "0.0.1-commit.033589e",
+    "@aztec/stdlib": "0.0.1-commit.033589e",
+    "@aztec/wallet-sdk": "0.0.1-commit.033589e"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/embedded/entrypoints/node.ts",
+      "./src/testing.ts"
+    ],
+    "name": "Wallets",
+    "tsconfig": "./tsconfig.json"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "engines": {
+    "node": ">=20.10"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs"
+  }
+}

package/src/embedded/account-contract-providers/bundle.ts

@@ -0,0 +1,40 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import type { Account, AccountContract } from '@aztec/aztec.js/account';
+import type { Fq } from '@aztec/foundation/curves/bn254';
+import { getCanonicalMultiCallEntrypoint } from '@aztec/protocol-contracts/multi-call-entrypoint';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { CompleteAddress, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { AccountContractsProvider } from './types.js';
+
+/**
+ * Loads account contract artifacts eagerly via static imports.
+ * Designed for Node.js environments where all artifacts are available at startup.
+ */
+export class BundleAccountContractsProvider implements AccountContractsProvider {
+  getSchnorrAccountContract(signingKey: Fq): Promise<AccountContract> {
+    return Promise.resolve(new SchnorrAccountContract(signingKey));
+  }
+
+  getEcdsaRAccountContract(signingKey: Buffer): Promise<AccountContract> {
+    return Promise.resolve(new EcdsaRAccountContract(signingKey));
+  }
+
+  getEcdsaKAccountContract(signingKey: Buffer): Promise<AccountContract> {
+    return Promise.resolve(new EcdsaKAccountContract(signingKey));
+  }
+
+  getStubAccountContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(StubAccountContractArtifact);
+  }
+
+  createStubAccount(address: CompleteAddress): Promise<Account> {
+    return Promise.resolve(createStubAccount(address));
+  }
+
+  getMulticallContract(): Promise<{ instance: ContractInstanceWithAddress; artifact: ContractArtifact }> {
+    return getCanonicalMultiCallEntrypoint();
+  }
+}

package/src/embedded/account-contract-providers/lazy.ts

@@ -0,0 +1,42 @@
+import type { Account, AccountContract } from '@aztec/aztec.js/account';
+import type { Fq } from '@aztec/foundation/curves/bn254';
+import { getCanonicalMultiCallEntrypoint } from '@aztec/protocol-contracts/multi-call-entrypoint/lazy';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { CompleteAddress, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { AccountContractsProvider } from './types.js';
+
+/**
+ * Loads account contract artifacts lazily via dynamic imports.
+ * Designed for browser environments where code splitting reduces initial bundle size.
+ */
+export class LazyAccountContractsProvider implements AccountContractsProvider {
+  async getSchnorrAccountContract(signingKey: Fq): Promise<AccountContract> {
+    const { SchnorrAccountContract } = await import('@aztec/accounts/schnorr/lazy');
+    return new SchnorrAccountContract(signingKey);
+  }
+
+  async getEcdsaRAccountContract(signingKey: Buffer): Promise<AccountContract> {
+    const { EcdsaRAccountContract } = await import('@aztec/accounts/ecdsa/lazy');
+    return new EcdsaRAccountContract(signingKey);
+  }
+
+  async getEcdsaKAccountContract(signingKey: Buffer): Promise<AccountContract> {
+    const { EcdsaKAccountContract } = await import('@aztec/accounts/ecdsa/lazy');
+    return new EcdsaKAccountContract(signingKey);
+  }
+
+  async getStubAccountContractArtifact(): Promise<ContractArtifact> {
+    const { getStubAccountContractArtifact } = await import('@aztec/accounts/stub/lazy');
+    return getStubAccountContractArtifact();
+  }
+
+  async createStubAccount(address: CompleteAddress): Promise<Account> {
+    const { createStubAccount } = await import('@aztec/accounts/stub/lazy');
+    return createStubAccount(address);
+  }
+
+  getMulticallContract(): Promise<{ instance: ContractInstanceWithAddress; artifact: ContractArtifact }> {
+    return getCanonicalMultiCallEntrypoint();
+  }
+}

package/src/embedded/account-contract-providers/types.ts

@@ -0,0 +1,19 @@
+import type { Account, AccountContract } from '@aztec/aztec.js/account';
+import type { Fq } from '@aztec/foundation/curves/bn254';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { CompleteAddress, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+/**
+ * Provides account contract implementations and stub accounts for the EmbeddedWallet.
+ * Two implementations exist:
+ * - LazyAccountContractsProvider: uses dynamic imports for browser environments
+ * - EagerAccountContractsProvider: uses static imports for Node.js environments
+ */
+export interface AccountContractsProvider {
+  getSchnorrAccountContract(signingKey: Fq): Promise<AccountContract>;
+  getEcdsaRAccountContract(signingKey: Buffer): Promise<AccountContract>;
+  getEcdsaKAccountContract(signingKey: Buffer): Promise<AccountContract>;
+  getStubAccountContractArtifact(): Promise<ContractArtifact>;
+  getMulticallContract(): Promise<{ instance: ContractInstanceWithAddress; artifact: ContractArtifact }>;
+  createStubAccount(address: CompleteAddress): Promise<Account>;
+}

package/src/embedded/embedded_wallet.ts

@@ -0,0 +1,227 @@
+import { type Account, SignerlessAccount } from '@aztec/aztec.js/account';
+import type { Aliased } from '@aztec/aztec.js/wallet';
+import { AccountManager } from '@aztec/aztec.js/wallet';
+import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { Logger } from '@aztec/foundation/log';
+import type { AccessScopes, PXEConfig, PXECreationOptions } from '@aztec/pxe/client/lazy';
+import type { PXE } from '@aztec/pxe/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { ExecutionPayload, type TxSimulationResult, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet, type FeeOptions } from '@aztec/wallet-sdk/base-wallet';
+
+import type { AccountContractsProvider } from './account-contract-providers/types.js';
+import { type AccountType, WalletDB } from './wallet_db.js';
+
+export type EmbeddedWalletOptions = {
+  /** Parent logger. Child loggers are derived via createChild() for each subsystem. */
+  logger?: Logger;
+  /** Use ephemeral (in-memory) stores. Data will not persist across sessions. */
+  ephemeral?: boolean;
+  /** Override PXE configuration. */
+  pxeConfig?: Partial<PXEConfig>;
+  /** Advanced PXE creation options (custom store, prover, simulator). */
+  pxeOptions?: PXECreationOptions;
+};
+
+export class EmbeddedWallet extends BaseWallet {
+  constructor(
+    pxe: PXE,
+    aztecNode: AztecNode,
+    protected walletDB: WalletDB,
+    protected accountContracts: AccountContractsProvider,
+    log?: Logger,
+  ) {
+    super(pxe, aztecNode, log);
+  }
+
+  protected async getAccountFromAddress(address: AztecAddress): Promise<Account> {
+    if (address.equals(AztecAddress.ZERO)) {
+      return new SignerlessAccount();
+    }
+
+    const { secretKey, salt, signingKey, type } = await this.walletDB.retrieveAccount(address);
+    const accountManager = await this.createAccountInternal(type, secretKey, salt, signingKey);
+    const account = await accountManager.getAccount();
+
+    if (!account) {
+      throw new Error(`Account not found in wallet for address: ${address}`);
+    }
+
+    return account;
+  }
+
+  getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    return this.walletDB.listAccounts();
+  }
+
+  override async registerSender(address: AztecAddress, alias: string) {
+    await this.walletDB.storeSender(address, alias);
+    return this.pxe.registerSender(address);
+  }
+
+  override async getAddressBook(): Promise<Aliased<AztecAddress>[]> {
+    const senders = await this.pxe.getSenders();
+    const storedSenders = await this.walletDB.listSenders();
+    for (const storedSender of storedSenders) {
+      if (senders.findIndex(sender => sender.equals(storedSender.item)) === -1) {
+        await this.pxe.registerSender(storedSender.item);
+      }
+    }
+    return storedSenders;
+  }
+
+  /**
+   * Simulates calls via a stub account entrypoint, bypassing real account authorization.
+   * This allows kernelless simulation with contract overrides, skipping expensive
+   * private kernel circuit execution.
+   */
+  protected override async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    from: AztecAddress,
+    feeOptions: FeeOptions,
+    scopes: AccessScopes,
+    _skipTxValidation?: boolean,
+    _skipFeeEnforcement?: boolean,
+  ): Promise<TxSimulationResult> {
+    const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(from);
+
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce: Fr.random(),
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+    const chainInfo = await this.getChainInfo();
+    const txRequest = await fromAccount.createTxExecutionRequest(
+      finalExecutionPayload,
+      feeOptions.gasSettings,
+      chainInfo,
+      executionOptions,
+    );
+    return this.pxe.simulateTx(txRequest, {
+      simulatePublic: true,
+      skipFeeEnforcement: true,
+      skipTxValidation: true,
+      overrides: {
+        contracts: { [from.toString()]: { instance, artifact } },
+      },
+      scopes,
+    });
+  }
+
+  private async getFakeAccountDataFor(address: AztecAddress) {
+    // While we have the convention of "Zero address means no auth", and also
+    // we don't have a way to trigger kernelless simulations without overrides,
+    // we need to explicitly handle the zero address case here by
+    // returning the actual multicall contract instead of trying to create a stub account for it.
+    if (!address.equals(AztecAddress.ZERO)) {
+      const originalAccount = await this.getAccountFromAddress(address);
+      if (originalAccount instanceof SignerlessAccount) {
+        throw new Error(`Cannot create fake account data for SignerlessAccount at address: ${address}`);
+      }
+      const originalAddress = (originalAccount as Account).getCompleteAddress();
+      const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
+      if (!contractInstance) {
+        throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+      }
+      const stubAccount = await this.accountContracts.createStubAccount(originalAddress);
+      const stubArtifact = await this.accountContracts.getStubAccountContractArtifact();
+      const instance = await getContractInstanceFromInstantiationParams(stubArtifact, {
+        salt: Fr.random(),
+      });
+      return {
+        account: stubAccount,
+        instance,
+        artifact: stubArtifact,
+      };
+    } else {
+      const { instance, artifact } = await this.accountContracts.getMulticallContract();
+      const account = new SignerlessAccount();
+      return {
+        instance,
+        account,
+        artifact,
+      };
+    }
+  }
+
+  protected async createAccountInternal(
+    type: AccountType,
+    secret: Fr,
+    salt: Fr,
+    signingKey: Buffer,
+  ): Promise<AccountManager> {
+    let contract;
+    switch (type) {
+      case 'schnorr': {
+        contract = await this.accountContracts.getSchnorrAccountContract(Fq.fromBuffer(signingKey));
+        break;
+      }
+      case 'ecdsasecp256k1': {
+        contract = await this.accountContracts.getEcdsaKAccountContract(signingKey);
+        break;
+      }
+      case 'ecdsasecp256r1': {
+        contract = await this.accountContracts.getEcdsaRAccountContract(signingKey);
+        break;
+      }
+      default: {
+        throw new Error(`Unknown account type ${type}`);
+      }
+    }
+
+    const accountManager = await AccountManager.create(this, secret, contract, salt);
+
+    const instance = accountManager.getInstance();
+    const existingInstance = await this.pxe.getContractInstance(instance.address);
+    if (!existingInstance) {
+      const existingArtifact = await this.pxe.getContractArtifact(instance.currentContractClassId);
+      await this.registerContract(
+        instance,
+        !existingArtifact ? await accountManager.getAccountContract().getContractArtifact() : undefined,
+        accountManager.getSecretKey(),
+      );
+    }
+    return accountManager;
+  }
+
+  async createAndStoreAccount(
+    alias: string,
+    type: AccountType,
+    secret: Fr,
+    salt: Fr,
+    signingKey: Buffer,
+  ): Promise<AccountManager> {
+    const accountManager = await this.createAccountInternal(type, secret, salt, signingKey);
+    await this.walletDB.storeAccount(accountManager.address, { type, secretKey: secret, salt, alias, signingKey });
+    return accountManager;
+  }
+
+  createSchnorrAccount(secret: Fr, salt: Fr, signingKey?: Fq, alias?: string): Promise<AccountManager> {
+    const sk = signingKey ?? deriveSigningKey(secret);
+    return this.createAndStoreAccount(alias ?? '', 'schnorr', secret, salt, sk.toBuffer());
+  }
+
+  createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer, alias?: string): Promise<AccountManager> {
+    return this.createAndStoreAccount(alias ?? '', 'ecdsasecp256r1', secret, salt, signingKey);
+  }
+
+  createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer, alias?: string): Promise<AccountManager> {
+    return this.createAndStoreAccount(alias ?? '', 'ecdsasecp256k1', secret, salt, signingKey);
+  }
+
+  setMinFeePadding(value?: number) {
+    this.minFeePadding = value ?? 0.5;
+  }
+
+  stop() {
+    return this.pxe.stop();
+  }
+}

package/src/embedded/entrypoints/browser.ts

@@ -0,0 +1,72 @@
+import { type AztecNode, createAztecNodeClient } from '@aztec/aztec.js/node';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { createStore, openTmpStore } from '@aztec/kv-store/indexeddb';
+import { type PXE, type PXECreationOptions, createPXE } from '@aztec/pxe/client/lazy';
+import { type PXEConfig, getPXEConfig } from '@aztec/pxe/config';
+
+import { LazyAccountContractsProvider } from '../account-contract-providers/lazy.js';
+import type { AccountContractsProvider } from '../account-contract-providers/types.js';
+import { EmbeddedWallet, type EmbeddedWalletOptions } from '../embedded_wallet.js';
+import { WalletDB } from '../wallet_db.js';
+
+export class BrowserEmbeddedWallet extends EmbeddedWallet {
+  static async create<T extends BrowserEmbeddedWallet = BrowserEmbeddedWallet>(
+    this: new (
+      pxe: PXE,
+      aztecNode: AztecNode,
+      walletDB: WalletDB,
+      accountContracts: AccountContractsProvider,
+      log?: Logger,
+    ) => T,
+    nodeOrUrl: string | AztecNode,
+    options: EmbeddedWalletOptions = {},
+  ): Promise<T> {
+    const rootLogger = options.logger ?? createLogger('embedded-wallet');
+
+    const aztecNode = typeof nodeOrUrl === 'string' ? createAztecNodeClient(nodeOrUrl) : nodeOrUrl;
+    const l1Contracts = await aztecNode.getL1ContractAddresses();
+
+    const pxeConfig: PXEConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: options.pxeConfig?.proverEnabled ?? false,
+      dataDirectory: `pxe_data_${l1Contracts.rollupAddress}`,
+      ...options.pxeConfig,
+    });
+
+    if (options.ephemeral) {
+      delete pxeConfig.dataDirectory;
+    }
+
+    const pxeOptions: PXECreationOptions = {
+      ...options.pxeOptions,
+      loggers: {
+        store: rootLogger.createChild('pxe:data'),
+        pxe: rootLogger.createChild('pxe:service'),
+        prover: rootLogger.createChild('pxe:prover'),
+        ...options.pxeOptions?.loggers,
+      },
+    };
+
+    const pxe = await createPXE(aztecNode, pxeConfig, pxeOptions);
+
+    const walletDBStore = options.ephemeral
+      ? await openTmpStore(true)
+      : await createStore(
+          'wallet_data',
+          {
+            dataDirectory: `wallet_data_${l1Contracts.rollupAddress}`,
+            dataStoreMapSizeKb: pxeConfig.dataStoreMapSizeKb,
+            l1Contracts,
+          },
+          1,
+          rootLogger.createChild('wallet:data'),
+        );
+    const walletDB = WalletDB.init(walletDBStore, rootLogger.createChild('wallet:db').info);
+
+    return new this(pxe, aztecNode, walletDB, new LazyAccountContractsProvider(), rootLogger) as T;
+  }
+}
+
+export { BrowserEmbeddedWallet as EmbeddedWallet };
+export type { EmbeddedWalletOptions } from '../embedded_wallet.js';
+export { WalletDB } from '../wallet_db.js';
+export type { AccountType } from '../wallet_db.js';