@aztec/cli-wallet 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/src/utils/wallet.ts

@@ -1,37 +1,46 @@
-import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+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 {
+  ContractFunctionInteraction,
   type InteractionFeeOptions,
-  getContractInstanceFromInstantiationParams,
-  getGasLimits,
+  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';
 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, TxSimulationResult } from '@aztec/stdlib/tx';
+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>();
+  // Stub class ids, populated on wallet startup
+  // to avoid redundant work per simulation
+  private stubClassIds = new Map<AccountType, Fr>();
 
   constructor(
     pxe: PXE,
@@ -51,7 +60,35 @@ export class CLIWallet extends BaseWallet {
   ): Promise<CLIWallet> {
     const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
     const pxe = await createPXE(node, pxeConfig);
-    return new CLIWallet(pxe, node, log, db);
+    const wallet = new CLIWallet(pxe, node, log, db);
+    await wallet.initStubClasses();
+    await wallet.registerAuthRegistry();
+    return wallet;
+  }
+
+  private async registerAuthRegistry(): Promise<void> {
+    const { instance, artifact } = await getStandardAuthRegistry();
+    await this.pxe.registerContractClass(artifact);
+    await this.pxe.registerContract(instance);
+  }
+
+  /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */
+  private async initStubClasses(): Promise<void> {
+    const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+    await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+
+    // ecdsa stubs share the same class id
+    const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+    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);
   }
 
   override async getAccounts(): Promise<Aliased<AztecAddress>[]> {
@@ -59,18 +96,32 @@ 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,
     increasedFee: InteractionFeeOptions,
   ) {
     const executionPayload = ExecutionPayload.empty();
-    const feeOptions = await this.completeFeeOptions(from, executionPayload.feePayer, increasedFee.gasSettings);
+    const feeOptions = await this.completeFeeOptions({
+      from,
+      feePayer: executionPayload.feePayer,
+      gasSettings: increasedFee.gasSettings,
+    });
     const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
     const fromAccount = await this.getAccountFromAddress(from);
     const chainInfo = await this.getChainInfo();
@@ -94,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, this.scopesFrom(from));
+    return await this.pxe.proveTx(cancellationTxRequest, {
+      scopes: this.scopesFrom(from, [], undefined),
+      senderForTags: from,
+    });
   }
 
   override async getAccountFromAddress(address: AztecAddress) {
@@ -102,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();
     }
 
@@ -112,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;
   }
 
   /**
@@ -195,26 +290,19 @@ export class CLIWallet extends BaseWallet {
     if (!contractInstance) {
       throw new Error(`No contract instance found for address: ${originalAddress.address}`);
     }
-    const stubAccount = createStubAccount(originalAddress);
-    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
-      salt: Fr.random(),
-    });
-    return {
-      account: stubAccount,
-      instance,
-      artifact: StubAccountContractArtifact,
-    };
-  }
-
-  override async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
-    const simulationResults = await super.simulateTx(executionPayload, opts);
-
-    if (opts.fee?.estimateGas) {
-      const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
-      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
-      printGasEstimates(feeOptions, limits, this.userLog);
+    const { type } = await this.db!.retrieveAccount(address);
+    const stubAccount =
+      type === 'schnorr' || type === 'schnorr_initializerless'
+        ? createStubSchnorrAccount(originalAddress)
+        : createStubEcdsaAccount(originalAddress);
+    const stubClassId = this.stubClassIds.get(type);
+    if (!stubClassId) {
+      throw new Error(
+        `Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`,
+      );
     }
-    return simulationResults;
+    const instance = { ...contractInstance, currentContractClassId: stubClassId };
+    return { account: stubAccount, instance };
   }
 
   /**
@@ -224,8 +312,9 @@ export class CLIWallet extends BaseWallet {
   protected override async simulateViaEntrypoint(
     executionPayload: ExecutionPayload,
     opts: SimulateViaEntrypointOptions,
-  ): Promise<TxSimulationResult> {
-    const { from, feeOptions, scopes } = opts;
+  ): Promise<TxSimulationResultWithAppOffset> {
+    const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
+    const scopes = this.scopesFrom(from, additionalScopes ?? [], sendMessagesAs);
     const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
     const finalExecutionPayload = feeExecutionPayload
       ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
@@ -238,9 +327,9 @@ export class CLIWallet extends BaseWallet {
       const entrypoint = new DefaultEntrypoint();
       txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
     } else {
-      const { account, instance, artifact } = await this.getFakeAccountDataFor(from);
+      const { account, instance } = await this.getFakeAccountDataFor(from);
       overrides = {
-        contracts: { [from.toString()]: { instance, artifact } },
+        contracts: { [from.toString()]: { instance } },
       };
       const executionOptions: DefaultAccountEntrypointOptions = {
         txNonce: Fr.random(),
@@ -256,13 +345,16 @@ export class CLIWallet extends BaseWallet {
       );
     }
 
-    return this.pxe.simulateTx(txRequest, {
+    const result = await this.pxe.simulateTx(txRequest, {
       simulatePublic: true,
       skipFeeEnforcement: true,
       skipTxValidation: true,
       overrides,
       scopes,
+      senderForTags: this.senderForTagsFrom(from, sendMessagesAs),
     });
+    const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+    return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
   }
 
   // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because