@aztec/wallets 0.0.1-commit.f8ca9b2f3

package/src/embedded/entrypoints/node.ts

@@ -0,0 +1,80 @@
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createLogger } from '@aztec/foundation/log';
+import { createStore as createWalletStore, openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import type { PXEConfig } from '@aztec/pxe/config';
+import { getPXEConfig } from '@aztec/pxe/config';
+import { type PXECreationOptions, createPXE } from '@aztec/pxe/server';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import { BundleAccountContractsProvider } from '../account-contract-providers/bundle.js';
+import { EmbeddedWallet, type EmbeddedWalletOptions } from '../embedded_wallet.js';
+import { WalletDB } from '../wallet_db.js';
+
+export type NodeEmbeddedWalletOptions = EmbeddedWalletOptions & {
+  /** Override PXE configuration. */
+  pxeConfig?: Partial<PXEConfig>;
+  /** Advanced PXE creation options (custom store, prover, simulator). */
+  pxeOptions?: PXECreationOptions;
+};
+
+export class NodeEmbeddedWallet extends EmbeddedWallet {
+  static async create(
+    nodeOrUrl: string | AztecNode,
+    options: NodeEmbeddedWalletOptions = {},
+  ): Promise<NodeEmbeddedWallet> {
+    const rootLogger = options.logger ?? createLogger('embedded-wallet');
+
+    const aztecNode = typeof nodeOrUrl === 'string' ? createAztecNodeClient(nodeOrUrl) : nodeOrUrl;
+
+    const pxeConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: options.pxeConfig?.proverEnabled ?? false,
+      ...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 l1Contracts = await aztecNode.getL1ContractAddresses();
+    const rollupAddress = l1Contracts.rollupAddress;
+
+    const walletDBStore = options.ephemeral
+      ? await openTmpStore(
+          'wallet_data',
+          true,
+          undefined,
+          undefined,
+          rootLogger.createChild('wallet:data').getBindings(),
+        )
+      : await createWalletStore(
+          'wallet_data',
+          1,
+          {
+            dataDirectory: pxeConfig.dataDirectory,
+            dataStoreMapSizeKb: pxeConfig.dataStoreMapSizeKb,
+            l1Contracts: { rollupAddress },
+          },
+          rootLogger.createChild('wallet:data').getBindings(),
+        );
+    const walletDB = WalletDB.init(walletDBStore, rootLogger.createChild('wallet:db').info);
+
+    return new NodeEmbeddedWallet(pxe, aztecNode, walletDB, new BundleAccountContractsProvider(), rootLogger);
+  }
+}
+
+export { NodeEmbeddedWallet as EmbeddedWallet };
+export type { EmbeddedWalletOptions } from '../embedded_wallet.js';
+export { WalletDB } from '../wallet_db.js';
+export type { AccountType } from '../wallet_db.js';

package/src/embedded/wallet_db.ts

@@ -0,0 +1,134 @@
+import type { Aliased } from '@aztec/aztec.js/wallet';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { LogFn } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];
+
+function accountKey(field: string, address: AztecAddress | string): string {
+  return `${field}:${address.toString()}`;
+}
+
+export class WalletDB {
+  private constructor(
+    private accounts: AztecAsyncMap<string, Buffer>,
+    private aliases: AztecAsyncMap<string, Buffer>,
+    private userLog: LogFn,
+  ) {}
+
+  static init(store: AztecAsyncKVStore, userLog: LogFn) {
+    const accounts = store.openMap<string, Buffer>('accounts');
+    const aliases = store.openMap<string, Buffer>('aliases');
+    return new WalletDB(accounts, aliases, userLog);
+  }
+
+  async storeAccount(
+    address: AztecAddress,
+    {
+      type,
+      secretKey,
+      salt,
+      alias,
+      signingKey,
+    }: {
+      type: AccountType;
+      secretKey: Fr;
+      salt: Fr;
+      signingKey: Fq | Buffer;
+      alias: string | undefined;
+    },
+    log: LogFn = 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: AztecAddress, alias: string, log: LogFn = this.userLog) {
+    await this.aliases.set(`senders:${alias}`, Buffer.from(address.toString()));
+    log(`Sender stored in database with alias ${alias}`);
+  }
+
+  async retrieveAccount(address: AztecAddress | string) {
+    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') as AccountType;
+    return { address, secretKey, salt, type, signingKey: signingKey! };
+  }
+
+  async listAccounts(): Promise<Aliased<AztecAddress>[]> {
+    // 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(): Promise<Aliased<AztecAddress>[]> {
+    const result: Aliased<AztecAddress>[] = [];
+    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(): Promise<Map<string, string>> {
+    const aliasesByAddress = new Map<string, string>();
+    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(): Promise<string[]> {
+    const addresses: string[] = [];
+    // 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: AztecAddress) {
+    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/src/testing.ts

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