@aztec/wallet-sdk 0.0.1-commit.d431d1c → 0.0.1-commit.db765a8

package/dest/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,oBAAY,iBAAiB;IAC3B,kDAAkD;IAClD,SAAS,2BAA2B;IACpC,uCAAuC;IACvC,kBAAkB,oCAAoC;IACtD,sEAAsE;IACtE,oBAAoB,sCAAsC;IAC1D,4CAA4C;IAC5C,UAAU,4BAA4B;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,SAAS,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,wBAAwB;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,IAAI,EAAE,iBAAiB,CAAC,SAAS,CAAC;IAClC,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,SAAS,EAAE,SAAS,CAAC;IACrB,wDAAwD;IACxD,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,IAAI,EAAE,iBAAiB,CAAC,kBAAkB,CAAC;IAC3C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,UAAU,EAAE,UAAU,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,oBAAY,iBAAiB;IAC3B,kDAAkD;IAClD,SAAS,2BAA2B;IACpC,uCAAuC;IACvC,kBAAkB,oCAAoC;IACtD,sEAAsE;IACtE,UAAU,4BAA4B;IACtC,oDAAoD;IACpD,oBAAoB,sCAAsC;IAC1D,qDAAqD;IACrD,qBAAqB,uCAAuC;CAC7D;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,UAAU;IACrD,gEAAgE;IAChE,SAAS,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,wBAAwB;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,IAAI,EAAE,iBAAiB,CAAC,SAAS,CAAC;IAClC,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,IAAI,EAAE,iBAAiB,CAAC,kBAAkB,CAAC;IAC3C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,mBAAmB;IACnB,IAAI,EAAE,iBAAiB,CAAC,oBAAoB,CAAC;IAC7C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,mBAAmB;IACnB,IAAI,EAAE,iBAAiB,CAAC,qBAAqB,CAAC;IAC9C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,SAAS,EAAE,iBAAiB,CAAC;CAC9B"}

package/dest/types.js

@@ -4,7 +4,8 @@
  */ export var WalletMessageType = /*#__PURE__*/ function(WalletMessageType) {
     /** Discovery request to find installed wallets */ WalletMessageType["DISCOVERY"] = "aztec-wallet-discovery";
     /** Discovery response from a wallet */ WalletMessageType["DISCOVERY_RESPONSE"] = "aztec-wallet-discovery-response";
-    /** Session disconnected notification (unencrypted control message) */ WalletMessageType["SESSION_DISCONNECTED"] = "aztec-wallet-session-disconnected";
-    /** Explicit disconnect request from dApp */ WalletMessageType["DISCONNECT"] = "aztec-wallet-disconnect";
+    /** Disconnect message (unencrypted control message, bidirectional) */ WalletMessageType["DISCONNECT"] = "aztec-wallet-disconnect";
+    /** Key exchange request sent over MessageChannel */ WalletMessageType["KEY_EXCHANGE_REQUEST"] = "aztec-wallet-key-exchange-request";
+    /** Key exchange response sent over MessageChannel */ WalletMessageType["KEY_EXCHANGE_RESPONSE"] = "aztec-wallet-key-exchange-response";
     return WalletMessageType;
 }({});

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@aztec/wallet-sdk",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/wallet-sdk",
-  "version": "0.0.1-commit.d431d1c",
+  "version": "0.0.1-commit.db765a8",
   "type": "module",
   "exports": {
     "./base-wallet": "./dest/base-wallet/index.js",
-    "./providers/extension": "./dest/providers/extension/index.js",
+    "./extension/handlers": "./dest/extension/handlers/index.js",
+    "./extension/provider": "./dest/extension/provider/index.js",
     "./crypto": "./dest/crypto.js",
     "./types": "./dest/types.js",
     "./manager": "./dest/manager/index.js"
   },
   "typedocOptions": {
     "entryPoints": [
-      "./src/index.ts"
+      "./src/base-wallet/index.ts",
+      "./src/extension/handlers/index.ts",
+      "./src/extension/provider/index.ts",
+      "./src/crypto.ts",
+      "./src/types.ts",
+      "./src/manager/index.ts"
     ],
+    "name": "Wallet SDK",
     "tsconfig": "./tsconfig.json"
   },
   "scripts": {
@@ -64,15 +71,15 @@
     ]
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.d431d1c",
-    "@aztec/constants": "0.0.1-commit.d431d1c",
-    "@aztec/entrypoints": "0.0.1-commit.d431d1c",
-    "@aztec/foundation": "0.0.1-commit.d431d1c",
-    "@aztec/pxe": "0.0.1-commit.d431d1c",
-    "@aztec/stdlib": "0.0.1-commit.d431d1c"
+    "@aztec/aztec.js": "0.0.1-commit.db765a8",
+    "@aztec/constants": "0.0.1-commit.db765a8",
+    "@aztec/entrypoints": "0.0.1-commit.db765a8",
+    "@aztec/foundation": "0.0.1-commit.db765a8",
+    "@aztec/pxe": "0.0.1-commit.db765a8",
+    "@aztec/stdlib": "0.0.1-commit.db765a8"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.0.1-commit.d431d1c",
+    "@aztec/noir-contracts.js": "0.0.1-commit.db765a8",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/base-wallet/base_wallet.ts

@@ -1,16 +1,26 @@
 import type { Account } from '@aztec/aztec.js/account';
 import type { CallIntent, IntentInnerHash } from '@aztec/aztec.js/authorization';
+import {
+  type InteractionWaitOptions,
+  NO_WAIT,
+  type SendReturn,
+  extractOffchainOutput,
+} from '@aztec/aztec.js/contracts';
 import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
+import { waitForTx } from '@aztec/aztec.js/node';
 import type {
   Aliased,
+  AppCapabilities,
   BatchResults,
   BatchedMethod,
+  ExecuteUtilityOptions,
   PrivateEvent,
   PrivateEventFilter,
   ProfileOptions,
   SendOptions,
   SimulateOptions,
   Wallet,
+  WalletCapabilities,
 } from '@aztec/aztec.js/wallet';
 import {
   GAS_ESTIMATION_DA_GAS_LIMIT,
@@ -23,6 +33,7 @@ import type { ChainInfo } from '@aztec/entrypoints/interfaces';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import type { FieldsOf } from '@aztec/foundation/types';
+import { type AccessScopes, displayDebugLogs } from '@aztec/pxe/client/lazy';
 import type { PXE, PackedPrivateEvent } from '@aztec/pxe/server';
 import {
   type ContractArtifact,
@@ -31,7 +42,7 @@ import {
   decodeFromAbi,
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type ContractInstanceWithAddress,
   computePartialAddress,
@@ -41,18 +52,19 @@ import { SimulationError } from '@aztec/stdlib/errors';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type {
-  TxExecutionRequest,
-  TxHash,
-  TxProfileResult,
-  TxReceipt,
+import {
+  BlockHeader,
+  type TxExecutionRequest,
+  type TxProfileResult,
   TxSimulationResult,
-  UtilitySimulationResult,
+  type UtilityExecutionResult,
 } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import { inspect } from 'util';
 
+import { buildMergedSimulationResult, extractOptimizablePublicStaticCalls, simulateViaNode } from './utils.js';
+
 /**
  * Options to configure fee payment for a transaction
  */
@@ -72,8 +84,6 @@ export type FeeOptions = {
  * A base class for Wallet implementations
  */
 export abstract class BaseWallet implements Wallet {
-  protected log = createLogger('wallet-sdk:base_wallet');
-
   protected minFeePadding = 0.5;
   protected cancellableTransactions = false;
 
@@ -81,8 +91,15 @@ export abstract class BaseWallet implements Wallet {
   protected constructor(
     protected readonly pxe: PXE,
     protected readonly aztecNode: AztecNode,
+    protected log = createLogger('wallet-sdk:base_wallet'),
   ) {}
 
+  protected scopesFrom(from: AztecAddress, additionalScopes: AztecAddress[] = []): AztecAddress[] {
+    const allScopes = from.isZero() ? additionalScopes : [from, ...additionalScopes];
+    const scopeSet = new Set(allScopes.map(address => address.toString()));
+    return [...scopeSet].map(AztecAddress.fromString);
+  }
+
   protected abstract getAccountFromAddress(address: AztecAddress): Promise<Account>;
 
   abstract getAccounts(): Promise<Aliased<AztecAddress>[]>;
@@ -137,6 +154,23 @@ export abstract class BaseWallet implements Wallet {
     return account.createAuthWit(messageHashOrIntent, chainInfo);
   }
 
+  /**
+   * Request capabilities from the wallet.
+   *
+   * This method is wallet-implementation-dependent and must be provided by classes extending BaseWallet.
+   * Embedded wallets typically don't support capability-based authorization (no user authorization flow),
+   * while external wallets (browser extensions, hardware wallets) implement this to reduce authorization
+   * friction by allowing apps to request permissions upfront.
+   *
+   * TODO: Consider making it abstract so implementing it is a conscious decision. Leaving it as-is
+   * while the feature stabilizes.
+   *
+   * @param _manifest - Application capability manifest declaring what operations the app needs
+   */
+  public requestCapabilities(_manifest: AppCapabilities): Promise<WalletCapabilities> {
+    throw new Error('Not implemented');
+  }
+
   public async batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>> {
     const results: any[] = [];
     for (const method of methods) {
@@ -263,29 +297,98 @@ export abstract class BaseWallet implements Wallet {
     return instance;
   }
 
+  /**
+   * Simulates calls through the standard PXE path (account entrypoint).
+   * @param executionPayload - The execution payload to simulate.
+   * @param from - The sender address.
+   * @param feeOptions - Fee options for the transaction.
+   * @param skipTxValidation - Whether to skip tx validation.
+   * @param skipFeeEnforcement - Whether to skip fee enforcement.
+   * @param scopes - The scopes to use for the simulation.
+   */
+  protected async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    from: AztecAddress,
+    feeOptions: FeeOptions,
+    scopes: AccessScopes,
+    skipTxValidation?: boolean,
+    skipFeeEnforcement?: boolean,
+  ) {
+    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, from, feeOptions);
+    return this.pxe.simulateTx(txRequest, { simulatePublic: true, skipTxValidation, skipFeeEnforcement, scopes });
+  }
+
+  /**
+   * Simulates a transaction, optimizing leading public static calls by running them directly
+   * on the node while sending the remaining calls through the standard PXE path.
+   * Return values from both paths are merged back in original call order.
+   * @param executionPayload - The execution payload to simulate.
+   * @param opts - Simulation options (from address, fee settings, etc.).
+   * @returns The merged simulation result.
+   */
   async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
     const feeOptions = opts.fee?.estimateGas
       ? await this.completeFeeOptionsForEstimation(opts.from, executionPayload.feePayer, opts.fee?.gasSettings)
       : await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
-    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
-    return this.pxe.simulateTx(
-      txRequest,
-      true /* simulatePublic */,
-      opts?.skipTxValidation,
-      opts?.skipFeeEnforcement ?? true,
-    );
+    const { optimizableCalls, remainingCalls } = extractOptimizablePublicStaticCalls(executionPayload);
+    const remainingPayload = { ...executionPayload, calls: remainingCalls };
+
+    const chainInfo = await this.getChainInfo();
+    let blockHeader: BlockHeader;
+    // PXE might not be synced yet, so we pull the latest header from the node
+    // To keep things consistent, we'll always try with PXE first
+    try {
+      blockHeader = await this.pxe.getSyncedBlockHeader();
+    } catch {
+      blockHeader = (await this.aztecNode.getBlockHeader())!;
+    }
+
+    const [optimizedResults, normalResult] = await Promise.all([
+      optimizableCalls.length > 0
+        ? simulateViaNode(
+            this.aztecNode,
+            optimizableCalls,
+            opts.from,
+            chainInfo,
+            feeOptions.gasSettings,
+            blockHeader,
+            opts.skipFeeEnforcement ?? true,
+            this.getContractName.bind(this),
+          )
+        : Promise.resolve([]),
+      remainingCalls.length > 0
+        ? this.simulateViaEntrypoint(
+            remainingPayload,
+            opts.from,
+            feeOptions,
+            this.scopesFrom(opts.from, opts.additionalScopes),
+            opts.skipTxValidation,
+            opts.skipFeeEnforcement ?? true,
+          )
+        : Promise.resolve(null),
+    ]);
+
+    return buildMergedSimulationResult(optimizedResults, normalResult);
   }
 
   async profileTx(executionPayload: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
     const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
     const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
-    return this.pxe.profileTx(txRequest, opts.profileMode, opts.skipProofGeneration ?? true);
+    return this.pxe.profileTx(txRequest, {
+      profileMode: opts.profileMode,
+      skipProofGeneration: opts.skipProofGeneration ?? true,
+      scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+    });
   }
 
-  async sendTx(executionPayload: ExecutionPayload, opts: SendOptions): Promise<TxHash> {
+  public async sendTx<W extends InteractionWaitOptions = undefined>(
+    executionPayload: ExecutionPayload,
+    opts: SendOptions<W>,
+  ): Promise<SendReturn<W>> {
     const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
     const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
-    const provenTx = await this.pxe.proveTx(txRequest);
+    const provenTx = await this.pxe.proveTx(txRequest, this.scopesFrom(opts.from, opts.additionalScopes));
+    const offchainOutput = extractOffchainOutput(provenTx.getOffchainEffects());
     const tx = await provenTx.toTx();
     const txHash = tx.getTxHash();
     if (await this.aztecNode.getTxEffect(txHash)) {
@@ -296,7 +399,35 @@ export abstract class BaseWallet implements Wallet {
       throw this.contextualizeError(err, inspect(tx));
     });
     this.log.info(`Sent transaction ${txHash}`);
-    return txHash;
+
+    // If wait is NO_WAIT, return txHash immediately
+    if (opts.wait === NO_WAIT) {
+      return { txHash, ...offchainOutput } as SendReturn<W>;
+    }
+
+    // Otherwise, wait for the full receipt (default behavior on wait: undefined)
+    const waitOpts = typeof opts.wait === 'object' ? opts.wait : undefined;
+    const receipt = await waitForTx(this.aztecNode, txHash, waitOpts);
+
+    // Display debug logs from public execution if present (served in test mode only)
+    if (receipt.debugLogs?.length) {
+      await displayDebugLogs(receipt.debugLogs, this.getContractName.bind(this));
+    }
+
+    return { receipt, ...offchainOutput } as SendReturn<W>;
+  }
+
+  /**
+   * Resolves a contract address to a human-readable name via PXE, if available.
+   * @param address - The contract address to resolve.
+   */
+  protected async getContractName(address: AztecAddress): Promise<string | undefined> {
+    const instance = await this.pxe.getContractInstance(address);
+    if (!instance) {
+      return undefined;
+    }
+    const artifact = await this.pxe.getContractArtifact(instance.currentContractClassId);
+    return artifact?.name;
   }
 
   protected contextualizeError(err: Error, ...context: string[]): Error {
@@ -313,12 +444,8 @@ export abstract class BaseWallet implements Wallet {
     return err;
   }
 
-  simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult> {
-    return this.pxe.simulateUtility(call, authwits);
-  }
-
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.aztecNode.getTxReceipt(txHash);
+  executeUtility(call: FunctionCall, opts: ExecuteUtilityOptions): Promise<UtilityExecutionResult> {
+    return this.pxe.executeUtility(call, { authwits: opts.authWitnesses, scopes: [opts.scope] });
   }
 
   async getPrivateEvents<T>(
@@ -345,14 +472,7 @@ export abstract class BaseWallet implements Wallet {
     const instance = await this.pxe.getContractInstance(address);
     const initNullifier = await siloNullifier(address, address.toField());
     const publiclyRegisteredContract = await this.aztecNode.getContract(address);
-    const [initNullifierMembershipWitness, publiclyRegisteredContractClass] = await Promise.all([
-      this.aztecNode.getNullifierMembershipWitness('latest', initNullifier),
-      publiclyRegisteredContract
-        ? this.aztecNode.getContractClass(
-            publiclyRegisteredContract.currentContractClassId || instance?.currentContractClassId,
-          )
-        : undefined,
-    ]);
+    const initNullifierMembershipWitness = await this.aztecNode.getNullifierMembershipWitness('latest', initNullifier);
     const isContractUpdated =
       publiclyRegisteredContract &&
       !publiclyRegisteredContract.currentContractClassId.equals(publiclyRegisteredContract.originalContractClassId);
@@ -360,7 +480,6 @@ export abstract class BaseWallet implements Wallet {
       instance: instance ?? undefined,
       isContractInitialized: !!initNullifierMembershipWitness,
       isContractPublished: !!publiclyRegisteredContract,
-      isContractClassPubliclyRegistered: !!publiclyRegisteredContractClass,
       isContractUpdated: !!isContractUpdated,
       updatedContractClassId: isContractUpdated ? publiclyRegisteredContract.currentContractClassId : undefined,
     };

package/src/base-wallet/index.ts

@@ -1 +1,2 @@
 export { BaseWallet, type FeeOptions } from './base_wallet.js';
+export { simulateViaNode, buildMergedSimulationResult, extractOptimizablePublicStaticCalls } from './utils.js';

package/src/base-wallet/utils.ts

@@ -0,0 +1,238 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { MAX_ENQUEUED_CALLS_PER_CALL } from '@aztec/constants';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { ContractNameResolver } from '@aztec/pxe/client/lazy';
+import { displayDebugLogs } from '@aztec/pxe/client/lazy';
+import { generateSimulatedProvingResult } from '@aztec/pxe/simulator';
+import { type FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import {
+  ClaimedLengthArray,
+  CountedPublicCallRequest,
+  PrivateCircuitPublicInputs,
+  PublicCallRequest,
+} from '@aztec/stdlib/kernel';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import {
+  type BlockHeader,
+  type ExecutionPayload,
+  HashedValues,
+  PrivateCallExecutionResult,
+  PrivateExecutionResult,
+  PublicSimulationOutput,
+  Tx,
+  TxContext,
+  TxSimulationResult,
+} from '@aztec/stdlib/tx';
+
+/**
+ * Splits an execution payload into a leading prefix of public static calls
+ * (eligible for direct node simulation) and the remaining calls.
+ *
+ * Only a leading run of public static calls is eligible for optimization.
+ * Any non-public-static call may enqueue public state mutations
+ * (e.g. private calls can enqueue public calls), so all calls that follow
+ * must go through the normal simulation path to see the correct state.
+ *
+ */
+export function extractOptimizablePublicStaticCalls(payload: ExecutionPayload): {
+  /** Leading public static calls eligible for direct node simulation. */
+  optimizableCalls: FunctionCall[];
+  /** All remaining calls. */
+  remainingCalls: FunctionCall[];
+} {
+  const splitIndex = payload.calls.findIndex(call => !call.isPublicStatic());
+  const boundary = splitIndex === -1 ? payload.calls.length : splitIndex;
+  return {
+    optimizableCalls: payload.calls.slice(0, boundary),
+    remainingCalls: payload.calls.slice(boundary),
+  };
+}
+
+/**
+ * Simulates a batch of public static calls by bypassing account entrypoint and private execution,
+ * directly constructing a minimal Tx and calling node.simulatePublicCalls.
+ *
+ * @param node - The Aztec node to simulate on.
+ * @param publicStaticCalls - Array of public static function calls (max MAX_ENQUEUED_CALLS_PER_CALL).
+ * @param from - The account address making the calls.
+ * @param chainInfo - Chain information (chainId and version).
+ * @param gasSettings - Gas settings for the transaction.
+ * @param blockHeader - Block header to use as anchor.
+ * @param skipFeeEnforcement - Whether to skip fee enforcement during simulation.
+ * @returns TxSimulationResult with public return values.
+ */
+async function simulateBatchViaNode(
+  node: AztecNode,
+  publicStaticCalls: FunctionCall[],
+  from: AztecAddress,
+  chainInfo: ChainInfo,
+  gasSettings: GasSettings,
+  blockHeader: BlockHeader,
+  skipFeeEnforcement: boolean,
+  getContractName: ContractNameResolver,
+): Promise<TxSimulationResult> {
+  const txContext = new TxContext(chainInfo.chainId, chainInfo.version, gasSettings);
+
+  const publicFunctionCalldata: HashedValues[] = [];
+  for (const call of publicStaticCalls) {
+    const calldata = await HashedValues.fromCalldata([call.selector.toField(), ...call.args]);
+    publicFunctionCalldata.push(calldata);
+  }
+
+  const publicCallRequests = makeTuple(MAX_ENQUEUED_CALLS_PER_CALL, i => {
+    const call = publicStaticCalls[i];
+    if (!call) {
+      return CountedPublicCallRequest.empty();
+    }
+    const publicCallRequest = new PublicCallRequest(from, call.to, call.isStatic, publicFunctionCalldata[i]!.hash);
+    // Counter starts at 1 (minRevertibleSideEffectCounter) so all calls are revertible
+    return new CountedPublicCallRequest(publicCallRequest, i + 1);
+  });
+
+  const publicCallRequestsArray: ClaimedLengthArray<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_CALL> =
+    new ClaimedLengthArray(
+      publicCallRequests as Tuple<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_CALL>,
+      publicStaticCalls.length,
+    );
+
+  const publicInputs = PrivateCircuitPublicInputs.from({
+    ...PrivateCircuitPublicInputs.empty(),
+    anchorBlockHeader: blockHeader,
+    txContext: txContext,
+    publicCallRequests: publicCallRequestsArray,
+    startSideEffectCounter: new Fr(0),
+    endSideEffectCounter: new Fr(publicStaticCalls.length + 1),
+  });
+
+  // Minimal entrypoint structure — no real private execution, just public call requests
+  const emptyEntrypoint = new PrivateCallExecutionResult(
+    Buffer.alloc(0),
+    Buffer.alloc(0),
+    new Map(),
+    publicInputs,
+    [],
+    new Map(),
+    [],
+    [],
+    [],
+    [],
+    [],
+  );
+
+  const privateResult = new PrivateExecutionResult(emptyEntrypoint, Fr.random(), publicFunctionCalldata);
+
+  const provingResult = await generateSimulatedProvingResult(
+    privateResult,
+    (_contractAddress: AztecAddress, _functionSelector: FunctionSelector) => Promise.resolve(''),
+    node,
+    1, // minRevertibleSideEffectCounter
+  );
+
+  provingResult.publicInputs.feePayer = from;
+
+  const tx = await Tx.create({
+    data: provingResult.publicInputs,
+    chonkProof: ChonkProof.empty(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: publicFunctionCalldata,
+  });
+
+  const publicOutput = await node.simulatePublicCalls(tx, skipFeeEnforcement);
+
+  if (publicOutput.revertReason) {
+    throw publicOutput.revertReason;
+  }
+
+  // Display debug logs from the public simulation.
+  await displayDebugLogs(publicOutput.debugLogs, getContractName);
+
+  return new TxSimulationResult(privateResult, provingResult.publicInputs, publicOutput, undefined);
+}
+
+/**
+ * Simulates public static calls by splitting them into batches of MAX_ENQUEUED_CALLS_PER_CALL
+ * and sending each batch directly to the node.
+ *
+ * @param node - The Aztec node to simulate on.
+ * @param publicStaticCalls - Array of public static function calls to optimize.
+ * @param from - The account address making the calls.
+ * @param chainInfo - Chain information (chainId and version).
+ * @param gasSettings - Gas settings for the transaction.
+ * @param blockHeader - Block header to use as anchor.
+ * @param skipFeeEnforcement - Whether to skip fee enforcement during simulation.
+ * @returns Array of TxSimulationResult, one per batch.
+ */
+export async function simulateViaNode(
+  node: AztecNode,
+  publicStaticCalls: FunctionCall[],
+  from: AztecAddress,
+  chainInfo: ChainInfo,
+  gasSettings: GasSettings,
+  blockHeader: BlockHeader,
+  skipFeeEnforcement: boolean = true,
+  getContractName: ContractNameResolver,
+): Promise<TxSimulationResult[]> {
+  const batches: FunctionCall[][] = [];
+
+  for (let i = 0; i < publicStaticCalls.length; i += MAX_ENQUEUED_CALLS_PER_CALL) {
+    batches.push(publicStaticCalls.slice(i, i + MAX_ENQUEUED_CALLS_PER_CALL));
+  }
+
+  const results: TxSimulationResult[] = [];
+
+  for (const batch of batches) {
+    const result = await simulateBatchViaNode(
+      node,
+      batch,
+      from,
+      chainInfo,
+      gasSettings,
+      blockHeader,
+      skipFeeEnforcement,
+      getContractName,
+    );
+    results.push(result);
+  }
+
+  return results;
+}
+
+/**
+ * Merges simulation results from the optimized (public static) and normal paths.
+ * Since optimized calls are always a leading prefix, return values are simply
+ * concatenated: optimized first, then normal.
+ * Stats are taken from the normal result only (the optimized path doesn't produce them).
+ *
+ * @param optimizedResults - Results from optimized public static call batches.
+ * @param normalResult - Result from normal simulation (null if all calls were optimized).
+ * @returns A single TxSimulationResult with return values in original call order.
+ */
+export function buildMergedSimulationResult(
+  optimizedResults: TxSimulationResult[],
+  normalResult: TxSimulationResult | null,
+): TxSimulationResult {
+  const optimizedReturnValues = optimizedResults.flatMap(r => r.publicOutput?.publicReturnValues ?? []);
+  const normalReturnValues = normalResult?.publicOutput?.publicReturnValues ?? [];
+  const allReturnValues = [...optimizedReturnValues, ...normalReturnValues];
+
+  const baseResult = normalResult ?? optimizedResults[0];
+
+  const mergedPublicOutput: PublicSimulationOutput | undefined = baseResult.publicOutput
+    ? {
+        ...baseResult.publicOutput,
+        publicReturnValues: allReturnValues,
+      }
+    : undefined;
+
+  return new TxSimulationResult(
+    baseResult.privateExecutionResult,
+    baseResult.publicInputs,
+    mergedPublicOutput,
+    normalResult?.stats,
+  );
+}