@aztec/cli-wallet 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/cmds/send.ts

@@ -42,10 +42,10 @@ export async function send(
   const localStart = performance.now();
   const sim = await call.simulate({
     ...sendOptions,
-    fee: { ...sendOptions.fee, estimateGas: true },
+    includeMetadata: true,
   });
-  // estimateGas: true guarantees these fields are present
-  const estimatedGas = sim.estimatedGas!;
+  // includeMetadata: true guarantees these fields are present
+  const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed!);
   const stats = sim.stats!;
 
   if (feeOpts.estimateOnly) {

package/src/cmds/simulate.ts

@@ -44,7 +44,8 @@ export async function simulate(
         if (!metadata.instance) {
           return undefined;
         }
-        const artifact = await wallet.getContractArtifact(metadata.instance.currentContractClassId);
+        const classId = metadata.updatedContractClassId ?? metadata.instance.originalContractClassId;
+        const artifact = await wallet.getContractArtifact(classId);
         return artifact;
       },
       log,

package/src/storage/wallet_db.ts

@@ -1,4 +1,5 @@
 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';
@@ -88,13 +89,28 @@ export class WalletDB {
     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,
   ) {
+    // 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');
+    }
+
     let publicSigningKey: Buffer | undefined;
     if (type === 'ecdsasecp256r1ssh' && publicKey) {
       publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
@@ -106,6 +122,9 @@ export class WalletDB {
       }
       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);
@@ -226,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

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

package/src/utils/options/fees.ts

@@ -137,7 +137,7 @@ export function parsePaymentMethod(
     if (!parsed.asset) {
       throw new Error('Missing "asset" in payment option');
     }
-    return AztecAddress.fromString(parsed.asset);
+    return AztecAddress.fromStringUnsafe(parsed.asset);
   };
 
   return async (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => {
@@ -259,7 +259,9 @@ export class CLIFeeArgs {
   async toUserFeeOptions(node: AztecNode, wallet: Wallet, from: AztecAddress): Promise<ParsedFeeOptions> {
     const minFees = await this.getMinFees(node);
     const maxFeesPerGas = minFees.mul(1 + MIN_FEE_PADDING);
-    const gasSettings = GasSettings.fallback({ ...this.gasSettings, maxFeesPerGas });
+    const { txsLimits } = await node.getNodeInfo();
+    const gasLimits = this.gasSettings.gasLimits ?? Gas.from(txsLimits.gas);
+    const gasSettings = GasSettings.fallback({ ...this.gasSettings, gasLimits, maxFeesPerGas });
     const paymentMethod = await this.paymentMethod(wallet, from, gasSettings);
     return {
       paymentMethod,

package/src/utils/options/options.ts

@@ -1,5 +1,5 @@
 import { TxHash } from '@aztec/aztec.js/tx';
-import { parseAztecAddress, parseSecretKey, parseTxHash } from '@aztec/cli/utils';
+import { parseAztecAddress, parseSigningKey, parseTxHash } from '@aztec/cli/utils';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
@@ -64,13 +64,13 @@ export function aliasedAddressParser(defaultPrefix: AliasType, address: string,
   }
 }
 
-export function aliasedSecretKeyParser(sk: string, db?: WalletDB) {
+export function aliasedSigningKeyParser(sk: string, db?: WalletDB) {
   if (sk.startsWith('0x')) {
-    return parseSecretKey(sk);
+    return parseSigningKey(sk);
   } else {
-    const prefixed = `${sk.startsWith('accounts') ? '' : 'accounts'}:${sk.endsWith(':sk') ? sk : `${sk}:sk`}`;
+    const prefixed = `${sk.startsWith('accounts') ? '' : 'accounts'}:${sk.endsWith(':signing') ? sk : `${sk}:signing`}`;
     const rawSk = db ? db.tryRetrieveAlias(prefixed) : sk;
-    return parseSecretKey(rawSk);
+    return parseSigningKey(rawSk);
   }
 }
 

package/src/utils/wallet.ts

@@ -1,16 +1,21 @@
-import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/stub/ecdsa';
-import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/stub/schnorr';
+import { EcdsaKAccountContract, EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/ecdsa/stub';
+import { SchnorrAccountContract, SchnorrInitializerlessAccountContract } from '@aztec/accounts/schnorr';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/schnorr/stub';
 import { getIdentities } from '@aztec/accounts/utils';
 import { type Account, type AccountContract, NO_FROM } from '@aztec/aztec.js/account';
-import { type InteractionFeeOptions, getContractClassFromArtifact, getGasLimits } from '@aztec/aztec.js/contracts';
+import {
+  ContractFunctionInteraction,
+  type InteractionFeeOptions,
+  getContractClassFromArtifact,
+} from '@aztec/aztec.js/contracts';
 import type { AztecNode } from '@aztec/aztec.js/node';
-import { AccountManager, type Aliased, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import { AccountManager, type Aliased } from '@aztec/aztec.js/wallet';
 import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
 import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
 import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import type { LogFn } from '@aztec/foundation/log';
 import type { NotesFilter } from '@aztec/pxe/client/lazy';
 import type { PXEConfig } from '@aztec/pxe/config';
@@ -18,16 +23,18 @@ import type { PXE } from '@aztec/pxe/server';
 import { createPXE, getPXEConfig } from '@aztec/pxe/server';
 import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
+import type { Gas, GasUsed } from '@aztec/stdlib/gas';
 import { NoteDao } from '@aztec/stdlib/note';
 import type { SimulationOverrides, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
-import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
+import { BaseWallet, type SimulateViaEntrypointOptions, getGasLimits } from '@aztec/wallet-sdk/base-wallet';
 
 import type { WalletDB } from '../storage/wallet_db.js';
 import type { AccountType } from './constants.js';
 import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
-import { printGasEstimates } from './options/fees.js';
+
+/** Padding the CLI wallet applies to simulated gas usage when deriving declared gas limits. */
+const DEFAULT_ESTIMATED_GAS_PADDING = 0.1;
 
 export class CLIWallet extends BaseWallet {
   private accountCache = new Map<string, Account>();
@@ -61,7 +68,8 @@ export class CLIWallet extends BaseWallet {
 
   private async registerAuthRegistry(): Promise<void> {
     const { instance, artifact } = await getStandardAuthRegistry();
-    await this.pxe.registerContract({ instance, artifact });
+    await this.pxe.registerContractClass(artifact);
+    await this.pxe.registerContract(instance);
   }
 
   /**
@@ -77,6 +85,7 @@ export class CLIWallet extends BaseWallet {
     await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
 
     this.stubClassIds.set('schnorr', schnorrClassId);
+    this.stubClassIds.set('schnorr_initializerless', schnorrClassId);
     this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
     this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
     this.stubClassIds.set('ecdsasecp256r1ssh', ecdsaClassId);
@@ -87,11 +96,21 @@ export class CLIWallet extends BaseWallet {
     return Promise.resolve(
       accounts.map(({ key, value }) => {
         const alias = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
-        return { alias, item: AztecAddress.fromString(value) };
+        return { alias, item: AztecAddress.fromStringUnsafe(value) };
       }),
     );
   }
 
+  /**
+   * Derives suggested total and teardown gas limits from simulated gas usage, padded and clamped to the
+   * network's per-tx admission limits.
+   * @param gasUsed - The gas consumed during simulation (from a `simulate({ includeMetadata: true })` result).
+   */
+  async estimateGasLimits(gasUsed: GasUsed): Promise<{ gasLimits: Gas; teardownGasLimits: Gas }> {
+    const maxTxGasLimits = await this.getMaxTxGasLimits();
+    return getGasLimits(gasUsed, maxTxGasLimits, DEFAULT_ESTIMATED_GAS_PADDING);
+  }
+
   private async createCancellationTxExecutionRequest(
     from: AztecAddress,
     txNonce: Fr,
@@ -126,7 +145,10 @@ export class CLIWallet extends BaseWallet {
     increasedFee: InteractionFeeOptions,
   ): Promise<TxProvingResult> {
     const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
-    return await this.pxe.proveTx(cancellationTxRequest, { scopes: this.scopesFrom(from), senderForTags: from });
+    return await this.pxe.proveTx(cancellationTxRequest, {
+      scopes: this.scopesFrom(from, [], undefined),
+      senderForTags: from,
+    });
   }
 
   override async getAccountFromAddress(address: AztecAddress) {
@@ -134,7 +156,7 @@ export class CLIWallet extends BaseWallet {
     if (this.accountCache.has(address.toString())) {
       return this.accountCache.get(address.toString())!;
     } else {
-      const accountManager = await this.createOrRetrieveAccount(address);
+      const accountManager = await this.retrieveAccount(address);
       account = await accountManager.getAccount();
     }
 
@@ -144,74 +166,115 @@ export class CLIWallet extends BaseWallet {
     return account;
   }
 
-  private async createAccount(secret: Fr, salt: Fr, contract: AccountContract): Promise<AccountManager> {
-    const accountManager = await AccountManager.create(this, secret, contract, { salt });
-
-    const instance = accountManager.getInstance();
-    const artifact = await contract.getContractArtifact();
-
-    await this.registerContract(instance, artifact, secret);
-    this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
-    return accountManager;
-  }
-
-  async createOrRetrieveAccount(
-    address?: AztecAddress,
-    secretKey?: Fr,
-    type: AccountType = 'schnorr',
-    salt?: Fr,
+  /**
+   * Creates an account from freshly supplied keys. SSH accounts sign with a key held in the agent (resolved from
+   * `publicKey`), every other type is rooted on `signingKey`, with `secretKey` as its privacy secret.
+   */
+  async createAccount(
+    type: AccountType,
+    signingKey: GrumpkinScalar | undefined,
+    secretKey: Fr | undefined,
+    salt: Fr = Fr.ZERO,
     publicKey?: string,
   ): Promise<AccountManager> {
-    let account;
-
-    salt ??= Fr.ZERO;
+    const publicSigningKey =
+      type === 'ecdsasecp256r1ssh' ? await this.resolveSshPublicSigningKey(publicKey) : undefined;
+    return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
+  }
 
-    if (this.db && address) {
-      ({ type, secretKey, salt } = await this.db.retrieveAccount(address));
+  /**
+   * Retrieves a previously stored account by address, loading its keys, type and salt from the wallet database.
+   */
+  async retrieveAccount(address: AztecAddress): Promise<AccountManager> {
+    if (!this.db) {
+      throw new Error('Cannot retrieve an account without a wallet database');
     }
-
-    if (!secretKey) {
-      throw new Error('Cannot retrieve/create wallet without secret key');
+    const { type, signingKey, secretKey, salt } = await this.db.retrieveAccount(address);
+    if (type !== 'ecdsasecp256r1ssh' && !signingKey) {
+      throw new Error(
+        `Account ${address} has no stored signing key: it was created with an older version of aztec-wallet and is ` +
+          `incompatible with this one. Create a new account to continue.`,
+      );
     }
+    const publicSigningKey =
+      type === 'ecdsasecp256r1ssh' ? await this.db.retrieveAccountMetadata(address, 'publicSigningKey') : undefined;
+    return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
+  }
 
+  private async buildAccount(
+    type: AccountType,
+    salt: Fr,
+    signingKey: GrumpkinScalar | undefined,
+    secretKey: Fr | undefined,
+    publicSigningKey: Buffer | undefined,
+  ): Promise<AccountManager> {
     switch (type) {
-      case 'schnorr': {
-        account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
-        break;
-      }
-      case 'ecdsasecp256r1': {
-        account = await this.createAccount(
-          secretKey,
-          salt,
-          new EcdsaRAccountContract(deriveSigningKey(secretKey).toBuffer()),
-        );
-        break;
+      case 'schnorr':
+      case 'schnorr_initializerless':
+      case 'ecdsasecp256r1':
+      case 'ecdsasecp256k1': {
+        if (!signingKey || !secretKey) {
+          throw new Error('Cannot build account without signing key and secret key');
+        }
+        const contract =
+          type === 'schnorr'
+            ? new SchnorrAccountContract(signingKey)
+            : type === 'schnorr_initializerless'
+              ? new SchnorrInitializerlessAccountContract(signingKey)
+              : type === 'ecdsasecp256r1'
+                ? new EcdsaRAccountContract(signingKey.toBuffer())
+                : new EcdsaKAccountContract(signingKey.toBuffer());
+        return await this.materializeAccount(secretKey, salt, contract);
       }
       case 'ecdsasecp256r1ssh': {
-        let publicSigningKey;
-        if (this.db && address) {
-          publicSigningKey = await this.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');
+        if (!secretKey || !publicSigningKey) {
+          throw new Error('Cannot build SSH account without secret key and public signing key');
         }
-        account = await this.createAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
-        break;
+        return await this.materializeAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
       }
       default: {
         throw new Error(`Unsupported account type: ${type}`);
       }
     }
+  }
 
-    return account;
+  private async resolveSshPublicSigningKey(publicKey: string | undefined): Promise<Buffer> {
+    if (!publicKey) {
+      throw new Error('Public key must be provided for ECDSA SSH account');
+    }
+    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`);
+    }
+    return extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+  }
+
+  private async materializeAccount(secret: Fr, salt: Fr, contract: AccountContract): Promise<AccountManager> {
+    const accountManager = await AccountManager.create(this, secret, contract, { salt });
+
+    const instance = accountManager.getInstance();
+    const artifact = await contract.getContractArtifact();
+
+    await this.registerContract(instance, artifact, secret);
+    this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+
+    // Initializerless accounts have no deployment tx; their address commits to the signing public key
+    // (via the contract's immutablesHash, resolved by AccountManager.create) and the constructor's
+    // storage writes are materialized locally via a simulated "store" call here.
+    if (contract instanceof SchnorrInitializerlessAccountContract) {
+      const constructorAbi = artifact.functions.find(f => f.name === 'constructor');
+      if (!constructorAbi) {
+        throw new Error('Could not create SchnorrInitializerlessAccount: constructor ABI not found');
+      }
+      const { x, y } = await contract.getSigningPublicKey();
+      const storeCall = new ContractFunctionInteraction(this, instance.address, constructorAbi, [x, y]);
+      await storeCall.simulate({ from: instance.address });
+    }
+
+    return accountManager;
   }
 
   /**
@@ -229,7 +292,9 @@ export class CLIWallet extends BaseWallet {
     }
     const { type } = await this.db!.retrieveAccount(address);
     const stubAccount =
-      type === 'schnorr' ? createStubSchnorrAccount(originalAddress) : createStubEcdsaAccount(originalAddress);
+      type === 'schnorr' || type === 'schnorr_initializerless'
+        ? createStubSchnorrAccount(originalAddress)
+        : createStubEcdsaAccount(originalAddress);
     const stubClassId = this.stubClassIds.get(type);
     if (!stubClassId) {
       throw new Error(
@@ -240,24 +305,6 @@ export class CLIWallet extends BaseWallet {
     return { account: stubAccount, instance };
   }
 
-  override async simulateTx(
-    executionPayload: ExecutionPayload,
-    opts: SimulateOptions,
-  ): Promise<TxSimulationResultWithAppOffset> {
-    const simulationResults = await super.simulateTx(executionPayload, opts);
-
-    if (opts.fee?.estimateGas) {
-      const feeOptions = await this.completeFeeOptions({
-        from: opts.from,
-        feePayer: executionPayload.feePayer,
-        gasSettings: opts.fee?.gasSettings,
-      });
-      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
-      printGasEstimates(feeOptions, limits, this.userLog);
-    }
-    return simulationResults;
-  }
-
   /**
    * Uses a stub account for kernelless simulation, bypassing real account authorization.
    * Uses DefaultEntrypoint directly for NO_FROM transactions.
@@ -267,7 +314,7 @@ export class CLIWallet extends BaseWallet {
     opts: SimulateViaEntrypointOptions,
   ): Promise<TxSimulationResultWithAppOffset> {
     const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
-    const scopes = this.scopesFrom(from, additionalScopes);
+    const scopes = this.scopesFrom(from, additionalScopes ?? [], sendMessagesAs);
     const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
     const finalExecutionPayload = feeExecutionPayload
       ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])