@aztec/wallet-sdk 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/dest/base-wallet/base_wallet.js

@@ -1,16 +1,21 @@
-import { NO_WAIT } from '@aztec/aztec.js/contracts';
+import { NO_FROM } from '@aztec/aztec.js/account';
+import { NO_WAIT, extractOffchainOutput } from '@aztec/aztec.js/contracts';
 import { waitForTx } from '@aztec/aztec.js/node';
-import { GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT } from '@aztec/constants';
+import { ContractInitializationStatus, TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
 import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
+import { displayDebugLogs } from '@aztec/pxe/client/lazy';
 import { decodeFromAbi } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePartialAddress, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import { siloNullifier } from '@aztec/stdlib/hash';
+import { Gas, GasFees, GasSettings, ManaUsageEstimate } from '@aztec/stdlib/gas';
+import { computeSiloedPrivateInitializationNullifier, computeSiloedPublicInitializationNullifier } from '@aztec/stdlib/hash';
 import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
+import { buildMergedSimulationResult, extractOptimizablePublicStaticCalls, simulateViaNode } from './utils.js';
 /**
  * A base class for Wallet implementations
  */ export class BaseWallet {
@@ -19,14 +24,36 @@ import { inspect } from 'util';
     log;
     minFeePadding;
     cancellableTransactions;
+    // A wallet is instantiated for a particular chain, so chain info never changes during its lifetime.
+    // We cache it here because getChainInfo is called frequently (every tx simulation, send, auth wit, etc.).
+    nodeInfoPromise;
     // Protected because we want to force wallets to instantiate their own PXE.
-    constructor(pxe, aztecNode){
+    constructor(pxe, aztecNode, log = createLogger('wallet-sdk:base_wallet')){
         this.pxe = pxe;
         this.aztecNode = aztecNode;
-        this.log = createLogger('wallet-sdk:base_wallet');
+        this.log = log;
         this.minFeePadding = 0.5;
         this.cancellableTransactions = false;
     }
+    scopesFrom(from, additionalScopes = []) {
+        const allScopes = from === NO_FROM ? additionalScopes : [
+            from,
+            ...additionalScopes
+        ];
+        const scopeSet = new Set(allScopes.map((address)=>address.toString()));
+        return [
+            ...scopeSet
+        ].map(AztecAddress.fromString);
+    }
+    /**
+   * Picks the sender address PXE should tag private messages with. Returns `undefined` when there is no signing
+   * account (`from === NO_FROM`) and no explicit override; in that case any private log emitted by the tx using
+   * the wallet-supplied default sender will fail the "Sender for tags is not set" assertion.
+   * @param from - Tx sender, or `NO_FROM`.
+   * @param sendMessagesAs - Explicit override.
+   */ senderForTagsFrom(from, sendMessagesAs) {
+        return sendMessagesAs ?? (from === NO_FROM ? undefined : from);
+    }
     /**
    * Returns the list of aliased contacts associated with the wallet.
    * This base implementation directly returns PXE's senders, but note that in general contacts are a superset of senders.
@@ -41,7 +68,10 @@ import { inspect } from 'util';
             }));
     }
     async getChainInfo() {
-        const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+        if (!this.nodeInfoPromise) {
+            this.nodeInfoPromise = this.aztecNode.getNodeInfo();
+        }
+        const { l1ChainId, rollupVersion } = await this.nodeInfoPromise;
         return {
             chainId: new Fr(l1ChainId),
             version: new Fr(rollupVersion)
@@ -49,18 +79,24 @@ import { inspect } from 'util';
     }
     async createTxExecutionRequestFromPayloadAndFee(executionPayload, from, feeOptions) {
         const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
-        const executionOptions = {
-            txNonce: Fr.random(),
-            cancellable: this.cancellableTransactions,
-            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
-        };
         const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
             feeExecutionPayload,
             executionPayload
         ]) : executionPayload;
-        const fromAccount = await this.getAccountFromAddress(from);
         const chainInfo = await this.getChainInfo();
-        return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+        if (from === NO_FROM) {
+            const entrypoint = new DefaultEntrypoint();
+            return entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
+        } else {
+            const fromAccount = await this.getAccountFromAddress(from);
+            const executionOptions = {
+                txNonce: Fr.random(),
+                cancellable: this.cancellableTransactions,
+                // If from is an address, feeOptions include the way the account contract should handle the fee payment
+                feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+            };
+            return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+        }
     }
     async createAuthWit(from, messageHashOrIntent) {
         const account = await this.getAccountFromAddress(from);
@@ -103,26 +139,33 @@ import { inspect } from 'util';
     }
     /**
    * Completes partial user-provided fee options with wallet defaults.
-   * @param from - The address where the transaction is being sent from
-   * @param feePayer - The address paying for fees (if any fee payment method is embedded in the execution payload)
-   * @param gasSettings - User-provided partial gas settings
-   * @returns - Complete fee options that can be used to create a transaction execution request
-   */ async completeFeeOptions(from, feePayer, gasSettings) {
-        const maxFeesPerGas = gasSettings?.maxFeesPerGas ?? (await this.aztecNode.getCurrentMinFees()).mul(1 + this.minFeePadding);
+   * @param config - Fee completion config.
+   */ async completeFeeOptions(config) {
+        const { from, feePayer, gasSettings, forEstimation, congestionEstimate } = config;
+        const maxFeesPerGas = gasSettings?.maxFeesPerGas ?? (await this.getMinFees(congestionEstimate)).mul(1 + this.minFeePadding);
         let accountFeePaymentMethodOptions;
-        // The transaction does not include a fee payment method, so we set the flag
-        // for the account to use its fee juice balance
-        if (!feePayer) {
-            accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
-        } else {
-            // The transaction includes fee payment method, so we check if we are the fee payer for it
-            // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
-            accountFeePaymentMethodOptions = from.equals(feePayer) ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM : AccountFeePaymentMethodOptions.EXTERNAL;
+        // If from is an address, we need to determine the appropriate fee payment method options for the
+        // account contract entrypoint to use
+        if (from !== NO_FROM) {
+            if (!feePayer) {
+                // The transaction does not include a fee payment method, so we set the flag
+                // for the account to use its fee juice balance
+                accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
+            } else {
+                // The transaction includes fee payment method, so we check if we are the fee payer for it
+                // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
+                accountFeePaymentMethodOptions = from.equals(feePayer) ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM : AccountFeePaymentMethodOptions.EXTERNAL;
+            }
         }
-        const fullGasSettings = GasSettings.default({
-            ...gasSettings,
-            maxFeesPerGas
-        });
+        const gasSettingsOverrides = {
+            gasLimits: gasSettings?.gasLimits ? Gas.from(gasSettings.gasLimits) : undefined,
+            teardownGasLimits: gasSettings?.teardownGasLimits ? Gas.from(gasSettings.teardownGasLimits) : undefined,
+            maxFeesPerGas,
+            maxPriorityFeesPerGas: gasSettings?.maxPriorityFeesPerGas ?? GasFees.empty()
+        };
+        // When estimating gas (simulation), use high limits so the simulation doesn't run out of gas.
+        // When sending for real, use protocol max limits that the network will actually accept.
+        const fullGasSettings = forEstimation ? GasSettings.forEstimation(gasSettingsOverrides) : GasSettings.fallback(gasSettingsOverrides);
         this.log.debug(`Using L2 gas settings`, fullGasSettings);
         return {
             gasSettings: fullGasSettings,
@@ -131,22 +174,24 @@ import { inspect } from 'util';
         };
     }
     /**
-   * Completes partial user-provided fee options with unreasonably high gas limits
-   * for gas estimation. Uses the same logic as completeFeeOptions but sets high limits
-   * to avoid running out of gas during estimation.
-   * @param from - The address where the transaction is being sent from
-   * @param feePayer - The address paying for fees (if any fee payment method is embedded in the execution payload)
-   * @param gasSettings - User-provided partial gas settings
-   */ async completeFeeOptionsForEstimation(from, feePayer, gasSettings) {
-        const defaultFeeOptions = await this.completeFeeOptions(from, feePayer, gasSettings);
-        const { gasSettings: { maxFeesPerGas, maxPriorityFeesPerGas } } = defaultFeeOptions;
-        // Use unrealistically high gas limits for estimation to avoid running out of gas.
-        // They will be tuned down after the simulation.
-        const gasSettingsForEstimation = new GasSettings(new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT), new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT), maxFeesPerGas, maxPriorityFeesPerGas);
-        return {
-            ...defaultFeeOptions,
-            gasSettings: gasSettingsForEstimation
-        };
+   * Returns the worst-case min fee across predicted future slots.
+   * Falls back to getCurrentMinFees if the node doesn't support getPredictedMinFees.
+   * @param estimate - The mana usage estimate to use for fee prediction. Defaults to Limit for conservative estimation.
+   */ async getMinFees(estimate = ManaUsageEstimate.Limit) {
+        try {
+            const predicted = await this.aztecNode.getPredictedMinFees(estimate);
+            if (predicted.length === 0) {
+                return this.aztecNode.getCurrentMinFees();
+            }
+            return predicted.reduce((worst, fees)=>fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst);
+        } catch (err) {
+            // Fallback for old nodes that don't support getPredictedMinFees.
+            // Only fall back on method-not-found errors (JSON-RPC code -32601); rethrow others.
+            if (err?.cause?.code === -32601 || err?.message?.includes('Method not found')) {
+                return this.aztecNode.getCurrentMinFees();
+            }
+            throw err;
+        }
     }
     registerSender(address, _alias = '') {
         return this.pxe.registerSender(address);
@@ -183,23 +228,113 @@ import { inspect } from 'util';
         }
         return instance;
     }
-    async simulateTx(executionPayload, opts) {
-        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, opts?.skipTxValidation, opts?.skipFeeEnforcement ?? true);
+    registerContractClass(artifact) {
+        return this.pxe.registerContractClass(artifact);
+    }
+    /**
+   * Simulates calls through the standard PXE path (account entrypoint).
+   * @param executionPayload - The execution payload to simulate.
+   * @param opts - Simulation options.
+   */ async simulateViaEntrypoint(executionPayload, opts) {
+        const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, opts.feeOptions);
+        const result = await this.pxe.simulateTx(txRequest, {
+            simulatePublic: true,
+            skipTxValidation: opts.skipTxValidation,
+            skipFeeEnforcement: opts.skipFeeEnforcement,
+            scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+            senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs),
+            overrides: opts.overrides
+        });
+        const appCallOffset = await this.computeAppCallOffset(opts.from, opts.feeOptions);
+        return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
+    }
+    /**
+   * Computes the index where the app's calls begin in the flattened array of calls (0 = entrypoint/root, 1..N = fee
+   * calls, N+1 = app).
+   * @param from - The sender address, or NO_FROM for the default entrypoint.
+   * @param feeOptions - Fee options containing the wallet fee payment method.
+   */ async computeAppCallOffset(from, feeOptions) {
+        if (from === NO_FROM) {
+            return 0;
+        }
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        return (feeExecutionPayload?.calls.length ?? 0) + 1; // +1 for entrypoint
+    }
+    /**
+   * 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, opts) {
+        const feeOptions = await this.completeFeeOptions({
+            from: opts.from,
+            feePayer: executionPayload.feePayer,
+            gasSettings: opts.fee?.gasSettings,
+            forEstimation: true,
+            congestionEstimate: opts.fee?.congestionEstimate
+        });
+        const { optimizableCalls, remainingCalls } = extractOptimizablePublicStaticCalls(executionPayload);
+        const remainingPayload = {
+            ...executionPayload,
+            calls: remainingCalls
+        };
+        const chainInfo = await this.getChainInfo();
+        let 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.getBlockData('latest')).header;
+        }
+        const simulationOrigin = opts.from === NO_FROM ? AztecAddress.ZERO : opts.from;
+        const [optimizedResults, normalResult] = await Promise.all([
+            optimizableCalls.length > 0 ? simulateViaNode(this.aztecNode, optimizableCalls, simulationOrigin, chainInfo, feeOptions.gasSettings, blockHeader, opts.skipFeeEnforcement ?? true, this.getContractName.bind(this), opts.overrides) : Promise.resolve([]),
+            remainingCalls.length > 0 ? this.simulateViaEntrypoint(remainingPayload, {
+                from: opts.from,
+                feeOptions,
+                additionalScopes: opts.additionalScopes,
+                skipTxValidation: opts.skipTxValidation,
+                skipFeeEnforcement: opts.skipFeeEnforcement ?? true,
+                sendMessagesAs: opts.sendMessagesAs,
+                overrides: opts.overrides
+            }) : Promise.resolve(null)
+        ]);
+        return buildMergedSimulationResult(optimizedResults, normalResult);
     }
     async profileTx(executionPayload, opts) {
-        const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const feeOptions = await this.completeFeeOptions({
+            from: opts.from,
+            feePayer: executionPayload.feePayer,
+            gasSettings: opts.fee?.gasSettings,
+            congestionEstimate: opts.fee?.congestionEstimate
+        });
         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),
+            senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs)
+        });
     }
     async sendTx(executionPayload, opts) {
-        const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+        const feeOptions = await this.completeFeeOptions({
+            from: opts.from,
+            feePayer: executionPayload.feePayer,
+            gasSettings: opts.fee?.gasSettings,
+            congestionEstimate: opts.fee?.congestionEstimate
+        });
         const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
-        const provenTx = await this.pxe.proveTx(txRequest);
+        const provenTx = await this.pxe.proveTx(txRequest, {
+            scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+            senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs)
+        });
+        const offchainOutput = extractOffchainOutput(provenTx.getOffchainEffects(), provenTx.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp);
         const tx = await provenTx.toTx();
         const txHash = tx.getTxHash();
-        if (await this.aztecNode.getTxEffect(txHash)) {
+        if ((await this.aztecNode.getTxReceipt(txHash)).isMined()) {
             throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
         }
         this.log.debug(`Sending transaction ${txHash}`);
@@ -209,11 +344,33 @@ import { inspect } from 'util';
         this.log.info(`Sent transaction ${txHash}`);
         // If wait is NO_WAIT, return txHash immediately
         if (opts.wait === NO_WAIT) {
-            return txHash;
+            return {
+                txHash,
+                ...offchainOutput
+            };
         }
         // Otherwise, wait for the full receipt (default behavior on wait: undefined)
         const waitOpts = typeof opts.wait === 'object' ? opts.wait : undefined;
-        return await waitForTx(this.aztecNode, txHash, waitOpts);
+        const receipt = await waitForTx(this.aztecNode, txHash, waitOpts);
+        // Display debug logs from public execution if present (served in test mode only)
+        if (receipt.isMined() && receipt.debugLogs?.length) {
+            await displayDebugLogs(receipt.debugLogs, this.getContractName.bind(this));
+        }
+        return {
+            receipt,
+            ...offchainOutput
+        };
+    }
+    /**
+   * Resolves a contract address to a human-readable name via PXE, if available.
+   * @param address - The contract address to resolve.
+   */ async getContractName(address) {
+        const instance = await this.pxe.getContractInstance(address);
+        if (!instance) {
+            return undefined;
+        }
+        const artifact = await this.pxe.getContractArtifact(instance.currentContractClassId);
+        return artifact?.name;
     }
     contextualizeError(err, ...context) {
         let contextStr = '';
@@ -228,8 +385,11 @@ import { inspect } from 'util';
         }
         return err;
     }
-    simulateUtility(call, authwits) {
-        return this.pxe.simulateUtility(call, authwits);
+    executeUtility(call, opts) {
+        return this.pxe.executeUtility(call, {
+            authwits: opts.authWitnesses,
+            scopes: opts.scopes
+        });
     }
     async getPrivateEvents(eventDef, eventFilter) {
         const pxeEvents = await this.pxe.getPrivateEvents(eventDef.eventSelector, eventFilter);
@@ -247,15 +407,33 @@ import { inspect } from 'util';
         });
         return decodedEvents;
     }
-    async getContractMetadata(address) {
+    /**
+   * Returns metadata about a contract, including whether it has been initialized, published, and updated.
+   * @param address - The contract address to query.
+   */ async getContractMetadata(address) {
         const instance = await this.pxe.getContractInstance(address);
-        const initNullifier = await siloNullifier(address, address.toField());
-        const publiclyRegisteredContract = await this.aztecNode.getContract(address);
-        const initNullifierMembershipWitness = await this.aztecNode.getNullifierMembershipWitness('latest', initNullifier);
+        const publiclyRegisteredContractPromise = this.aztecNode.getContract(address);
+        let initializationStatus;
+        if (instance) {
+            // We have the instance, so we can compute the private initialization nullifier (which includes init_hash and is
+            // emitted by both private and public initializers) and get a definitive INITIALIZED/UNINITIALIZED answer.
+            const initNullifier = await computeSiloedPrivateInitializationNullifier(address, instance.initializationHash);
+            const witness = await this.aztecNode.getNullifierMembershipWitness('latest', initNullifier);
+            initializationStatus = witness ? ContractInitializationStatus.INITIALIZED : ContractInitializationStatus.UNINITIALIZED;
+        } else {
+            // Without the instance we lack the init_hash needed for the private nullifier. We fall back to checking the
+            // public initialization nullifier (computed from address alone). Not all contracts emit it (only those with
+            // public functions that require initialization checks), so its absence doesn't mean the contract is
+            // uninitialized.
+            const publicNullifier = await computeSiloedPublicInitializationNullifier(address);
+            const witness = await this.aztecNode.getNullifierMembershipWitness('latest', publicNullifier);
+            initializationStatus = witness ? ContractInitializationStatus.INITIALIZED : ContractInitializationStatus.UNKNOWN;
+        }
+        const publiclyRegisteredContract = await publiclyRegisteredContractPromise;
         const isContractUpdated = publiclyRegisteredContract && !publiclyRegisteredContract.currentContractClassId.equals(publiclyRegisteredContract.originalContractClassId);
         return {
             instance: instance ?? undefined,
-            isContractInitialized: !!initNullifierMembershipWitness,
+            initializationStatus,
             isContractPublished: !!publiclyRegisteredContract,
             isContractUpdated: !!isContractUpdated,
             updatedContractClassId: isContractUpdated ? publiclyRegisteredContract.currentContractClassId : undefined

package/dest/base-wallet/index.d.ts

@@ -1,2 +1,3 @@
-export { BaseWallet, type FeeOptions } from './base_wallet.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlLXdhbGxldC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLEtBQUssVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUMifQ==
+export { BaseWallet, type CompleteFeeOptionsConfig, type FeeOptions, type SimulateViaEntrypointOptions, } from './base_wallet.js';
+export { simulateViaNode, buildMergedSimulationResult, extractOptimizablePublicStaticCalls } from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlLXdhbGxldC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsVUFBVSxFQUNWLEtBQUssd0JBQXdCLEVBQzdCLEtBQUssVUFBVSxFQUNmLEtBQUssNEJBQTRCLEdBQ2xDLE1BQU0sa0JBQWtCLENBQUM7QUFDMUIsT0FBTyxFQUFFLGVBQWUsRUFBRSwyQkFBMkIsRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLFlBQVksQ0FBQyJ9

package/dest/base-wallet/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/base-wallet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/base-wallet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EACf,KAAK,4BAA4B,GAClC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,mCAAmC,EAAE,MAAM,YAAY,CAAC"}

package/dest/base-wallet/index.js

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

package/dest/base-wallet/utils.d.ts

@@ -0,0 +1,52 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { ContractNameResolver } from '@aztec/pxe/client/lazy';
+import { type FunctionCall } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { type BlockHeader, type ExecutionPayload, type SimulationOverrides, 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 declare function extractOptimizablePublicStaticCalls(payload: ExecutionPayload): {
+    /** Leading public static calls eligible for direct node simulation. */
+    optimizableCalls: FunctionCall[];
+    /** All remaining calls. */
+    remainingCalls: FunctionCall[];
+};
+/**
+ * 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.
+ * @param getContractName - Resolver for contract names (used for debug log display).
+ * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+ * @returns Array of TxSimulationResult, one per batch.
+ */
+export declare function simulateViaNode(node: AztecNode, publicStaticCalls: FunctionCall[], from: AztecAddress, chainInfo: ChainInfo, gasSettings: GasSettings, blockHeader: BlockHeader, skipFeeEnforcement: boolean | undefined, getContractName: ContractNameResolver, overrides?: SimulationOverrides): Promise<TxSimulationResult[]>;
+/**
+ * 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 declare function buildMergedSimulationResult(optimizedResults: TxSimulationResult[], normalResult: TxSimulationResultWithAppOffset | null): TxSimulationResultWithAppOffset;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlLXdhbGxldC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsK0JBQStCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUV6RSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUkvRCxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBR25FLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBb0IsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQVFyRCxPQUFPLEVBQ0wsS0FBSyxXQUFXLEVBQ2hCLEtBQUssZ0JBQWdCLEVBS3JCLEtBQUssbUJBQW1CLEVBR3hCLGtCQUFrQixFQUNuQixNQUFNLGtCQUFrQixDQUFDO0FBRTFCOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFnQixtQ0FBbUMsQ0FBQyxPQUFPLEVBQUUsZ0JBQWdCLEdBQUc7SUFDOUUsdUVBQXVFO0lBQ3ZFLGdCQUFnQixFQUFFLFlBQVksRUFBRSxDQUFDO0lBQ2pDLDJCQUEyQjtJQUMzQixjQUFjLEVBQUUsWUFBWSxFQUFFLENBQUM7Q0FDaEMsQ0FPQTtBQTBHRDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHdCQUFzQixlQUFlLENBQ25DLElBQUksRUFBRSxTQUFTLEVBQ2YsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLEVBQ2pDLElBQUksRUFBRSxZQUFZLEVBQ2xCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFdBQVcsRUFBRSxXQUFXLEVBQ3hCLFdBQVcsRUFBRSxXQUFXLEVBQ3hCLGtCQUFrQixxQkFBZ0IsRUFDbEMsZUFBZSxFQUFFLG9CQUFvQixFQUNyQyxTQUFTLENBQUMsRUFBRSxtQkFBbUIsR0FDOUIsT0FBTyxDQUFDLGtCQUFrQixFQUFFLENBQUMsQ0F5Qi9CO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQWdCLDJCQUEyQixDQUN6QyxnQkFBZ0IsRUFBRSxrQkFBa0IsRUFBRSxFQUN0QyxZQUFZLEVBQUUsK0JBQStCLEdBQUcsSUFBSSxHQUNuRCwrQkFBK0IsQ0FxQmpDIn0=

package/dest/base-wallet/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/base-wallet/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAI/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAQrD,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAKrB,KAAK,mBAAmB,EAGxB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;GASG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,gBAAgB,GAAG;IAC9E,uEAAuE;IACvE,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,2BAA2B;IAC3B,cAAc,EAAE,YAAY,EAAE,CAAC;CAChC,CAOA;AA0GD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,SAAS,EACf,iBAAiB,EAAE,YAAY,EAAE,EACjC,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,WAAW,EACxB,kBAAkB,qBAAgB,EAClC,eAAe,EAAE,oBAAoB,EACrC,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAyB/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,gBAAgB,EAAE,kBAAkB,EAAE,EACtC,YAAY,EAAE,+BAA+B,GAAG,IAAI,GACnD,+BAA+B,CAqBjC"}

package/dest/base-wallet/utils.js

@@ -0,0 +1,137 @@
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
+import { MAX_ENQUEUED_CALLS_PER_CALL } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { displayDebugLogs } from '@aztec/pxe/client/lazy';
+import { generateSimulatedProvingResult } from '@aztec/pxe/simulator';
+import { ClaimedLengthArray, CountedPublicCallRequest, PrivateCircuitPublicInputs, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, 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) {
+    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.
+ * @param getContractName - Resolver for contract names (used for debug log display).
+ * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+ * @returns TxSimulationResult with public return values.
+ */ async function simulateBatchViaNode(node, publicStaticCalls, from, chainInfo, gasSettings, blockHeader, skipFeeEnforcement, getContractName, overrides) {
+    const txContext = new TxContext(chainInfo.chainId, chainInfo.version, gasSettings);
+    const publicFunctionCalldata = [];
+    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 = new ClaimedLengthArray(publicCallRequests, 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, _functionSelector)=>Promise.resolve(''), node, 1);
+    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, overrides);
+    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.
+ * @param getContractName - Resolver for contract names (used for debug log display).
+ * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+ * @returns Array of TxSimulationResult, one per batch.
+ */ export async function simulateViaNode(node, publicStaticCalls, from, chainInfo, gasSettings, blockHeader, skipFeeEnforcement = true, getContractName, overrides) {
+    const batches = [];
+    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 = [];
+    for (const batch of batches){
+        const result = await simulateBatchViaNode(node, batch, from, chainInfo, gasSettings, blockHeader, skipFeeEnforcement, getContractName, overrides);
+        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, normalResult) {
+    const optimizedReturnValues = optimizedResults.flatMap((r)=>r.publicOutput?.publicReturnValues ?? []);
+    const normalReturnValues = normalResult?.publicOutput?.publicReturnValues ?? [];
+    const allReturnValues = [
+        ...optimizedReturnValues,
+        ...normalReturnValues
+    ];
+    const baseResult = normalResult ?? optimizedResults[0];
+    const mergedPublicOutput = baseResult.publicOutput ? {
+        ...baseResult.publicOutput,
+        publicReturnValues: allReturnValues
+    } : undefined;
+    const merged = new TxSimulationResult(baseResult.privateExecutionResult, baseResult.publicInputs, mergedPublicOutput, normalResult?.stats);
+    return TxSimulationResultWithAppOffset.fromResultAndOffset(merged, normalResult?.appCallOffset ?? 0);
+}