@aztec/wallets 0.0.1-commit.4d79d1f2d

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,91 @@
+{
+  "name": "@aztec/wallets",
+  "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/wallets",
+  "version": "0.0.1-commit.4d79d1f2d",
+  "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.4d79d1f2d",
+    "@aztec/aztec.js": "0.0.1-commit.4d79d1f2d",
+    "@aztec/entrypoints": "0.0.1-commit.4d79d1f2d",
+    "@aztec/foundation": "0.0.1-commit.4d79d1f2d",
+    "@aztec/kv-store": "0.0.1-commit.4d79d1f2d",
+    "@aztec/pxe": "0.0.1-commit.4d79d1f2d",
+    "@aztec/stdlib": "0.0.1-commit.4d79d1f2d",
+    "@aztec/wallet-sdk": "0.0.1-commit.4d79d1f2d"
+  },
+  "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"
+  },
+  "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,35 @@
+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 type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { CompleteAddress } 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));
+  }
+}

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

@@ -0,0 +1,37 @@
+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 } 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);
+  }
+}

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

@@ -0,0 +1,18 @@
+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 } 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>;
+  createStubAccount(address: CompleteAddress): Promise<Account>;
+}

package/src/embedded/embedded_wallet.ts

@@ -0,0 +1,203 @@
+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 { 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;
+};
+
+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,
+    _skipTxValidation?: boolean,
+    _skipFeeEnforcement?: boolean,
+    scopes?: AztecAddress[],
+  ): 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) {
+    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,
+    };
+  }
+
+  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 artifact = await accountManager.getAccountContract().getContractArtifact();
+
+    await this.registerContract(instance, artifact, 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/embedded_wallet_browser.ts

@@ -0,0 +1,40 @@
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/indexeddb';
+import { createPXE } from '@aztec/pxe/client/lazy';
+import { getPXEConfig } from '@aztec/pxe/config';
+
+import { LazyAccountContractsProvider } from './account-contract-providers/lazy.js';
+import { EmbeddedWallet } from './embedded_wallet.js';
+import { WalletDB } from './wallet_db.js';
+
+export class BrowserEmbeddedWallet extends EmbeddedWallet {
+  static async create(nodeUrl: string): Promise<BrowserEmbeddedWallet> {
+    const aztecNode = createAztecNodeClient(nodeUrl);
+
+    const l1Contracts = await aztecNode.getL1ContractAddresses();
+    const rollupAddress = l1Contracts.rollupAddress;
+
+    const config = getPXEConfig();
+    config.dataDirectory = `pxe-${rollupAddress}`;
+
+    const pxe = await createPXE(aztecNode, config, {
+      loggers: {
+        store: createLogger('pxe:data:idb'),
+        pxe: createLogger('pxe:service'),
+        prover: createLogger('bb:wasm:lazy'),
+      },
+    });
+
+    const logger = createLogger('embedded-wallet:browser');
+    const walletDBStore = await createStore(
+      `wallet-${rollupAddress}`,
+      { dataDirectory: 'wallet', dataStoreMapSizeKb: 2e10 },
+      undefined,
+      createLogger('wallet:data:idb'),
+    );
+    const walletDB = WalletDB.init(walletDBStore, logger.info);
+
+    return new BrowserEmbeddedWallet(pxe, aztecNode, walletDB, new LazyAccountContractsProvider());
+  }
+}

package/src/embedded/entrypoints/browser.ts

@@ -0,0 +1,50 @@
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore, openTmpStore } from '@aztec/kv-store/indexeddb';
+import { createPXE } from '@aztec/pxe/client/lazy';
+import { getPXEConfig } from '@aztec/pxe/config';
+
+import { LazyAccountContractsProvider } from '../account-contract-providers/lazy.js';
+import { EmbeddedWallet, type EmbeddedWalletOptions } from '../embedded_wallet.js';
+import { WalletDB } from '../wallet_db.js';
+
+export class BrowserEmbeddedWallet extends EmbeddedWallet {
+  static async create(nodeUrl: string, options: EmbeddedWalletOptions = {}): Promise<BrowserEmbeddedWallet> {
+    const rootLogger = options.logger ?? createLogger('embedded-wallet');
+
+    const aztecNode = createAztecNodeClient(nodeUrl);
+
+    const l1Contracts = await aztecNode.getL1ContractAddresses();
+    const rollupAddress = l1Contracts.rollupAddress;
+
+    const config = getPXEConfig();
+    if (!options.ephemeral) {
+      config.dataDirectory = `pxe-${rollupAddress}`;
+    }
+
+    const pxe = await createPXE(aztecNode, config, {
+      loggers: {
+        store: rootLogger.createChild('pxe:data'),
+        pxe: rootLogger.createChild('pxe:service'),
+        prover: rootLogger.createChild('pxe:prover'),
+      },
+    });
+
+    const walletDBStore = options.ephemeral
+      ? await openTmpStore(true)
+      : await createStore(
+          `wallet-${rollupAddress}`,
+          { dataDirectory: 'wallet', dataStoreMapSizeKb: 2e10 },
+          undefined,
+          rootLogger.createChild('wallet:data'),
+        );
+    const walletDB = WalletDB.init(walletDBStore, rootLogger.createChild('wallet:db').info);
+
+    return new BrowserEmbeddedWallet(pxe, aztecNode, walletDB, new LazyAccountContractsProvider(), rootLogger);
+  }
+}
+
+export { BrowserEmbeddedWallet as EmbeddedWallet };
+export type { EmbeddedWalletOptions } from '../embedded_wallet.js';
+export { WalletDB } from '../wallet_db.js';
+export type { AccountType } from '../wallet_db.js';