@aztec/wallet-sdk 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/src/base-wallet/base_wallet.ts

@@ -21,22 +21,17 @@ import {
   type ProfileOptions,
   type SendOptions,
   type SimulateOptions,
+  TxSimulationResultWithAppOffset,
   type Wallet,
   type WalletCapabilities,
 } from '@aztec/aztec.js/wallet';
-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 { AccountFeePaymentMethodOptions, type DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
 import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 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 { displayDebugLogs } from '@aztec/pxe/client/lazy';
 import type { PXE, PackedPrivateEvent } from '@aztec/pxe/server';
 import {
   type ContractArtifact,
@@ -46,29 +41,27 @@ import {
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractInstanceWithAddress,
-  computePartialAddress,
-  getContractClassFromArtifact,
-} from '@aztec/stdlib/contract';
+import { type ContractInstancePreimage, type NodeInfo, computePartialAddress } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import { Gas, GasFees, GasSettings, ManaUsageEstimate } from '@aztec/stdlib/gas';
 import {
   computeSiloedPrivateInitializationNullifier,
   computeSiloedPublicInitializationNullifier,
 } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { type MasterSecretKeys, deriveKeys, deriveKeysFromMasterSecretKeys } from '@aztec/stdlib/keys';
 import {
   BlockHeader,
+  ExecutionPayload,
   type TxExecutionRequest,
   type TxProfileResult,
-  TxSimulationResult,
   type UtilityExecutionResult,
+  mergeExecutionPayloads,
 } from '@aztec/stdlib/tx';
-import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import { inspect } from 'util';
 
+import { assertGasLimitsWithinNetworkLimits } from './get_gas_limits.js';
 import { buildMergedSimulationResult, extractOptimizablePublicStaticCalls, simulateViaNode } from './utils.js';
 
 /**
@@ -89,19 +82,41 @@ export type FeeOptions = {
 /** Options for `simulateViaEntrypoint`. */
 export type SimulateViaEntrypointOptions = Pick<
   SimulateOptions,
-  'from' | 'additionalScopes' | 'skipTxValidation' | 'skipFeeEnforcement'
+  'from' | 'additionalScopes' | 'skipTxValidation' | 'skipFeeEnforcement' | 'sendMessagesAs' | 'overrides'
 > & {
   /** Fee options for the entrypoint */
   feeOptions: FeeOptions;
-  /** Scopes to use for the simulation */
-  scopes: AccessScopes;
 };
+
+/** Options for `completeFeeOptions`. */
+export type CompleteFeeOptionsConfig = {
+  /** The address where the transaction is being sent from. */
+  from: AztecAddress | NoFrom;
+  /** The address paying for fees (if any fee payment method is embedded in the execution payload). */
+  feePayer?: AztecAddress;
+  /** User-provided partial gas settings. */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+  /** If true, returns gas settings with high gas limits for estimation. If false, uses fallback limits. */
+  forEstimation?: boolean;
+  /**
+   * Assumed network congestion level for fee prediction. Controls how aggressively the wallet
+   * estimates future fees. Defaults to Limit (worst case) when not specified.
+   */
+  congestionEstimate?: ManaUsageEstimate;
+};
+
 /**
  * A base class for Wallet implementations
  */
 export abstract class BaseWallet implements Wallet {
   protected minFeePadding = 0.5;
   protected cancellableTransactions = false;
+  // 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.
+  protected defaultWaitInterval?: number;
+  // 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.).
+  private nodeInfoPromise: Promise<NodeInfo> | undefined;
 
   // Protected because we want to force wallets to instantiate their own PXE.
   protected constructor(
@@ -113,7 +128,18 @@ export abstract class BaseWallet implements Wallet {
   protected scopesFrom(from: AztecAddress | NoFrom, additionalScopes: AztecAddress[] = []): AztecAddress[] {
     const allScopes = from === NO_FROM ? additionalScopes : [from, ...additionalScopes];
     const scopeSet = new Set(allScopes.map(address => address.toString()));
-    return [...scopeSet].map(AztecAddress.fromString);
+    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.
+   */
+  protected senderForTagsFrom(from: AztecAddress | NoFrom, sendMessagesAs?: AztecAddress): AztecAddress | undefined {
+    return sendMessagesAs ?? (from === NO_FROM ? undefined : from);
   }
 
   protected abstract getAccountFromAddress(address: AztecAddress): Promise<Account>;
@@ -128,15 +154,42 @@ export abstract class BaseWallet implements Wallet {
    * @returns The aliased collection of AztecAddresses that form this wallet's address book
    */
   async getAddressBook(): Promise<Aliased<AztecAddress>[]> {
-    const senders: AztecAddress[] = await this.pxe.getSenders();
-    return senders.map(sender => ({ item: sender, alias: '' }));
+    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.
+   */
+  private getNodeInfo(): Promise<NodeInfo> {
+    if (!this.nodeInfoPromise) {
+      this.nodeInfoPromise = this.aztecNode.getNodeInfo().catch(err => {
+        this.nodeInfoPromise = undefined;
+        throw err;
+      });
+    }
+    return this.nodeInfoPromise;
   }
 
   async getChainInfo(): Promise<ChainInfo> {
-    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.
+   */
+  protected async getMaxTxGasLimits(): Promise<Gas> {
+    const { txsLimits } = await this.getNodeInfo();
+    return new Gas(txsLimits.gas.daGas, txsLimits.gas.l2Gas);
+  }
+
   protected async createTxExecutionRequestFromPayloadAndFee(
     executionPayload: ExecutionPayload,
     from: AztecAddress | NoFrom,
@@ -214,18 +267,12 @@ export abstract class BaseWallet implements Wallet {
 
   /**
    * 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
+   * @param config - Fee completion config.
    */
-  protected async completeFeeOptions(
-    from: AztecAddress | NoFrom,
-    feePayer?: AztecAddress,
-    gasSettings?: Partial<FieldsOf<GasSettings>>,
-  ): Promise<FeeOptions> {
+  protected async completeFeeOptions(config: CompleteFeeOptionsConfig): Promise<FeeOptions> {
+    const { from, feePayer, gasSettings, forEstimation, congestionEstimate } = config;
     const maxFeesPerGas =
-      gasSettings?.maxFeesPerGas ?? (await this.aztecNode.getCurrentMinFees()).mul(1 + this.minFeePadding);
+      gasSettings?.maxFeesPerGas ?? (await this.getMinFees(congestionEstimate)).mul(1 + this.minFeePadding);
     let accountFeePaymentMethodOptions;
     // If from is an address, we need to determine the appropriate fee payment method options for the
     // account contract entrypoint to use
@@ -242,7 +289,32 @@ export abstract class BaseWallet implements Wallet {
           : AccountFeePaymentMethodOptions.EXTERNAL;
       }
     }
-    const fullGasSettings: GasSettings = 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 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 {
+      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,
+      });
+    }
     this.log.debug(`Using L2 gas settings`, fullGasSettings);
     return {
       gasSettings: fullGasSettings,
@@ -252,76 +324,67 @@ export abstract class BaseWallet implements Wallet {
   }
 
   /**
-   * 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
+   * 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.
    */
-  protected async completeFeeOptionsForEstimation(
-    from: AztecAddress | NoFrom,
-    feePayer?: AztecAddress,
-    gasSettings?: Partial<FieldsOf<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,
-    };
+  protected async getMinFees(estimate: ManaUsageEstimate = ManaUsageEstimate.Limit): Promise<GasFees> {
+    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: any) {
+      // 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: AztecAddress, _alias: string = ''): Promise<AztecAddress> {
-    return this.pxe.registerSender(address);
+  async registerSender(address: AztecAddress, _alias: string = ''): Promise<AztecAddress> {
+    await this.pxe.registerTaggingSecretSource({ kind: 'address-derived', sender: address });
+    return address;
   }
 
   async registerContract(
-    instance: ContractInstanceWithAddress,
+    instance: ContractInstancePreimage,
     artifact?: ContractArtifact,
-    secretKey?: Fr,
-  ): Promise<ContractInstanceWithAddress> {
-    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()}`,
-          );
-        }
+    secretKeyOrKeys?: Fr | MasterSecretKeys,
+  ): Promise<void> {
+    // 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));
-    }
-    return instance;
+  registerContractClass(artifact: ContractArtifact): Promise<void> {
+    return this.pxe.registerContractClass(artifact);
   }
 
   /**
@@ -335,12 +398,30 @@ export abstract class BaseWallet implements Wallet {
       opts.from,
       opts.feeOptions,
     );
-    return this.pxe.simulateTx(txRequest, {
+    const result = await this.pxe.simulateTx(txRequest, {
       simulatePublic: true,
       skipTxValidation: opts.skipTxValidation,
       skipFeeEnforcement: opts.skipFeeEnforcement,
-      scopes: opts.scopes,
+      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.
+   */
+  protected async computeAppCallOffset(from: AztecAddress | NoFrom, feeOptions: FeeOptions): Promise<number> {
+    if (from === NO_FROM) {
+      return 0;
+    }
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    return (feeExecutionPayload?.calls.length ?? 0) + 1; // +1 for entrypoint
   }
 
   /**
@@ -351,10 +432,17 @@ export abstract class BaseWallet implements Wallet {
    * @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);
+  async simulateTx(
+    executionPayload: ExecutionPayload,
+    opts: SimulateOptions,
+  ): Promise<TxSimulationResultWithAppOffset> {
+    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 };
 
@@ -365,7 +453,7 @@ export abstract class BaseWallet implements Wallet {
     try {
       blockHeader = await this.pxe.getSyncedBlockHeader();
     } catch {
-      blockHeader = (await this.aztecNode.getBlockHeader())!;
+      blockHeader = (await this.aztecNode.getBlockData('latest'))!.header;
     }
 
     const simulationOrigin = opts.from === NO_FROM ? AztecAddress.ZERO : opts.from;
@@ -380,15 +468,18 @@ export abstract class BaseWallet implements Wallet {
             blockHeader,
             opts.skipFeeEnforcement ?? true,
             this.getContractName.bind(this),
+            opts.overrides,
           )
         : Promise.resolve([]),
       remainingCalls.length > 0
         ? this.simulateViaEntrypoint(remainingPayload, {
             from: opts.from,
             feeOptions,
-            scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+            additionalScopes: opts.additionalScopes,
             skipTxValidation: opts.skipTxValidation,
             skipFeeEnforcement: opts.skipFeeEnforcement ?? true,
+            sendMessagesAs: opts.sendMessagesAs,
+            overrides: opts.overrides,
           })
         : Promise.resolve(null),
     ]);
@@ -397,12 +488,18 @@ export abstract class BaseWallet implements Wallet {
   }
 
   async profileTx(executionPayload: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
-    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, {
       profileMode: opts.profileMode,
       skipProofGeneration: opts.skipProofGeneration ?? true,
       scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+      senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs),
     });
   }
 
@@ -410,16 +507,24 @@ export abstract class BaseWallet implements Wallet {
     executionPayload: ExecutionPayload,
     opts: SendOptions<W>,
   ): Promise<SendReturn<W>> {
-    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, this.scopesFrom(opts.from, opts.additionalScopes));
+    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}`);
@@ -434,11 +539,15 @@ export abstract class BaseWallet implements Wallet {
     }
 
     // Otherwise, wait for the full receipt (default behavior on wait: undefined)
-    const waitOpts = typeof opts.wait === 'object' ? opts.wait : undefined;
+    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.debugLogs?.length) {
+    if (receipt.isMined() && receipt.debugLogs?.length) {
       await displayDebugLogs(receipt.debugLogs, this.getContractName.bind(this));
     }
 
@@ -454,7 +563,11 @@ export abstract class BaseWallet implements Wallet {
     if (!instance) {
       return undefined;
     }
-    const artifact = await this.pxe.getContractArtifact(instance.currentContractClassId);
+    // 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;
   }
 

package/src/base-wallet/get_gas_limits.ts

@@ -0,0 +1,88 @@
+import { MAX_PROCESSABLE_L2_GAS, MAX_TX_DA_GAS } from '@aztec/constants';
+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 function getGasLimits(
+  gasUsed: GasUsed,
+  maxTxGasLimits: Gas,
+  pad = 0.1,
+): {
+  /**
+   * Gas limit for the tx, excluding teardown gas
+   */
+  gasLimits: Gas;
+  /**
+   * Gas limit for the teardown phase
+   */
+  teardownGasLimits: Gas;
+} {
+  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: Gas, pad: number, cap: Gas): Gas {
+  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: Gas, maxTxGasLimits: Gas): void {
+  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/src/base-wallet/index.ts

@@ -1,2 +1,8 @@
-export { BaseWallet, type FeeOptions, type SimulateViaEntrypointOptions } from './base_wallet.js';
+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';