refactor(wallets): narrow stub-class cache to just the class id

Callers only ever consume the `id` field from `getContractClassFromArtifact`,
so cache `Map<AccountType, Promise<Fr>>` instead of the full
`ContractClassWithId & ContractClassIdPreimage`. Method renamed
`#getStubClass` → `#getStubClassId`, map renamed `#stubClasses` →
`#stubClassIds`, callers drop the destructure.

Drop the verbose Promise-as-value rationale comment — the idiom is
established in this codebase (see ContractSyncService) and the PXE
precedents document the cache contract briefly without explaining
the dedupe pattern.

Author: dbanks12

yarn-project/cli-wallet/src/utils/wallet.ts

@@ -17,7 +17,6 @@ import type { PXEConfig } from '@aztec/pxe/config';
 import type { PXE } from '@aztec/pxe/server';
 import { createPXE, getPXEConfig } from '@aztec/pxe/server';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassIdPreimage, ContractClassWithId } from '@aztec/stdlib/contract';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 import { NoteDao } from '@aztec/stdlib/note';
 import type { SimulationOverrides, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
@@ -31,13 +30,8 @@ import { printGasEstimates } from './options/fees.js';
 
 export class CLIWallet extends BaseWallet {
   private accountCache = new Map<string, Account>();
-  /**
-   * Per-account-type cache of the stub class id and preimage. The Promise is stored (not the resolved
-   * value) so concurrent first-time callers dedupe on the same hashing + registration work. ECDSA
-   * variants all map to the same stub artifact but get their own cache slot, so we may hash + register
-   * the same artifact one extra time per variant on first miss; that cost is bounded and one-time.
-   */
-  #stubClasses = new Map<AccountType, Promise<ContractClassWithId & ContractClassIdPreimage>>();
+  // Per-account-type cache of the stub class id, populated lazily on first use.
+  #stubClassIds = new Map<AccountType, Promise<Fr>>();
 
   constructor(
     pxe: PXE,
@@ -208,25 +202,25 @@ export class CLIWallet extends BaseWallet {
     const { type } = await this.db!.retrieveAccount(address);
     const stubAccount =
       type === 'schnorr' ? createStubSchnorrAccount(originalAddress) : createStubEcdsaAccount(originalAddress);
-    const { id: stubClassId } = await this.#getStubClass(type);
+    const stubClassId = await this.#getStubClassId(type);
     const instance = { ...contractInstance, currentContractClassId: stubClassId };
     return { account: stubAccount, instance };
   }
 
   /**
-   * Lazily hashes and registers the stub class for the given account type, caching the result so
-   * subsequent simulations skip the artifact-hashing + registration round-trip.
+   * Lazily hashes and registers the stub class for the given account type, caching the resulting class
+   * id so subsequent simulations skip the artifact-hashing + registration round-trip.
    */
-  #getStubClass(type: AccountType): Promise<ContractClassWithId & ContractClassIdPreimage> {
-    let cached = this.#stubClasses.get(type);
+  #getStubClassId(type: AccountType): Promise<Fr> {
+    let cached = this.#stubClassIds.get(type);
     if (!cached) {
       cached = (async () => {
         const artifact = type === 'schnorr' ? StubSchnorrAccountContractArtifact : StubEcdsaAccountContractArtifact;
-        const stubClass = await getContractClassFromArtifact(artifact);
+        const { id } = await getContractClassFromArtifact(artifact);
         await this.pxe.registerContractClass(artifact);
-        return stubClass;
+        return id;
       })();
-      this.#stubClasses.set(type, cached);
+      this.#stubClassIds.set(type, cached);
     }
     return cached;
   }

yarn-project/end-to-end/src/test-wallet/test_wallet.ts

@@ -25,11 +25,7 @@ import { type PXEConfig, getPXEConfig } from '@aztec/pxe/config';
 import { PXE, type PXECreationOptions, createPXE } from '@aztec/pxe/server';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassIdPreimage,
-  type ContractClassWithId,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 import type { NoteDao } from '@aztec/stdlib/note';
 import {
@@ -116,26 +112,23 @@ export class TestWallet extends BaseWallet {
     });
   }
 
-  /**
-   * Per-account-type cache of the stub class id and preimage. The Promise is stored (not the resolved
-   * value) so concurrent first-time callers dedupe on the same hashing + registration work.
-   */
-  #stubClasses = new Map<AccountType, Promise<ContractClassWithId & ContractClassIdPreimage>>();
+  // Per-account-type cache of the stub class id, populated lazily on first use.
+  #stubClassIds = new Map<AccountType, Promise<Fr>>();
 
   /**
-   * Lazily hashes and registers the stub class for the given account type, caching the result so
-   * subsequent simulations skip the artifact-hashing + registration round-trip.
+   * Lazily hashes and registers the stub class for the given account type, caching the resulting
+   * class id so subsequent simulations skip the artifact-hashing + registration round-trip.
    */
-  #getStubClass(type: AccountType): Promise<ContractClassWithId & ContractClassIdPreimage> {
-    let cached = this.#stubClasses.get(type);
+  #getStubClassId(type: AccountType): Promise<Fr> {
+    let cached = this.#stubClassIds.get(type);
     if (!cached) {
       cached = (async () => {
         const stubArtifact = type === 'schnorr' ? StubSchnorrAccountContractArtifact : StubEcdsaAccountContractArtifact;
-        const stubClass = await getContractClassFromArtifact(stubArtifact);
+        const { id } = await getContractClassFromArtifact(stubArtifact);
         await this.pxe.registerContractClass(stubArtifact);
-        return stubClass;
+        return id;
       })();
-      this.#stubClasses.set(type, cached);
+      this.#stubClassIds.set(type, cached);
     }
     return cached;
   }
@@ -160,7 +153,7 @@ export class TestWallet extends BaseWallet {
         );
       }
 
-      const { id: stubClassId } = await this.#getStubClass(this.getTypeFor(address));
+      const stubClassId = await this.#getStubClassId(this.getTypeFor(address));
 
       contracts[address.toString()] = {
         instance: { ...contractInstance, currentContractClassId: stubClassId },

yarn-project/wallets/src/embedded/embedded_wallet.ts

@@ -11,11 +11,7 @@ import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { PXEConfig, PXECreationOptions } from '@aztec/pxe/client/lazy';
 import type { PXE } from '@aztec/pxe/server';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassIdPreimage,
-  type ContractClassWithId,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
@@ -80,11 +76,8 @@ const DEFAULT_ESTIMATED_GAS_PADDING = 0.1;
 export class EmbeddedWallet extends BaseWallet {
   protected estimatedGasPadding = DEFAULT_ESTIMATED_GAS_PADDING;
 
-  /**
-   * Per-account-type cache of the stub class id and preimage. The Promise is stored (not the resolved
-   * value) so concurrent first-time callers dedupe on the same hashing + registration work.
-   */
-  #stubClasses = new Map<AccountType, Promise<ContractClassWithId & ContractClassIdPreimage>>();
+  // Per-account-type cache of the stub class id, populated lazily on first use.
+  #stubClassIds = new Map<AccountType, Promise<Fr>>();
 
   constructor(
     pxe: PXE,
@@ -203,19 +196,19 @@ export class EmbeddedWallet extends BaseWallet {
   }
 
   /**
-   * Lazily hashes and registers the stub class for the given account type, caching the result so
-   * subsequent simulations skip the artifact-hashing + registration round-trip.
+   * Lazily hashes and registers the stub class for the given account type, caching the resulting
+   * class id so subsequent simulations skip the artifact-hashing + registration round-trip.
    */
-  #getStubClass(type: AccountType): Promise<ContractClassWithId & ContractClassIdPreimage> {
-    let cached = this.#stubClasses.get(type);
+  #getStubClassId(type: AccountType): Promise<Fr> {
+    let cached = this.#stubClassIds.get(type);
     if (!cached) {
       cached = (async () => {
         const stubArtifact = await this.accountContracts.getStubAccountContractArtifact(type);
-        const stubClass = await getContractClassFromArtifact(stubArtifact);
+        const { id } = await getContractClassFromArtifact(stubArtifact);
         await this.pxe.registerContractClass(stubArtifact);
-        return stubClass;
+        return id;
       })();
-      this.#stubClasses.set(type, cached);
+      this.#stubClassIds.set(type, cached);
     }
     return cached;
   }
@@ -233,7 +226,7 @@ export class EmbeddedWallet extends BaseWallet {
     for (const account of filtered) {
       const address = account.item;
       const { type } = await this.walletDB.retrieveAccount(address);
-      const { id: stubClassId } = await this.#getStubClass(type);
+      const stubClassId = await this.#getStubClassId(type);
 
       const originalAccount = await this.getAccountFromAddress(address);
       const completeAddress = originalAccount.getCompleteAddress();