@aztec/wallet-sdk 0.0.1-commit.a072138 → 0.0.1-commit.a5db02d

package/dest/base-wallet/base_wallet.js

@@ -1,16 +1,23 @@
-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 { computePartialAddress, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePartialAddress } 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 { deriveKeys, deriveKeysFromMasterSecretKeys } from '@aztec/stdlib/keys';
 import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
+import { assertGasLimitsWithinNetworkLimits } from './get_gas_limits.js';
+import { buildMergedSimulationResult, extractOptimizablePublicStaticCalls, simulateViaNode } from './utils.js';
 /**
  * A base class for Wallet implementations
  */ export class BaseWallet {
@@ -19,14 +26,39 @@ import { inspect } from 'util';
     log;
     minFeePadding;
     cancellableTransactions;
+    // Poll interval (in seconds) injected into sendTx waits when the caller does not specify one. Left undefined on
+    // production wallets so the DefaultWaitOpts 1s cadence stands; test wallets talking to in-process nodes lower it.
+    defaultWaitInterval;
+    // 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.fromStringUnsafe);
+    }
+    /**
+   * 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.
@@ -34,33 +66,64 @@ import { inspect } from 'util';
    *  - Contacts: more general concept akin to a phone's contact list.
    * @returns The aliased collection of AztecAddresses that form this wallet's address book
    */ async getAddressBook() {
-        const senders = await this.pxe.getSenders();
-        return senders.map((sender)=>({
-                item: sender,
+        const sources = await this.pxe.getTaggingSecretSources({
+            kind: 'address-derived'
+        });
+        return sources.map((source)=>({
+                item: source.sender,
                 alias: ''
             }));
     }
+    /**
+   * Fetches and caches the node info for the wallet's lifetime, since a wallet talks to a single network and
+   * node info never changes. A rejected fetch clears the cache so the next call retries instead of replaying
+   * the cached rejection forever — important because the gas-limit fill-in and validation (run on every send)
+   * depend on it.
+   */ getNodeInfo() {
+        if (!this.nodeInfoPromise) {
+            this.nodeInfoPromise = this.aztecNode.getNodeInfo().catch((err)=>{
+                this.nodeInfoPromise = undefined;
+                throw err;
+            });
+        }
+        return this.nodeInfoPromise;
+    }
     async getChainInfo() {
-        const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+        const { l1ChainId, rollupVersion } = await this.getNodeInfo();
         return {
             chainId: new Fr(l1ChainId),
             version: new Fr(rollupVersion)
         };
     }
+    /**
+   * Returns the maximum gas limits a single transaction may declare on this wallet's network (the
+   * node-advertised `txsLimits.gas`). Internal helper used to fill in default gas limits when sending a
+   * transaction without explicit limits, and to validate caller-provided limits before sending. Backed by
+   * the cached node info, since a wallet talks to a single network.
+   */ async getMaxTxGasLimits() {
+        const { txsLimits } = await this.getNodeInfo();
+        return new Gas(txsLimits.gas.daGas, txsLimits.gas.l2Gas);
+    }
     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 +166,50 @@ 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;
+        // 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 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 without explicit limits, declare the most a single tx may use on this network
+        // (the node's per-tx admission limit), so the proposer does not skip the tx for over-declaring gas.
+        let fullGasSettings;
+        if (forEstimation) {
+            // Estimation deliberately uses very high internal limits and skips tx validation, so we do not
+            // validate against the network admission limit here.
+            fullGasSettings = GasSettings.forEstimation(gasSettingsOverrides);
         } 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 maxTxGasLimits = await this.getMaxTxGasLimits();
+            // If the caller declared explicit gas limits, reject them up front when they exceed the network's
+            // per-tx admission limit (mirroring the node's GasLimitsValidator). Otherwise fill in the limit.
+            if (gasSettingsOverrides.gasLimits) {
+                assertGasLimitsWithinNetworkLimits(gasSettingsOverrides.gasLimits, maxTxGasLimits);
+            }
+            fullGasSettings = GasSettings.fallback({
+                ...gasSettingsOverrides,
+                gasLimits: gasSettingsOverrides.gasLimits ?? maxTxGasLimits
+            });
         }
-        const fullGasSettings = GasSettings.default({
-            ...gasSettings,
-            maxFeesPerGas
-        });
         this.log.debug(`Using L2 gas settings`, fullGasSettings);
         return {
             gasSettings: fullGasSettings,
@@ -131,75 +218,161 @@ 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);
+    async registerSender(address, _alias = '') {
+        await this.pxe.registerTaggingSecretSource({
+            kind: 'address-derived',
+            sender: address
+        });
+        return address;
     }
-    async registerContract(instance, artifact, secretKey) {
-        const existingInstance = await this.pxe.getContractInstance(instance.address);
-        if (existingInstance) {
-            // Instance already registered in the wallet
-            if (artifact) {
-                const thisContractClass = await getContractClassFromArtifact(artifact);
-                if (!thisContractClass.id.equals(existingInstance.currentContractClassId)) {
-                    // wallet holds an outdated version of this contract
-                    await this.pxe.updateContract(instance.address, artifact);
-                    instance.currentContractClassId = thisContractClass.id;
-                }
-            }
-        // If no artifact provided, we just use the existing registration
-        } else {
-            // Instance not registered yet
-            if (!artifact) {
-                // Try to get the artifact from the wallet's contract class storage
-                artifact = await this.pxe.getContractArtifact(instance.currentContractClassId);
-                if (!artifact) {
-                    throw new Error(`Cannot register contract at ${instance.address.toString()}: artifact is required but not provided, and wallet does not have the artifact for contract class ${instance.currentContractClassId.toString()}`);
-                }
+    async registerContract(instance, artifact, secretKeyOrKeys) {
+        // Classes and instances are registered independently: register the artifact (if provided) then the instance.
+        // Neither call validates that the artifact matches the class the instance runs, a missing artifact only surfaces
+        // when the contract is later simulated.
+        if (artifact) {
+            await this.pxe.registerContractClass(artifact);
+        }
+        const contractAddress = await this.pxe.registerContract(instance);
+        if (secretKeyOrKeys) {
+            // PXE never receives the account seed (from which the message-signing/fallback secret keys could be re-derived):
+            // the wallet derives the keys here. Of these, PXE only reads and stores the four privacy secret keys and the
+            // message-signing and fallback *public* keys — it never touches the message-signing or fallback secret keys.
+            //
+            // Since PXE recomputes the address from those keys, we assert it matches the instance's address: a mismatch means
+            // the provided keys don't correspond to this account.
+            const derivedKeys = secretKeyOrKeys instanceof Fr ? await deriveKeys(secretKeyOrKeys) : await deriveKeysFromMasterSecretKeys(secretKeyOrKeys);
+            const { address } = await this.pxe.registerAccount(derivedKeys, await computePartialAddress(instance));
+            if (!address.equals(contractAddress)) {
+                throw new Error(`Registered account address ${address.toString()} does not match contract instance address ${contractAddress.toString()}: the provided keys do not correspond to this account.`);
             }
-            await this.pxe.registerContract({
-                artifact,
-                instance
-            });
         }
-        if (secretKey) {
-            await this.pxe.registerAccount(secretKey, await computePartialAddress(instance));
+    }
+    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;
         }
-        return instance;
+        const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+        return (feeExecutionPayload?.calls.length ?? 0) + 1; // +1 for entrypoint
     }
-    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);
+    /**
+   * 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 +382,41 @@ 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 callerWaitOpts = typeof opts.wait === 'object' ? opts.wait : undefined;
+        const waitOpts = this.defaultWaitInterval !== undefined && callerWaitOpts?.interval === undefined ? {
+            ...callerWaitOpts,
+            interval: this.defaultWaitInterval
+        } : callerWaitOpts;
+        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;
+        }
+        // Contract names are class-stable (an upgrade preserves the contract name), so the original class artifact is a
+        // sufficient source for the display name without resolving the current class against the node.
+        // TODO: if a contract were to be upgraded and its original artifact never registered, then this would fail and we'd
+        // want to fallback to the current class.
+        const artifact = await this.pxe.getContractArtifact(instance.originalContractClassId);
+        return artifact?.name;
     }
     contextualizeError(err, ...context) {
         let contextStr = '';
@@ -228,8 +431,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 +453,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/get_gas_limits.d.ts

@@ -0,0 +1,36 @@
+import { Gas, type GasUsed } from '@aztec/stdlib/gas';
+/**
+ * Returns suggested total and teardown gas limits for a simulated tx, clamped to the network's per-tx
+ * admission limits.
+ *
+ * The network only admits transactions that declare up to `maxTxGasLimits` per dimension (the
+ * node-advertised `txsLimits.gas`). Wallets pass the value read from their own node info, but since node info
+ * is remote input it is defensively clamped here to the per-tx protocol maxima so a value above them is never
+ * honored. If the simulated usage already exceeds the resulting admission limits the tx can never be included,
+ * so this throws a descriptive error instead of returning a limit the node would reject. Otherwise it pads the
+ * usage and clamps each dimension to the admission limit.
+ * @param gasUsed - The gas actually consumed during simulation.
+ * @param maxTxGasLimits - The maximum gas a single tx may declare on this network (the node-advertised `txsLimits.gas`).
+ * @param pad - Fraction to pad the suggested gas limits by (as a decimal, e.g. 0.1 for 10%). The effective
+ * padding shrinks to zero as usage approaches the network limit, since the network will not admit a higher
+ * declared limit regardless of the buffer.
+ */
+export declare function getGasLimits(gasUsed: GasUsed, maxTxGasLimits: Gas, pad?: number): {
+    /**
+     * Gas limit for the tx, excluding teardown gas
+     */
+    gasLimits: Gas;
+    /**
+     * Gas limit for the teardown phase
+     */
+    teardownGasLimits: Gas;
+};
+/**
+ * Validates that caller-declared gas limits do not exceed the network's per-tx admission limits, throwing a
+ * descriptive error per dimension when they do. The node's inbound validation checks declared
+ * `gasSettings.gasLimits`, so we mirror that here to surface the rejection locally before the tx is sent.
+ * @param gasLimits - The gas limits the transaction will declare.
+ * @param maxTxGasLimits - The maximum gas a single tx may declare on this network (the node-advertised `txsLimits.gas`).
+ */
+export declare function assertGasLimitsWithinNetworkLimits(gasLimits: Gas, maxTxGasLimits: Gas): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2dhc19saW1pdHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlLXdhbGxldC9nZXRfZ2FzX2xpbWl0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsR0FBRyxFQUFFLEtBQUssT0FBTyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFdEQ7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsd0JBQWdCLFlBQVksQ0FDMUIsT0FBTyxFQUFFLE9BQU8sRUFDaEIsY0FBYyxFQUFFLEdBQUcsRUFDbkIsR0FBRyxTQUFNLEdBQ1I7SUFDRDs7T0FFRztJQUNILFNBQVMsRUFBRSxHQUFHLENBQUM7SUFDZjs7T0FFRztJQUNILGlCQUFpQixFQUFFLEdBQUcsQ0FBQztDQUN4QixDQTZCQTtBQVFEOzs7Ozs7R0FNRztBQUNILHdCQUFnQixrQ0FBa0MsQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFLGNBQWMsRUFBRSxHQUFHLEdBQUcsSUFBSSxDQVc1RiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_gas_limits.d.ts","sourceRoot":"","sources":["../../src/base-wallet/get_gas_limits.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,GAAG,EACnB,GAAG,SAAM,GACR;IACD;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;IACf;;OAEG;IACH,iBAAiB,EAAE,GAAG,CAAC;CACxB,CA6BA;AAQD;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,GAAG,IAAI,CAW5F"}

package/dest/base-wallet/get_gas_limits.js

@@ -0,0 +1,55 @@
+import { MAX_PROCESSABLE_L2_GAS, MAX_TX_DA_GAS } from '@aztec/constants';
+import { Gas } from '@aztec/stdlib/gas';
+/**
+ * Returns suggested total and teardown gas limits for a simulated tx, clamped to the network's per-tx
+ * admission limits.
+ *
+ * The network only admits transactions that declare up to `maxTxGasLimits` per dimension (the
+ * node-advertised `txsLimits.gas`). Wallets pass the value read from their own node info, but since node info
+ * is remote input it is defensively clamped here to the per-tx protocol maxima so a value above them is never
+ * honored. If the simulated usage already exceeds the resulting admission limits the tx can never be included,
+ * so this throws a descriptive error instead of returning a limit the node would reject. Otherwise it pads the
+ * usage and clamps each dimension to the admission limit.
+ * @param gasUsed - The gas actually consumed during simulation.
+ * @param maxTxGasLimits - The maximum gas a single tx may declare on this network (the node-advertised `txsLimits.gas`).
+ * @param pad - Fraction to pad the suggested gas limits by (as a decimal, e.g. 0.1 for 10%). The effective
+ * padding shrinks to zero as usage approaches the network limit, since the network will not admit a higher
+ * declared limit regardless of the buffer.
+ */ export function getGasLimits(gasUsed, maxTxGasLimits, pad = 0.1) {
+    const { totalGas, teardownGas } = gasUsed;
+    // `maxTxGasLimits` is the node-advertised admission limit. Node info is remote input, so we defensively
+    // clamp to the per-tx protocol maxima so a value above them can never be honored.
+    const maxLimits = new Gas(Math.min(maxTxGasLimits.daGas, MAX_TX_DA_GAS), Math.min(maxTxGasLimits.l2Gas, MAX_PROCESSABLE_L2_GAS));
+    // The simulated usage must fit within the admission limits, otherwise the tx can never be included.
+    if (totalGas.daGas > maxLimits.daGas) {
+        throw new Error(`Transaction consumes ${totalGas.daGas} DA gas but the network only admits transactions declaring up to ${maxLimits.daGas} DA gas`);
+    }
+    if (totalGas.l2Gas > maxLimits.l2Gas) {
+        throw new Error(`Transaction consumes ${totalGas.l2Gas} L2 gas but the network only admits transactions declaring up to ${maxLimits.l2Gas} L2 gas`);
+    }
+    // Pad the limits by the buffer, then cap each dimension at the admission limit so the buffer cannot push a
+    // declared limit past what inbound validation accepts. Teardown is part of the total, so clamping it to the
+    // admission limit is safe.
+    return {
+        gasLimits: padGas(totalGas, pad, maxLimits),
+        teardownGasLimits: padGas(teardownGas, pad, maxLimits)
+    };
+}
+/** Pads each gas dimension, capping it at the network admission limit. */ function padGas(gas, pad, cap) {
+    const padded = gas.mul(1 + pad);
+    return new Gas(Math.min(padded.daGas, cap.daGas), Math.min(padded.l2Gas, cap.l2Gas));
+}
+/**
+ * Validates that caller-declared gas limits do not exceed the network's per-tx admission limits, throwing a
+ * descriptive error per dimension when they do. The node's inbound validation checks declared
+ * `gasSettings.gasLimits`, so we mirror that here to surface the rejection locally before the tx is sent.
+ * @param gasLimits - The gas limits the transaction will declare.
+ * @param maxTxGasLimits - The maximum gas a single tx may declare on this network (the node-advertised `txsLimits.gas`).
+ */ export function assertGasLimitsWithinNetworkLimits(gasLimits, maxTxGasLimits) {
+    if (gasLimits.daGas > maxTxGasLimits.daGas) {
+        throw new Error(`Declared DA gas limit (${gasLimits.daGas}) exceeds the maximum this network allows per tx (${maxTxGasLimits.daGas})`);
+    }
+    if (gasLimits.l2Gas > maxTxGasLimits.l2Gas) {
+        throw new Error(`Declared L2 gas limit (${gasLimits.l2Gas}) exceeds the maximum this network allows per tx (${maxTxGasLimits.l2Gas})`);
+    }
+}

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

@@ -1,2 +1,4 @@
-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';
+export { getGasLimits, assertGasLimitsWithinNetworkLimits } from './get_gas_limits.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlLXdhbGxldC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsVUFBVSxFQUNWLEtBQUssd0JBQXdCLEVBQzdCLEtBQUssVUFBVSxFQUNmLEtBQUssNEJBQTRCLEdBQ2xDLE1BQU0sa0JBQWtCLENBQUM7QUFDMUIsT0FBTyxFQUFFLGVBQWUsRUFBRSwyQkFBMkIsRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMvRyxPQUFPLEVBQUUsWUFBWSxFQUFFLGtDQUFrQyxFQUFFLE1BQU0scUJBQXFCLENBQUMifQ==