@aztec/cli-wallet 0.0.0-test.0

package/src/cmds/send.ts

@@ -0,0 +1,62 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract, Fr } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+import type { LogFn } from '@aztec/foundation/log';
+import { GasSettings } from '@aztec/stdlib/gas';
+
+import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+
+export async function send(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  wait: boolean,
+  cancellable: boolean,
+  feeOpts: IFeeOpts,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const call = contract.methods[functionName](...functionArgs);
+
+  const gasLimits = await call.estimateGas({ ...(await feeOpts.toSendOpts(wallet)) });
+  printGasEstimates(feeOpts, gasLimits, log);
+
+  if (feeOpts.estimateOnly) {
+    return;
+  }
+
+  const nonce = Fr.random();
+  const tx = call.send({ ...(await feeOpts.toSendOpts(wallet)), nonce, cancellable });
+  const txHash = await tx.getTxHash();
+  log(`\nTransaction hash: ${txHash.toString()}`);
+  if (wait) {
+    try {
+      await tx.wait();
+
+      log('Transaction has been mined');
+
+      const receipt = await tx.getReceipt();
+      log(` Tx fee: ${receipt.transactionFee}`);
+      log(` Status: ${receipt.status}`);
+      log(` Block number: ${receipt.blockNumber}`);
+      log(` Block hash: ${receipt.blockHash?.toString()}`);
+    } catch (err: any) {
+      log(`Transaction failed\n ${err.message}`);
+    }
+  } else {
+    log('Transaction pending. Check status with check-tx');
+  }
+  const gasSettings = GasSettings.from({
+    ...feeOpts.gasSettings,
+    ...gasLimits,
+  });
+  return {
+    txHash,
+    nonce,
+    cancellable,
+    gasSettings,
+  };
+}

package/src/cmds/simulate.ts

@@ -0,0 +1,42 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract, type ProfileResult } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { format } from 'util';
+
+function printProfileResult(result: ProfileResult, log: LogFn) {
+  log(format('\nSimulation result:'));
+  log(format('Return value:', JSON.stringify(result.returnValues, null, 2)));
+
+  log(format('\nGate count per circuit:'));
+  let acc = 0;
+  result.gateCounts.forEach(r => {
+    acc += r.gateCount;
+    log(format('  ', r.circuitName.padEnd(50), 'Gates:', r.gateCount.toLocaleString(), '\tAcc:', acc.toLocaleString()));
+  });
+
+  log(format('\nTotal gates:', acc.toLocaleString()));
+}
+
+export async function simulate(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  profile: boolean,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const call = contract.methods[functionName](...functionArgs);
+
+  if (profile) {
+    const result = await call.simulateWithProfile();
+    printProfileResult(result, log);
+  } else {
+    const result = await call.simulate();
+    log(format('\nSimulation result: ', result, '\n'));
+  }
+}

package/src/storage/wallet_db.ts

@@ -0,0 +1,243 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasSettings } from '@aztec/stdlib/gas';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { AccountType } from '../utils/accounts.js';
+import { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
+
+export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const;
+export type AliasType = (typeof Aliases)[number];
+
+export class WalletDB {
+  #accounts!: AztecAsyncMap<string, Buffer>;
+  #aliases!: AztecAsyncMap<string, Buffer>;
+  #bridgedFeeJuice!: AztecAsyncMap<string, Buffer>;
+  #transactions!: AztecAsyncMap<string, Buffer>;
+
+  private static instance: WalletDB;
+
+  private aliasCache = new Map<string, string>();
+
+  static getInstance() {
+    if (!WalletDB.instance) {
+      WalletDB.instance = new WalletDB();
+    }
+
+    return WalletDB.instance;
+  }
+
+  async init(store: AztecAsyncKVStore) {
+    this.#accounts = store.openMap('accounts');
+    this.#aliases = store.openMap('aliases');
+    this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
+    this.#transactions = store.openMap('transactions');
+
+    await this.refreshAliasCache();
+  }
+
+  private async refreshAliasCache() {
+    this.aliasCache = new Map((await this.listAliases()).map(({ key, value }) => [key, value]));
+  }
+
+  async pushBridgedFeeJuice(recipient: AztecAddress, secret: Fr, amount: bigint, leafIndex: bigint, log: LogFn) {
+    let stackPointer = (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+    stackPointer++;
+    await this.#bridgedFeeJuice.set(
+      `${recipient.toString()}:${stackPointer}`,
+      Buffer.from(`${amount.toString()}:${secret.toString()}:${leafIndex.toString()}`),
+    );
+    await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([stackPointer]));
+    log(`Pushed ${amount} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+  }
+
+  async popBridgedFeeJuice(recipient: AztecAddress, log: LogFn) {
+    let stackPointer = (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+    const result = await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:${stackPointer}`);
+    if (!result) {
+      throw new Error(
+        `No stored fee juice available for recipient ${recipient.toString()}. Please provide claim amount and secret. Stack pointer ${stackPointer}`,
+      );
+    }
+    const [amountStr, secretStr, leafIndexStr] = result.toString().split(':');
+    await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([--stackPointer]));
+    log(`Retrieved ${amountStr} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
+  }
+
+  async storeAccount(
+    address: AztecAddress,
+    {
+      type,
+      secretKey,
+      salt,
+      alias,
+      publicKey,
+    }: { type: AccountType; secretKey: Fr; salt: Fr; alias: string | undefined; publicKey: string | undefined },
+    log: LogFn,
+  ) {
+    if (alias) {
+      await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+    }
+    await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type));
+    await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer());
+    await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+    if (type === 'ecdsasecp256r1ssh' && publicKey) {
+      const publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
+      await this.storeAccountMetadata(address, 'publicSigningKey', publicSigningKey);
+    }
+    await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
+    log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+
+    await this.refreshAliasCache();
+  }
+
+  async storeSender(address: AztecAddress, alias: string, log: LogFn) {
+    await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+    log(`Account stored in database with alias ${alias} as a sender`);
+
+    await this.refreshAliasCache();
+  }
+
+  async storeContract(address: AztecAddress, artifactPath: string, log: LogFn, alias?: string) {
+    if (alias) {
+      await this.#aliases.set(`contracts:${alias}`, Buffer.from(address.toString()));
+      await this.#aliases.set(`artifacts:${alias}`, Buffer.from(artifactPath));
+    }
+    await this.#aliases.set(`contracts:last`, Buffer.from(address.toString()));
+    await this.#aliases.set(`artifacts:last`, Buffer.from(artifactPath));
+    await this.#aliases.set(`artifacts:${address.toString()}`, Buffer.from(artifactPath));
+    log(`Contract stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+
+    await this.refreshAliasCache();
+  }
+
+  async storeAuthwitness(authWit: AuthWitness, log: LogFn, alias?: string) {
+    if (alias) {
+      await this.#aliases.set(`authwits:${alias}`, Buffer.from(authWit.toString()));
+    }
+    await this.#aliases.set(`authwits:last`, Buffer.from(authWit.toString()));
+    log(`Authorization witness stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+
+    await this.refreshAliasCache();
+  }
+
+  async storeTx(
+    {
+      txHash,
+      nonce,
+      cancellable,
+      gasSettings,
+    }: { txHash: TxHash; nonce: Fr; cancellable: boolean; gasSettings: GasSettings },
+    log: LogFn,
+    alias?: string,
+  ) {
+    if (alias) {
+      await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
+    }
+    await this.#transactions.set(`${txHash.toString()}:nonce`, nonce.toBuffer());
+    await this.#transactions.set(`${txHash.toString()}:cancellable`, Buffer.from(cancellable ? 'true' : 'false'));
+    await this.#transactions.set(`${txHash.toString()}:gasSettings`, gasSettings.toBuffer());
+    await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+    log(`Transaction hash stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+
+    await this.refreshAliasCache();
+  }
+
+  async retrieveTxData(txHash: TxHash) {
+    const nonceBuffer = await this.#transactions.getAsync(`${txHash.toString()}:nonce`);
+    if (!nonceBuffer) {
+      throw new Error(
+        `Could not find ${txHash.toString()}:nonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`,
+      );
+    }
+    const nonce = Fr.fromBuffer(nonceBuffer);
+    const cancellable = (await this.#transactions.getAsync(`${txHash.toString()}:cancellable`))!.toString() === 'true';
+    const gasBuffer = (await this.#transactions.getAsync(`${txHash.toString()}:gasSettings`))!;
+    return { txHash, nonce, cancellable, gasSettings: GasSettings.fromBuffer(gasBuffer) };
+  }
+
+  tryRetrieveAlias(arg: string) {
+    try {
+      return this.retrieveAliasFromCache(arg);
+    } catch (e) {
+      return arg;
+    }
+  }
+
+  public retrieveAliasFromCache(arg: string) {
+    if (Aliases.find(alias => arg.startsWith(`${alias}:`))) {
+      const [type, ...alias] = arg.split(':');
+      const aliasKey = `${type}:${alias.join(':') ?? 'last'}`;
+      const data = this.aliasCache.get(aliasKey);
+      if (!data) {
+        throw new Error(`Could not find alias ${arg}`);
+      }
+      return data.toString();
+    } else {
+      throw new Error(`Aliases must start with one of ${Aliases.join(', ')}`);
+    }
+  }
+
+  async retrieveAlias(arg: string) {
+    if (Aliases.find(alias => arg.startsWith(`${alias}:`))) {
+      const [type, ...alias] = arg.split(':');
+      const data = await this.#aliases.getAsync(`${type}:${alias.join(':') ?? 'last'}`);
+      if (!data) {
+        throw new Error(`Could not find alias ${arg}`);
+      }
+      return data.toString();
+    } else {
+      throw new Error(`Aliases must start with one of ${Aliases.join(', ')}`);
+    }
+  }
+
+  async listAliases(type?: AliasType) {
+    const result = [];
+    if (type && !Aliases.includes(type)) {
+      throw new Error(`Unknown alias type ${type}`);
+    }
+    for await (const [key, value] of this.#aliases.entriesAsync()) {
+      if (!type || key.startsWith(`${type}:`)) {
+        result.push({ key, value: value.toString() });
+      }
+    }
+    return result;
+  }
+
+  async storeAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string, metadata: Buffer) {
+    const { address } = await this.retrieveAccount(aliasOrAddress);
+    await this.#accounts.set(`${address.toString()}:${metadataKey}`, metadata);
+  }
+
+  async retrieveAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string) {
+    const { address } = await this.retrieveAccount(aliasOrAddress);
+    const result = await this.#accounts.getAsync(`${address.toString()}:${metadataKey}`);
+    if (!result) {
+      throw new Error(`Could not find metadata with key ${metadataKey} for account ${aliasOrAddress}`);
+    }
+    return result;
+  }
+
+  async retrieveAccount(address: AztecAddress | string) {
+    const secretKeyBuffer = await this.#accounts.getAsync(`${address.toString()}:sk`);
+    if (!secretKeyBuffer) {
+      throw new Error(`Could not find ${address}:sk. Account "${address.toString}" does not exist on this wallet.`);
+    }
+    const secretKey = Fr.fromBuffer(secretKeyBuffer);
+    const salt = Fr.fromBuffer((await this.#accounts.getAsync(`${address.toString()}:salt`))!);
+    const type = (await this.#accounts.getAsync(`${address.toString()}:type`))!.toString('utf8') as AccountType;
+    return { address, secretKey, salt, type };
+  }
+
+  async storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn) {
+    await this.#aliases.set(`${type}:${key}`, value);
+    await this.refreshAliasCache();
+    log(`Data stored in database with alias ${type}:${key}`);
+
+    await this.refreshAliasCache();
+  }
+}

package/src/utils/accounts.ts

@@ -0,0 +1,102 @@
+import { getIdentities } from '@aztec/accounts/utils';
+import type { AccountManager, AccountWalletWithSecretKey } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import type { WalletDB } from '../storage/wallet_db.js';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];
+
+export async function createOrRetrieveAccount(
+  pxe: PXE,
+  address?: AztecAddress,
+  db?: WalletDB,
+  secretKey?: Fr,
+  type: AccountType = 'schnorr',
+  salt?: Fr,
+  publicKey?: string | undefined,
+): Promise<AccountManager> {
+  let account;
+
+  salt ??= Fr.ZERO;
+
+  if (db && address) {
+    ({ type, secretKey, salt } = await db.retrieveAccount(address));
+  }
+
+  if (!salt) {
+    throw new Error('Cannot retrieve/create wallet without salt');
+  }
+
+  if (!secretKey) {
+    throw new Error('Cannot retrieve/create wallet without secret key');
+  }
+
+  switch (type) {
+    case 'schnorr': {
+      const { getSchnorrAccount } = await import('@aztec/accounts/schnorr');
+      account = getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt);
+      break;
+    }
+    case 'ecdsasecp256r1ssh': {
+      let publicSigningKey;
+      if (db && address) {
+        publicSigningKey = await db.retrieveAccountMetadata(address, 'publicSigningKey');
+      } else if (publicKey) {
+        const identities = await getIdentities();
+        const foundIdentity = identities.find(
+          identity => identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey,
+        );
+        if (!foundIdentity) {
+          throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+        }
+        publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+      } else {
+        throw new Error('Public key must be provided for ECDSA SSH account');
+      }
+
+      const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa');
+      account = getEcdsaRSSHAccount(pxe, secretKey, publicSigningKey, salt);
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported account type: ${type}`);
+    }
+  }
+
+  return account;
+}
+
+export async function addScopeToWallet(wallet: AccountWalletWithSecretKey, scope: AztecAddress, db?: WalletDB) {
+  const address = wallet.getAddress().toString();
+  const currentScopes = wallet.getScopes() ?? [];
+  const deduplicatedScopes = Array.from(
+    new Set([address, ...currentScopes, scope].map(scope => scope.toString())).values(),
+  );
+  if (db) {
+    await db.storeAccountMetadata(wallet.getAddress(), 'scopes', Buffer.from(deduplicatedScopes.join(',')));
+  }
+  wallet.setScopes(deduplicatedScopes.map(scope => AztecAddress.fromString(scope)));
+}
+
+export async function getWalletWithScopes(account: AccountManager, db?: WalletDB) {
+  const wallet = await account.getWallet();
+  if (db) {
+    const address = wallet.getAddress().toString();
+    let storedScopes: string[] = [];
+    try {
+      storedScopes = ((await db.retrieveAccountMetadata(wallet.getAddress(), 'scopes')) ?? '').toString().split(',');
+      // eslint-disable-next-line no-empty
+    } catch {}
+    const currentScopes = wallet.getScopes()?.map(scopes => scopes.toString()) ?? [];
+    const deduplicatedScopes = Array.from(new Set([address, ...currentScopes, ...storedScopes]).values()).map(scope =>
+      AztecAddress.fromString(scope),
+    );
+    wallet.setScopes(deduplicatedScopes);
+  }
+  return wallet;
+}

package/src/utils/ecdsa.ts

@@ -0,0 +1,15 @@
+export function extractECDSAPublicKeyFromBase64String(base64PublicKey: string): Buffer {
+  const buffer = Buffer.from(base64PublicKey, 'base64');
+  let keyOffset = 0;
+  const typeLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 4;
+  keyOffset += typeLen;
+
+  const curveLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 4;
+  keyOffset += curveLen;
+
+  const keyLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 5; // 4+1 to remove the prefix
+  return buffer.subarray(keyOffset, keyOffset + keyLen - 1);
+}