@miden-sdk/miden-sdk 0.15.6 → 0.15.8

package/dist/mt/api-types.d.ts

@@ -14,6 +14,8 @@ import type {
   TransactionId,
   TransactionRequest,
   TransactionResult,
+  TransactionStoreUpdate,
+  ProvenTransaction,
   TransactionSummary,
   TransactionRecord,
   InputNoteRecord,
@@ -511,6 +513,81 @@ export interface BatchSubmitResult {
   blockNumber: number;
 }
 
+/** Options for {@link TransactionExecution.prove}. */
+export interface ProveOptions {
+  /**
+   * Per-call prover override. Falls back to the client's default prover, or
+   * the built-in local prover if none is configured.
+   *
+   * A prover is consumed by the call — build (or clone) a fresh one per
+   * `prove()`. Reusing an already-passed prover silently falls back to the
+   * built-in local prover.
+   */
+  prover?: TransactionProver;
+}
+
+/**
+ * A locally-executed transaction — nothing proven, submitted, or persisted yet.
+ * First stage of the manual transaction lifecycle, returned by
+ * {@link TransactionsResource.executeRequest}. Advance it with {@link prove}.
+ */
+export interface TransactionExecution {
+  /** The raw execution artifact (account delta, output notes, …). */
+  readonly result: TransactionResult;
+  /** The executed transaction's id. */
+  readonly id: TransactionId;
+  /**
+   * Prove this execution, then continue with {@link TransactionProof.submit}.
+   * Pure computation — touches neither the network nor the local store.
+   *
+   * @param options - Optional per-call prover override.
+   */
+  prove(options?: ProveOptions): Promise<TransactionProof>;
+}
+
+/**
+ * A proven transaction, ready for the network. Second stage of the manual
+ * transaction lifecycle, returned by {@link TransactionExecution.prove}.
+ * Advance it with {@link submit}.
+ */
+export interface TransactionProof {
+  /** The raw proof — e.g. to serialize and submit from a different client. */
+  readonly proof: ProvenTransaction;
+  /** The execution result this proof was produced from. */
+  readonly result: TransactionResult;
+  /**
+   * Submit the proof to the network, then persist with
+   * {@link TransactionSubmission.apply}. Does NOT persist locally on its own.
+   */
+  submit(): Promise<TransactionSubmission>;
+}
+
+/**
+ * A submitted transaction. Final stage of the manual transaction lifecycle,
+ * returned by {@link TransactionProof.submit}. Persist it with {@link apply},
+ * or block until it commits with {@link waitForConfirmation}.
+ */
+export interface TransactionSubmission {
+  /** The block height the transaction was submitted at. */
+  readonly blockNumber: number;
+  /** The execution result that was submitted. */
+  readonly result: TransactionResult;
+  /**
+   * Persist the transaction into the local store, firing registered
+   * transaction observers (e.g. PSWAP lineage tracking). Until this runs the
+   * local store is unaware of the transaction.
+   *
+   * @returns The pre-apply store update.
+   */
+  apply(): Promise<TransactionStoreUpdate>;
+  /**
+   * Poll local sync height until the transaction commits on-chain.
+   *
+   * @param options - Polling options (timeout, interval, onProgress).
+   */
+  waitForConfirmation(options?: WaitOptions): Promise<void>;
+}
+
 export interface SwapOptions extends TransactionOptions {
   account: AccountRef;
   offer: Asset;
@@ -957,6 +1034,49 @@ export interface TransactionsResource {
     options?: TransactionOptions
   ): Promise<TransactionSubmitResult>;
 
+  /**
+   * Execute a transaction request locally — nothing is proven, submitted, or
+   * persisted. Returns a {@link TransactionExecution} handle; advance the
+   * lifecycle by chaining `.prove()` → `.submit()` → `.apply()`, benchmarking
+   * or error-handling each stage independently:
+   *
+   * ```ts
+   * const executed  = await client.transactions.executeRequest(account, request);
+   * const proven    = await executed.prove({ prover });
+   * const submitted = await proven.submit();
+   * await submitted.apply();
+   * ```
+   *
+   * {@link submit} runs every stage in one call. The stages are not atomic as a
+   * group: awaiting other mutating calls on the same account between them can
+   * interleave state — drive the chain as an uninterrupted sequence per account.
+   *
+   * @param account - The account executing the transaction.
+   * @param request - The pre-built transaction request.
+   * @returns A handle to the executed transaction, ready to prove.
+   */
+  executeRequest(
+    account: AccountRef,
+    request: TransactionRequest
+  ): Promise<TransactionExecution>;
+
+  /**
+   * Submit a proof produced somewhere that shares nothing with this client —
+   * e.g. a detached prover that never saw the local store. Returns a
+   * {@link TransactionSubmission} handle; call `.apply()` on it to persist
+   * locally. For the in-process flow prefer
+   * `executeRequest(...)` → `.prove()` → `.submit()`, which threads the proof
+   * and result for you.
+   *
+   * @param proof - A proof for `result`, proven elsewhere.
+   * @param result - The matching execution result.
+   * @returns A handle to the submitted transaction, ready to apply.
+   */
+  submitProven(
+    proof: ProvenTransaction,
+    result: TransactionResult
+  ): Promise<TransactionSubmission>;
+
   /**
    * Execute a heterogeneous batch of operations against a single account.
    * Each operation is built, proven individually and as a batch, and all

package/dist/mt/crates/miden_client_web.d.ts

@@ -912,6 +912,25 @@ export class AdviceMap {
     constructor();
 }
 
+/**
+ * Whether a faucet's asset callbacks run when an asset is added to an account or a note.
+ *
+ * The flag is part of an asset's vault key, so two assets from the same faucet with different
+ * flags occupy different vault slots and do not merge. Assets minted by a faucet that registers
+ * transfer policies carry `Enabled`; everything else carries `Disabled`.
+ */
+export enum AssetCallbackFlag {
+    /**
+     * The faucet's callbacks are not invoked for this asset. This is the default for an asset
+     * built via the `FungibleAsset` constructor.
+     */
+    Disabled = 0,
+    /**
+     * The faucet's callbacks are invoked before this asset is added to an account or a note.
+     */
+    Enabled = 1,
+}
+
 /**
  * A container for an unlimited number of assets.
  *
@@ -1030,6 +1049,16 @@ export class BasicFungibleFaucetComponent {
      * Extracts faucet metadata from an account.
      */
     static fromAccount(account: Account): BasicFungibleFaucetComponent;
+    /**
+     * Extracts faucet metadata from an account's storage.
+     *
+     * Unlike [`Self::from_account`], this reads the metadata straight from the storage slots
+     * without checking that the account exposes the basic fungible faucet interface. This makes
+     * it work for faucets built from custom components that reuse the standards storage layout
+     * (e.g. `AggLayer` bridged-asset faucets), but it also means a non-faucet account whose
+     * storage happens to use the same slot names would yield bogus metadata without an error.
+     */
+    static fromAccountStorage(account_storage: AccountStorage): BasicFungibleFaucetComponent;
     /**
      * Returns the optional token logo URI, or `undefined` when unset.
      */
@@ -1595,18 +1624,69 @@ export class FungibleAsset {
      * Returns the amount of fungible units.
      */
     amount(): bigint;
+    /**
+     * Returns whether this asset invokes its faucet's callbacks.
+     */
+    callbacks(): AssetCallbackFlag;
     /**
      * Returns the faucet account that minted this asset.
      */
     faucetId(): AccountId;
     /**
-     * Encodes this asset into the word layout used in the vault.
+     * Reconstructs a fungible asset from its vault entry — the `(key, value)`
+     * word pair as stored in an account vault, i.e. the outputs of
+     * [`vaultKey`](Self::vault_key) and [`intoWord`](Self::into_word). The key
+     * word carries the faucet id and the callback flag; the value word carries
+     * the amount. This is the inverse of those getters, so
+     * `FungibleAsset.fromVaultEntry(a.vaultKey(), a.intoWord())` round-trips an
+     * asset read from vault data (callback flag included). Errors if the words
+     * don't describe a valid fungible asset (e.g. a malformed key, non-zero
+     * upper limbs in the value word, or an amount above the maximum fungible
+     * asset amount, `2^63 - 2^31`).
+     */
+    static fromVaultEntry(key: Word, value: Word): FungibleAsset;
+    /**
+     * Reconstructs a fungible asset from its vault key word and a scalar amount.
+     *
+     * A convenience over [`fromVaultEntry`](Self::from_vault_entry) for when you
+     * hold the key word (from [`vaultKey`](Self::vault_key)) and the amount as a
+     * number rather than the value word: the key supplies the faucet id and
+     * callback flag, and the amount is encoded into the value word for you. Use
+     * `fromVaultEntry` when you already have both vault words. Errors on a
+     * malformed key or an amount above the maximum fungible asset amount,
+     * `2^63 - 2^31`.
+     */
+    static fromVaultKey(key: Word, amount: bigint): FungibleAsset;
+    /**
+     * Returns the value word stored under [`vaultKey`](Self::vault_key) in an
+     * account vault. For a fungible asset the value word encodes the amount.
+     *
+     * This is the value half of the vault entry; pair it with `vaultKey()` and
+     * pass both to [`fromVaultEntry`](Self::from_vault_entry) to reconstruct the
+     * asset.
      */
     intoWord(): Word;
     /**
      * Creates a fungible asset for the given faucet and amount.
      */
     constructor(faucet_id: AccountId, amount: bigint);
+    /**
+     * Returns the key word under which this asset is stored in an account vault.
+     *
+     * The key encodes the faucet id and the callback flag; the amount lives in
+     * the paired value word from [`intoWord`](Self::into_word). Pass both back
+     * into [`fromVaultEntry`](Self::from_vault_entry) to reconstruct the asset.
+     */
+    vaultKey(): Word;
+    /**
+     * Returns a copy of this asset carrying the given callback flag.
+     *
+     * The flag is part of the asset's vault key, so it must match the flag the issuing faucet
+     * applies — an asset built with the wrong flag addresses a different vault slot than the one
+     * holding the balance. The constructor always produces `Disabled`; pass `Enabled` only for
+     * assets from a faucet that registers transfer policies.
+     */
+    withCallbacks(callbacks: AssetCallbackFlag): FungibleAsset;
 }
 
 /**

package/dist/mt/docs-entry.d.ts

@@ -24,6 +24,7 @@ export {
   NoteFile,
   NoteId,
   NoteTag,
+  ProvenTransaction,
   PswapLineageRecord,
   PswapLineageState,
   RawOutputNote,
@@ -33,6 +34,8 @@ export {
   TransactionProver,
   TransactionRecord,
   TransactionRequest,
+  TransactionResult,
+  TransactionStoreUpdate,
   TransactionSummary,
   Word,
 } from "./crates/miden_client_web.js";

package/dist/mt/eager.js

@@ -1,6 +1,6 @@
 import { getWasmOrThrow } from './index.js';
 export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWasmWebClient, MockWasmWebClient as MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, withSyncLock, wordToBigInt } from './index.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-mvyTli7g.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetCallbackFlag, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-CvYxNO9A.js';
 import './wasm.js';
 
 // Eager entry point for @miden-sdk/miden-sdk (browser builds).

package/dist/mt/index.js

@@ -1,5 +1,5 @@
 import loadWasm from './wasm.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-mvyTli7g.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetCallbackFlag, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, EthAddress, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsSettingMutation, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkAccountTarget, NetworkId, NetworkNoteStatusInfo, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteArray, NoteAssets, NoteAttachment, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PswapLineageRecord, PswapLineageState, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapEntryJs, StorageMapInfo, StorageMapUpdate, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, initThreadPool, mtProbeAsync, mtProbeSync, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-CvYxNO9A.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -547,6 +547,26 @@ class AccountsResource {
   }
 }
 
+/**
+ * Prove an executed transaction, resolving the prover exactly the way the
+ * one-shot `submit()` pipeline does: the per-call prover if given, else the
+ * client's default prover, else the built-in local prover. Shared by
+ * {@link TransactionExecution.prove} and the internal pipeline so the two can
+ * never drift.
+ *
+ * @param {*} inner - The WASM WebClient.
+ * @param {*} defaultProver - The client's configured default prover, or null.
+ * @param {*} result - The execution result to prove.
+ * @param {{ prover?: * }} [opts] - Optional per-call prover override.
+ * @returns {Promise<*>} The proven transaction.
+ */
+async function proveResult(inner, defaultProver, result, opts) {
+  const prover = opts?.prover ?? defaultProver;
+  return prover
+    ? await inner.proveTransaction(result, prover)
+    : await inner.proveTransaction(result);
+}
+
 class TransactionsResource {
   #inner;
   #getWasm;
@@ -1188,6 +1208,65 @@ class TransactionsResource {
     );
   }
 
+  /**
+   * Execute a transaction request locally — nothing is proven, submitted, or
+   * persisted. Returns a {@link TransactionExecution} handle; advance the
+   * lifecycle by chaining `.prove()` → `.submit()` → `.apply()`, benchmarking
+   * or error-handling each stage independently. Use {@link submit} to run every
+   * stage in one call.
+   *
+   * ```ts
+   * const executed  = await client.transactions.executeRequest(account, request);
+   * const proven    = await executed.prove({ prover });
+   * const submitted = await proven.submit();
+   * await submitted.apply();
+   * ```
+   *
+   * The stages are NOT atomic as a group: awaiting other mutating calls on the
+   * same account between them can interleave state. Drive the chain as an
+   * uninterrupted sequence per account.
+   *
+   * @param {AccountRef} account - The account executing the transaction.
+   * @param {TransactionRequest} request - The pre-built transaction request.
+   * @returns {Promise<TransactionExecution>} A handle to the executed
+   *   transaction, ready to prove.
+   */
+  async executeRequest(account, request) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(account, wasm);
+    const result = await this.#inner.executeTransaction(accountId, request);
+    return new TransactionExecution(this.#inner, this.#client, this, result);
+  }
+
+  /**
+   * Submit a proof produced somewhere that shares nothing with this client —
+   * e.g. a detached prover that never saw the local store. Returns a
+   * {@link TransactionSubmission} handle; call `.apply()` on it to persist
+   * locally. For the in-process flow prefer
+   * `executeRequest(...)` → `.prove()` → `.submit()`, which threads the proof
+   * and result for you.
+   *
+   * @param {ProvenTransaction} proof - A proof for `result`, proven elsewhere.
+   * @param {TransactionResult} result - The matching execution result.
+   * @returns {Promise<TransactionSubmission>} A handle to the submitted
+   *   transaction, ready to apply.
+   */
+  async submitProven(proof, result) {
+    this.#client.assertNotTerminated();
+    const blockNumber = await this.#inner.submitProvenTransaction(
+      proof,
+      result
+    );
+    return new TransactionSubmission(
+      this.#inner,
+      this.#client,
+      this,
+      result,
+      blockNumber
+    );
+  }
+
   async list(query) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -1478,10 +1557,12 @@ class TransactionsResource {
 
   async #submitOrSubmitWithProver(accountId, request, perCallProver) {
     const result = await this.#inner.executeTransaction(accountId, request);
-    const prover = perCallProver ?? this.#client.defaultProver;
-    const proven = prover
-      ? await this.#inner.proveTransaction(result, prover)
-      : await this.#inner.proveTransaction(result);
+    const proven = await proveResult(
+      this.#inner,
+      this.#client.defaultProver,
+      result,
+      { prover: perCallProver }
+    );
     const txId = result.id();
     const height = await this.#inner.submitProvenTransaction(proven, result);
     await this.#inner.applyTransaction(result, height);
@@ -1489,6 +1570,172 @@ class TransactionsResource {
   }
 }
 
+/**
+ * A locally-executed transaction — nothing proven, submitted, or persisted yet.
+ * First stage of the manual transaction lifecycle, returned by
+ * {@link TransactionsResource.executeRequest}. Advance it with {@link prove}.
+ */
+class TransactionExecution {
+  #inner;
+  #client;
+  #resource;
+  #result;
+
+  constructor(inner, client, resource, result) {
+    this.#inner = inner;
+    this.#client = client;
+    this.#resource = resource;
+    this.#result = result;
+  }
+
+  /** The raw execution artifact (account delta, output notes, …). */
+  get result() {
+    return this.#result;
+  }
+
+  /** The executed transaction's id. */
+  get id() {
+    return this.#result.id();
+  }
+
+  /**
+   * Prove this execution. Uses the per-call prover when provided, falling back
+   * to the client's default prover (or the built-in local prover). Pure
+   * computation — touches neither the network nor the local store.
+   *
+   * A `TransactionProver` is consumed by the call: build (or clone) a fresh
+   * prover per `prove()`. Reusing an already-passed prover silently falls back
+   * to the built-in local prover.
+   *
+   * @param {ProveOptions} [opts] - Optional per-call prover override.
+   * @returns {Promise<TransactionProof>} A handle to the proven transaction,
+   *   ready to submit.
+   */
+  async prove(opts) {
+    this.#client.assertNotTerminated();
+    const proven = await proveResult(
+      this.#inner,
+      this.#client.defaultProver,
+      this.#result,
+      opts
+    );
+    return new TransactionProof(
+      this.#inner,
+      this.#client,
+      this.#resource,
+      proven,
+      this.#result
+    );
+  }
+}
+
+/**
+ * A proven transaction, ready for the network. Second stage of the manual
+ * transaction lifecycle, returned by {@link TransactionExecution.prove}.
+ * Advance it with {@link submit}.
+ */
+class TransactionProof {
+  #inner;
+  #client;
+  #resource;
+  #proof;
+  #result;
+
+  constructor(inner, client, resource, proof, result) {
+    this.#inner = inner;
+    this.#client = client;
+    this.#resource = resource;
+    this.#proof = proof;
+    this.#result = result;
+  }
+
+  /** The raw proof — e.g. to serialize and submit from a different client. */
+  get proof() {
+    return this.#proof;
+  }
+
+  /** The execution result this proof was produced from. */
+  get result() {
+    return this.#result;
+  }
+
+  /**
+   * Submit the proof to the network. Does NOT persist locally — call
+   * {@link TransactionSubmission.apply} on the returned handle; skipping it
+   * leaves the local store out of sync until the next full sync.
+   *
+   * @returns {Promise<TransactionSubmission>} A handle to the submitted
+   *   transaction, ready to apply.
+   */
+  async submit() {
+    this.#client.assertNotTerminated();
+    const blockNumber = await this.#inner.submitProvenTransaction(
+      this.#proof,
+      this.#result
+    );
+    return new TransactionSubmission(
+      this.#inner,
+      this.#client,
+      this.#resource,
+      this.#result,
+      blockNumber
+    );
+  }
+}
+
+/**
+ * A submitted transaction. Final stage of the manual transaction lifecycle,
+ * returned by {@link TransactionProof.submit}. Persist it locally with
+ * {@link apply}, or block until it commits with {@link waitForConfirmation}.
+ */
+class TransactionSubmission {
+  #inner;
+  #client;
+  #resource;
+  #result;
+  #blockNumber;
+
+  constructor(inner, client, resource, result, blockNumber) {
+    this.#inner = inner;
+    this.#client = client;
+    this.#resource = resource;
+    this.#result = result;
+    this.#blockNumber = blockNumber;
+  }
+
+  /** The block height the transaction was submitted at. */
+  get blockNumber() {
+    return this.#blockNumber;
+  }
+
+  /** The execution result that was submitted. */
+  get result() {
+    return this.#result;
+  }
+
+  /**
+   * Persist the transaction into the local store, firing registered
+   * transaction observers (e.g. PSWAP lineage tracking). Until this runs the
+   * local store is unaware of the transaction.
+   *
+   * @returns {Promise<TransactionStoreUpdate>} The pre-apply store update.
+   */
+  async apply() {
+    this.#client.assertNotTerminated();
+    return await this.#inner.applyTransaction(this.#result, this.#blockNumber);
+  }
+
+  /**
+   * Poll local sync height until the transaction commits on-chain. Convenience
+   * wrapper over {@link TransactionsResource.waitFor}.
+   *
+   * @param {WaitOptions} [opts] - Polling options (timeout, interval, onProgress).
+   */
+  async waitForConfirmation(opts) {
+    return await this.#resource.waitFor(this.#result.id().toHex(), opts);
+  }
+}
+
 class NotesResource {
   #inner;
   #getWasm;
@@ -2885,6 +3132,33 @@ function installStorageView(wasmModule) {
     const raw = originalStorage.call(this);
     return new StorageView(raw, WordClass);
   };
+
+  // WASM statics that take a raw AccountStorage argument must accept the
+  // StorageView that account.storage() now returns — unwrap it before the
+  // wasm-bindgen instanceof guard rejects it. The napi class freezes its
+  // statics (non-writable, non-configurable) so it cannot be patched here;
+  // its Rust-side FromNapiValue impl accepts StorageView natively instead.
+  const FaucetComponent = wasmModule.BasicFungibleFaucetComponent;
+  const descriptor =
+    FaucetComponent &&
+    Object.getOwnPropertyDescriptor(FaucetComponent, "fromAccountStorage");
+  if (
+    descriptor?.value &&
+    (descriptor.writable || descriptor.configurable) &&
+    !descriptor.value.__unwrapsStorageView
+  ) {
+    const originalFromStorage = descriptor.value.bind(FaucetComponent);
+    const unwrapping = (storage) =>
+      originalFromStorage(
+        storage instanceof StorageView ? storage.raw : storage
+      );
+    unwrapping.__unwrapsStorageView = true;
+    Object.defineProperty(FaucetComponent, "fromAccountStorage", {
+      value: unwrapping,
+      writable: true,
+      configurable: true,
+    });
+  }
 }
 
 const AccountType = Object.freeze({