@aztec/cli-wallet 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/cmds/get_fee_juice_balance.ts

@@ -0,0 +1,37 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { getFeeJuiceBalance } from '@aztec/aztec.js/utils';
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import type { LogFn } from '@aztec/foundation/log';
+
+const FEE_JUICE_DECIMALS = 18;
+const FEE_JUICE_UNIT = 10n ** BigInt(FEE_JUICE_DECIMALS);
+
+/** Formats a raw FeeJuice balance (18 decimals) for human-readable display. */
+function formatFeeJuice(raw: bigint, exact: boolean): string {
+  const whole = raw / FEE_JUICE_UNIT;
+  const fractional = raw % FEE_JUICE_UNIT;
+  const fracStr = fractional.toString().padStart(FEE_JUICE_DECIMALS, '0');
+  if (exact) {
+    return `${whole}.${fracStr} FJ`;
+  }
+  if (fractional === 0n) {
+    return `${whole} FJ`;
+  }
+  return `${whole}.${fracStr.replace(/0+$/, '')} FJ`;
+}
+
+export async function getFeeJuiceBalanceCmd(
+  node: AztecNode,
+  address: AztecAddress,
+  json: boolean,
+  exact: boolean,
+  log: LogFn,
+) {
+  const balance = await getFeeJuiceBalance(address, node);
+  if (json) {
+    log(prettyPrintJSON({ address: address.toString(), balance: balance.toString() }));
+  } else {
+    log(`Fee Juice balance for ${address.toString()}: ${formatFeeJuice(balance, exact)}`);
+  }
+}

package/src/cmds/import_test_accounts.ts

@@ -16,7 +16,18 @@ export async function importTestAccounts(wallet: CLIWallet, db: WalletDB, json:
       const secret = testAccounts[i].secret;
       const salt = new Fr(account.salt);
       const address = account.address;
-      await db.storeAccount(address, { type: 'schnorr', secretKey: secret, salt, alias, publicKey: undefined }, log);
+      await db.storeAccount(
+        address,
+        {
+          type: 'schnorr_initializerless',
+          signingKey: account.signingKey,
+          secretKey: secret,
+          salt,
+          alias,
+          publicKey: undefined,
+        },
+        log,
+      );
 
       if (json) {
         out[alias] = {

package/src/cmds/index.ts

@@ -4,25 +4,27 @@ import {
   ETHEREUM_HOSTS,
   PRIVATE_KEY,
   addOptions,
-  createSecretKeyOption,
+  createSigningKeyOption,
   l1ChainIdOption,
   parseBigint,
   parseFieldFromHexString,
   parsePublicKey,
 } from '@aztec/cli/utils';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import type { LogFn, Logger } from '@aztec/foundation/log';
+import { TxStatus } from '@aztec/stdlib/tx';
 
 import { type Command, Option } from 'commander';
 import inquirer from 'inquirer';
 
 import type { WalletDB } from '../storage/wallet_db.js';
 import type { CliWalletAndNodeWrapper } from '../utils/cli_wallet_and_node_wrapper.js';
+import type { AccountType } from '../utils/constants.js';
 import {
   ARTIFACT_DESCRIPTION,
   CLIFeeArgs,
   aliasedAddressParser,
-  aliasedSecretKeyParser,
+  aliasedSigningKeyParser,
   aliasedTxHashParser,
   artifactPathFromPromiseOrAlias,
   artifactPathParser,
@@ -38,7 +40,17 @@ import {
   createVerboseOption,
   integerArgParser,
 } from '../utils/options/index.js';
-import type { AccountType } from '../utils/wallet.js';
+
+function parseWaitForStatus(status: string): TxStatus {
+  switch (status) {
+    case 'proposed':
+      return TxStatus.PROPOSED;
+    case 'checkpointed':
+      return TxStatus.CHECKPOINTED;
+    default:
+      throw new Error(`Invalid wait-for-status: ${status}. Use 'proposed' or 'checkpointed'.`);
+  }
+}
 
 // TODO: This function is only used in 1 place so we could just inline this
 export function injectCommands(
@@ -63,7 +75,7 @@ export function injectCommands(
   const createAccountCommand = program
     .command('create-account')
     .description(
-      'Creates an aztec account that can be used for sending transactions. Registers the account on the PXE and deploys an account contract. Uses a Schnorr single-key account which uses the same key for encryption and authentication (not secure for production usage).',
+      'Creates an aztec account that can be used for sending transactions. Registers the account on the PXE and deploys an account contract. Uses a Schnorr account which uses an immutable key for authentication.',
     )
     .summary('Creates an aztec account that can be used for sending transactions.')
     .addOption(createAccountOption('Alias or address of the account performing the deployment', !db, db))
@@ -84,12 +96,17 @@ export function injectCommands(
       'Public key that identifies a private signing key stored outside of the wallet. Used for ECDSA SSH accounts over the secp256r1 curve.',
     )
     .addOption(
-      createSecretKeyOption('Secret key for account. Uses random by default.', false, sk =>
-        aliasedSecretKeyParser(sk, db),
+      createSigningKeyOption('Signing key for account. Uses random by default.', false, sk =>
+        aliasedSigningKeyParser(sk, db),
       ).conflicts('public-key'),
     )
     .addOption(createAliasOption('Alias for the account. Used for easy reference in subsequent commands.', !db))
     .addOption(createTypeOption(true))
+    .option(
+      '-s, --salt <hex string>',
+      'Optional deployment salt as a hex string for generating the deployment address. Defaults to 0.',
+      parseFieldFromHexString,
+    )
     .option(
       '--register-only',
       'Just register the account on the Wallet. Do not deploy or initialize the account contract.',
@@ -98,6 +115,7 @@ export function injectCommands(
     // `options.wait` is default true. Passing `--no-wait` will set it to false.
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
     .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
+    .option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed')
     .addOption(createVerboseOption());
 
   addOptions(createAccountCommand, CLIFeeArgs.getOptions()).action(async (_options, command) => {
@@ -106,8 +124,10 @@ export function injectCommands(
     const {
       type,
       from: parsedFromAddress,
-      secretKey,
+      signingKey,
+      salt,
       wait,
+      waitForStatus: waitForStatusStr,
       registerOnly,
       skipInitialization,
       publicDeploy,
@@ -136,7 +156,8 @@ export function injectCommands(
       wallet,
       node,
       type,
-      secretKey,
+      signingKey,
+      salt,
       publicKey,
       alias,
       parsedFromAddress,
@@ -146,14 +167,15 @@ export function injectCommands(
       registerClass,
       wait,
       CLIFeeArgs.parse(options, log, db),
+      parseWaitForStatus(waitForStatusStr),
       json,
       verbose,
       debugLogger,
       log,
     );
     if (db) {
-      const { address, alias, secretKey, salt } = accountCreationResult;
-      await db.storeAccount(address, { type, secretKey, salt, alias, publicKey }, log);
+      const { address, alias, signingKey, secretKey, salt } = accountCreationResult;
+      await db.storeAccount(address, { type, signingKey, secretKey, salt, alias, publicKey }, log);
     }
   });
 
@@ -180,12 +202,22 @@ export function injectCommands(
       '--skip-initialization',
       'Skip initializing the account contract. Useful for publicly deploying an existing account.',
     )
+    .option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed')
     .addOption(createVerboseOption());
 
   addOptions(deployAccountCommand, CLIFeeArgs.getOptions()).action(async (parsedAccount, _options, command) => {
     const { deployAccount } = await import('./deploy_account.js');
     const options = command.optsWithGlobals();
-    const { wait, from: parsedFromAddress, json, registerClass, skipInitialization, publicDeploy, verbose } = options;
+    const {
+      wait,
+      waitForStatus: waitForStatusStr,
+      from: parsedFromAddress,
+      json,
+      registerClass,
+      skipInitialization,
+      publicDeploy,
+      verbose,
+    } = options;
 
     const { wallet, node } = walletAndNodeWrapper;
 
@@ -199,6 +231,7 @@ export function injectCommands(
       publicDeploy,
       skipInitialization,
       CLIFeeArgs.parse(options, log, db),
+      parseWaitForStatus(waitForStatusStr),
       json,
       verbose,
       debugLogger,
@@ -219,7 +252,7 @@ export function injectCommands(
     )
     .option(
       '-s, --salt <hex string>',
-      'Optional deployment salt as a hex string for generating the deployment address.',
+      'Optional deployment salt as a hex string for generating the deployment address. Defaults to random.',
       parseFieldFromHexString,
     )
     .option('--universal', 'Do not mix the sender address into the deployment.')
@@ -238,6 +271,7 @@ export function injectCommands(
         'The amount of time in seconds to wait for the deployment to post to L2',
       ).conflicts('wait'),
     )
+    .option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed')
     .addOption(createVerboseOption());
 
   addOptions(deployCommand, CLIFeeArgs.getOptions()).action(async (artifactPathPromise, _options, command) => {
@@ -249,6 +283,7 @@ export function injectCommands(
       args,
       salt,
       wait,
+      waitForStatus: waitForStatusStr,
       classRegistration,
       init,
       publicDeployment,
@@ -262,12 +297,12 @@ export function injectCommands(
     const { wallet, node } = walletAndNodeWrapper;
     const artifactPath = await artifactPathPromise;
 
-    debugLogger.info(`Using wallet with address ${parsedFromAddress.toString()}`);
+    debugLogger.info(`Using wallet with address ${parsedFromAddress?.toString() ?? '<none>'}`);
 
     const address = await deploy(
       wallet,
       node,
-      universal ? undefined : parsedFromAddress,
+      parsedFromAddress,
       artifactPath,
       json,
       publicKey,
@@ -279,10 +314,12 @@ export function injectCommands(
       typeof init === 'string' ? false : init,
       wait,
       CLIFeeArgs.parse(options, log, db),
-      timeout,
+      parseWaitForStatus(waitForStatusStr),
       verbose,
+      timeout,
       debugLogger,
       log,
+      universal,
     );
     if (db && address) {
       await db.storeContract(address, artifactPath, log, alias);
@@ -308,6 +345,7 @@ export function injectCommands(
     )
     .addOption(createAccountOption('Alias or address of the account to send the transaction from', !db, db))
     .option('--no-wait', 'Print transaction hash without waiting for it to be mined')
+    .option('--wait-for-status <status>', "Tx status to wait for: 'proposed' or 'checkpointed'", 'proposed')
     .addOption(createVerboseOption());
 
   addOptions(sendCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
@@ -319,6 +357,7 @@ export function injectCommands(
       contractAddress,
       from: parsedFromAddress,
       wait,
+      waitForStatus: waitForStatusStr,
       alias,
       authWitness: authWitnessArray,
       verbose,
@@ -342,6 +381,7 @@ export function injectCommands(
       alias,
       CLIFeeArgs.parse(options, log, db),
       authWitnesses,
+      parseWaitForStatus(waitForStatusStr),
       verbose,
       log,
     );
@@ -359,7 +399,9 @@ export function injectCommands(
     .addOption(createContractAddressOption(db))
     .addOption(createArtifactOption(db))
     .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
+      createSigningKeyOption("The sender's signing key", !db, sk => aliasedSigningKeyParser(sk, db)).conflicts(
+        'account',
+      ),
     )
     .addOption(createAuthwitnessOption('Authorization witness to use for the simulation', !db, db))
     .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
@@ -492,6 +534,20 @@ export function injectCommands(
       }
     });
 
+  program
+    .command('get-fee-juice-balance')
+    .description('Checks the Fee Juice balance for a given address.')
+    .argument('<address>', 'Aztec address or alias to check balance for', address =>
+      aliasedAddressParser('accounts', address, db),
+    )
+    .option('--json', 'Emit output as json')
+    .option('--exact', 'Show exact balance with all 18 decimal places')
+    .action(async (address, options) => {
+      const { getFeeJuiceBalanceCmd } = await import('./get_fee_juice_balance.js');
+      const { json, exact } = options;
+      await getFeeJuiceBalanceCmd(walletAndNodeWrapper.node, address, json, exact, log);
+    });
+
   program
     .command('create-authwit')
     .description(

package/src/cmds/send.ts

@@ -1,9 +1,10 @@
 import type { AztecAddress } from '@aztec/aztec.js/addresses';
 import { AuthWitness } from '@aztec/aztec.js/authorization';
-import { Contract, type SendInteractionOptions } from '@aztec/aztec.js/contracts';
-import type { AztecNode } from '@aztec/aztec.js/node';
+import { Contract, NO_WAIT, type SendInteractionOptions } from '@aztec/aztec.js/contracts';
+import { type AztecNode, waitForTx } from '@aztec/aztec.js/node';
 import { prepTx } from '@aztec/cli/utils';
 import type { LogFn } from '@aztec/foundation/log';
+import { TxStatus } from '@aztec/stdlib/tx';
 
 import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
 import { CLIFeeArgs } from '../utils/options/fees.js';
@@ -22,6 +23,7 @@ export async function send(
   cancellable: boolean,
   feeOpts: CLIFeeArgs,
   authWitnesses: AuthWitness[],
+  waitForStatus: TxStatus,
   verbose: boolean,
   log: LogFn,
 ) {
@@ -37,40 +39,58 @@ export async function send(
     authWitnesses,
   };
 
-  const { estimatedGas, stats } = await call.simulate({
+  const localStart = performance.now();
+  const sim = await call.simulate({
     ...sendOptions,
-    fee: { ...sendOptions.fee, estimateGas: true },
+    includeMetadata: true,
   });
+  // includeMetadata: true guarantees these fields are present
+  const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed!);
+  const stats = sim.stats!;
 
   if (feeOpts.estimateOnly) {
     return;
   }
 
-  const tx = call.send({ ...sendOptions, fee: { ...sendOptions.fee, gasSettings: estimatedGas } });
   if (verbose) {
     printProfileResult(stats!, log);
   }
 
-  const txHash = await tx.getTxHash();
+  const { txHash } = await call.send({
+    ...sendOptions,
+    fee: { ...sendOptions.fee, gasSettings: estimatedGas },
+    wait: NO_WAIT,
+  });
+  const localTimeMs = performance.now() - localStart;
+
   log(`\nTransaction hash: ${txHash.toString()}`);
+
   if (wait) {
     try {
-      await tx.wait({ timeout: DEFAULT_TX_TIMEOUT_S });
+      const nodeStart = performance.now();
+      const receipt = await waitForTx(node, txHash, { timeout: DEFAULT_TX_TIMEOUT_S, waitForStatus });
+      const nodeTimeMs = performance.now() - nodeStart;
 
-      log('Transaction has been mined');
-
-      const receipt = await tx.getReceipt();
+      const statusLabel = waitForStatus === TxStatus.PROPOSED ? 'proposed' : 'checkpointed';
+      log(`Transaction has been ${statusLabel}`);
       log(` Tx fee: ${receipt.transactionFee}`);
       log(` Status: ${receipt.status}`);
       log(` Block number: ${receipt.blockNumber}`);
       log(` Block hash: ${receipt.blockHash?.toString()}`);
+      log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+      log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+
+      return {
+        txHash,
+      };
     } catch (err: any) {
       log(`Transaction failed\n ${err.message}`);
+      throw err;
     }
   } else {
     log('Transaction pending. Check status with check-tx');
+    return {
+      txHash,
+    };
   }
-  return {
-    txHash,
-  };
 }

package/src/cmds/simulate.ts

@@ -38,17 +38,15 @@ export async function simulate(
   });
   if (verbose) {
     await printAuthorizations(
-      simulationResult.offchainEffects!,
+      simulationResult.offchainEffects,
       async (address: AztecAddress) => {
         const metadata = await wallet.getContractMetadata(address);
-        if (!metadata.contractInstance) {
+        if (!metadata.instance) {
           return undefined;
         }
-        const classMetadata = await wallet.getContractClassMetadata(
-          metadata.contractInstance.currentContractClassId,
-          true,
-        );
-        return classMetadata.artifact;
+        const classId = metadata.updatedContractClassId ?? metadata.instance.originalContractClassId;
+        const artifact = await wallet.getContractArtifact(classId);
+        return artifact;
       },
       log,
     );

package/src/storage/wallet_db.ts

@@ -1,17 +1,19 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 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 type { TxHash } from '@aztec/stdlib/tx';
 
+import type { AccountType } from '../utils/constants.js';
 import { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
-import type { AccountType } from '../utils/wallet.js';
 
 export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const;
 export type AliasType = (typeof Aliases)[number];
 
 export class WalletDB {
+  #store!: AztecAsyncKVStore;
   #accounts!: AztecAsyncMap<string, Buffer>;
   #aliases!: AztecAsyncMap<string, Buffer>;
   #bridgedFeeJuice!: AztecAsyncMap<string, Buffer>;
@@ -29,6 +31,7 @@ export class WalletDB {
   }
 
   async init(store: AztecAsyncKVStore) {
+    this.#store = store;
     this.#accounts = store.openMap('accounts');
     this.#aliases = store.openMap('aliases');
     this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
@@ -41,14 +44,17 @@ export class WalletDB {
   }
 
   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}`);
+    await this.#store.transactionAsync(async () => {
+      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) {
@@ -65,30 +71,67 @@ export class WalletDB {
     return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
   }
 
+  async peekBridgedFeeJuice(recipient: AztecAddress, log: LogFn) {
+    const 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(':');
+    log(`Peeked ${amountStr} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
+  }
+
   async storeAccount(
     address: AztecAddress,
     {
       type,
+      signingKey,
       secretKey,
       salt,
       alias,
       publicKey,
-    }: { type: AccountType; secretKey: Fr; salt: Fr; alias: string | undefined; publicKey: string | undefined },
+    }: {
+      type: AccountType;
+      signingKey?: GrumpkinScalar;
+      secretKey?: Fr;
+      salt: Fr;
+      alias: string | undefined;
+      publicKey: string | undefined;
+    },
     log: LogFn,
   ) {
-    if (alias) {
-      await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+    // Even though the privacy secret key is sometimes derived from the signing key, we store it in the database
+    // regardless as that is not always the case. Local-key accounts also store their signing key, while external-key
+    // accounts such as SSH store only the privacy secret.
+    if (!secretKey) {
+      throw new Error('Cannot store account without a secret key');
     }
-    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());
+
+    let publicSigningKey: Buffer | undefined;
     if (type === 'ecdsasecp256r1ssh' && publicKey) {
-      const publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
-      await this.storeAccountMetadata(address, 'publicSigningKey', publicSigningKey);
+      publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
     }
-    await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
-    log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
 
+    await this.#store.transactionAsync(async () => {
+      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());
+      if (signingKey) {
+        await this.#accounts.set(`${address.toString()}:signing`, signingKey.toBuffer());
+      }
+      await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+      if (publicSigningKey) {
+        await this.#accounts.set(`${address.toString()}: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();
   }
 
@@ -100,35 +143,38 @@ export class WalletDB {
   }
 
   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));
+    await this.#store.transactionAsync(async () => {
+      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()));
+    await this.#store.transactionAsync(async () => {
+      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 }: { txHash: TxHash }, log: LogFn, alias?: string) {
-    if (alias) {
-      await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
-    }
-    await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+    await this.#store.transactionAsync(async () => {
+      if (alias) {
+        await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
+      }
+      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();
   }
 
@@ -199,10 +245,13 @@ export class WalletDB {
     if (!secretKeyBuffer) {
       throw new Error(`Could not find ${address}:sk. Account "${address.toString}" does not exist on this wallet.`);
     }
+    const signingKeyBuffer = await this.#accounts.getAsync(`${address.toString()}:signing`);
     const secretKey = Fr.fromBuffer(secretKeyBuffer);
+    // External-key accounts (e.g. SSH) store no signing key.
+    const signingKey = signingKeyBuffer ? GrumpkinScalar.fromBuffer(signingKeyBuffer) : undefined;
     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 };
+    return { address, signingKey, secretKey, salt, type };
   }
 
   async storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn) {

package/src/utils/constants.ts

@@ -0,0 +1,10 @@
+export const MIN_FEE_PADDING = 0.5;
+
+export const AccountTypes = [
+  'schnorr',
+  'schnorr_initializerless',
+  'ecdsasecp256r1',
+  'ecdsasecp256r1ssh',
+  'ecdsasecp256k1',
+] as const;
+export type AccountType = (typeof AccountTypes)[number];