@miden-sdk/miden-sdk 0.14.5 → 0.14.9

package/dist/{crates → st/crates}/miden_client_web.d.ts

@@ -3885,6 +3885,28 @@ export class TransactionProver {
      * Returns the endpoint if this is a remote prover.
      */
     endpoint(): string | undefined;
+    /**
+     * Creates a prover that delegates `prove()` to a JavaScript callback.
+     *
+     * The callback receives the serialized [`TransactionInputs`] as a
+     * `Uint8Array` and must return a `Promise<Uint8Array>` resolving to a
+     * serialized [`ProvenTransaction`] (same encoding the gRPC remote
+     * prover uses: `tx_inputs.to_bytes()` in, `ProvenTransaction::read_from_bytes`
+     * out).
+     *
+     * Use case: routing prove to a native iOS / Android plugin
+     * (`@miden/native-prover`) so mobile builds skip WASM prove entirely
+     * — `WKWebView` can't be made cross-origin-isolated reliably and the
+     * MT WASM bundle can't instantiate without `SharedArrayBuffer`, so the
+     * host wraps a native Rust prover (built with the same `miden_tx`
+     * crate) and exposes a JS-shaped callback over the Capacitor bridge.
+     *
+     * The SDK does NOT serialize the prover for persistence across
+     * reloads (unlike `newRemoteProver`), since the callback is a
+     * runtime JS reference. Hosts must recreate the prover on every
+     * page load.
+     */
+    static newCallbackProver(callback: Function): TransactionProver;
     /**
      * Creates a prover that uses the local proving backend.
      */
@@ -4651,6 +4673,15 @@ export { exportStore2 as exportStore }
  */
 export function importStore(store_name: string, store_dump: string): Promise<void>;
 
+/**
+ * Single-threaded version of `parallel_sum_bench` for direct comparison.
+ * Same workload, plain `iter()` — bypasses rayon entirely. Needs to live
+ * on the WASM side rather than be reimplemented in JS so the workload is
+ * bit-for-bit identical to `parallel_sum_bench` (same libm, same FP
+ * determinism, same constant-folding resistance).
+ */
+export function sequentialSumBench(n: bigint): bigint;
+
 /**
  * Initializes the `tracing` subscriber that routes Rust log output to the
  * browser console via `console.log` / `console.warn` / `console.error`.

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

@@ -0,0 +1,35 @@
+/**
+ * TypeDoc entry point — curated subset of the public API.
+ * Only types listed here (or transitively referenced) appear in generated docs.
+ * Runtime consumers should import from index.d.ts, not this file.
+ */
+
+// Curated WASM re-exports: only types referenced in the public API
+export {
+  Account,
+  AccountCode,
+  AccountFile,
+  AccountHeader,
+  AccountId,
+  AccountStorage,
+  AssetVault,
+  Felt,
+  InputNoteRecord,
+  Note,
+  NoteExportFormat,
+  NoteFile,
+  NoteId,
+  NoteTag,
+  RawOutputNote,
+  OutputNoteRecord,
+  SyncSummary,
+  TransactionId,
+  TransactionProver,
+  TransactionRecord,
+  TransactionRequest,
+  TransactionSummary,
+  Word,
+} from "./crates/miden_client_web.js";
+
+// All simplified API types
+export * from "./api-types.js";

package/dist/{eager.js → st/eager.js}

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

package/dist/st/eager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eager.js","sources":["../../js/eager.js"],"sourcesContent":["// Eager entry point for @miden-sdk/miden-sdk.\n//\n// Awaits WASM initialization at module top level, so importing this module\n// guarantees that any wasm-bindgen constructor (`new RpcClient(...)`,\n// `AccountId.fromHex(...)`, `TransactionProver.newRemoteProver(...)`, etc.)\n// is safe to call synchronously on the next line. No explicit\n// `await MidenClient.ready()` / `isReady` gate is required.\n//\n// This is the default entry (`@miden-sdk/miden-sdk` → `./dist/eager.js`).\n//\n// When NOT to use this entry:\n// - **Capacitor mobile apps** (Miden Wallet iOS/Android): Capacitor's\n//   `capacitor://localhost` scheme handler interacts poorly with top-level\n//   await in the main WKWebView. Verified empirically: TLA in a Capacitor\n//   host WKWebView hangs module evaluation indefinitely, while the same\n//   TLA in the dApp-browser WKWebView (vanilla HTTPS) resolves in <100ms.\n// - **Next.js / SSR**: TLA blocks server-side module evaluation.\n// - **Framework adapters (@miden-sdk/react, etc.)**: they manage readiness\n//   via their own state machine (e.g. `isReady`) and should not impose\n//   TLA on consumer bundles.\n//\n// For those contexts, import from `@miden-sdk/miden-sdk/lazy` — identical\n// API surface, no top-level await, callers are responsible for awaiting\n// `MidenClient.ready()` (or the equivalent) before touching wasm-bindgen\n// types.\nimport { getWasmOrThrow } from \"./index.js\";\n\nawait getWasmOrThrow();\n\nexport * from \"./index.js\";\n"],"names":[],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,MAAM,cAAc,EAAE;;;;"}

package/dist/st/index.d.ts

@@ -0,0 +1,89 @@
+// Re-export everything from the WASM module
+export * from "./crates/miden_client_web.js";
+
+// Re-export all simplified API types
+export * from "./api-types.js";
+
+// Explicit re-export to shadow the wasm-bindgen `AuthScheme` enum declared
+// in `./crates/miden_client_web` with the user-facing string constant plus
+// merged string-union type from `./api-types`. Without this, `export *`
+// makes the name ambiguous and TypeScript resolves to the crates enum,
+// breaking `AuthScheme.Falcon` / `AuthScheme.ECDSA` lookups.
+export { AuthScheme, resolveAuthScheme } from "./api-types.js";
+
+// Import types needed for the @internal class declarations below
+import type {
+  WebClient as WasmWebClientBase,
+  SyncSummary,
+} from "./crates/miden_client_web.js";
+import type {
+  GetKeyCallback,
+  InsertKeyCallback,
+  SignCallback,
+} from "./api-types.js";
+
+export type LogLevel =
+  | "error"
+  | "warn"
+  | "info"
+  | "debug"
+  | "trace"
+  | "off"
+  | "none";
+
+/**
+ * Initializes the tracing subscriber that routes Rust log output to the
+ * browser console. Call once per thread (main thread / Web Worker).
+ * Subsequent calls on the same thread are harmless no-ops.
+ *
+ * @param logLevel - The maximum log level to display.
+ */
+export declare function setupLogging(logLevel: LogLevel): void;
+
+// ════════════════════════════════════════════════════════════════
+// Internal exports (not public API — for tests and advanced usage)
+// ════════════════════════════════════════════════════════════════
+
+/** @internal Low-level WebClient wrapper. Use MidenClient instead. */
+export declare class WasmWebClient extends WasmWebClientBase {
+  static createClient(
+    rpcUrl?: string,
+    noteTransportUrl?: string,
+    seed?: Uint8Array,
+    storeName?: string,
+    logLevel?: LogLevel,
+    useWorker?: boolean
+  ): Promise<WasmWebClient>;
+
+  static createClientWithExternalKeystore(
+    rpcUrl?: string,
+    noteTransportUrl?: string,
+    seed?: Uint8Array,
+    storeName?: string,
+    getKeyCb?: GetKeyCallback,
+    insertKeyCb?: InsertKeyCallback,
+    signCb?: SignCallback,
+    logLevel?: LogLevel,
+    useWorker?: boolean
+  ): Promise<WasmWebClient>;
+
+  syncState(): Promise<SyncSummary>;
+  syncStateWithTimeout(timeoutMs: number): Promise<SyncSummary>;
+  setSignCb(signCb: SignCallback | null | undefined): void;
+  onStateChanged(callback: (event: any) => void): (() => void) | undefined;
+  terminate(): void;
+}
+
+/** @internal Low-level MockWebClient wrapper. Use MidenClient.createMock() instead. */
+export declare class MockWasmWebClient extends WasmWebClient {
+  static createClient(
+    serializedMockChain?: Uint8Array,
+    serializedMockNoteTransportNode?: Uint8Array,
+    seed?: Uint8Array,
+    logLevel?: LogLevel
+  ): Promise<MockWasmWebClient>;
+
+  proveBlock(): void;
+  serializeMockChain(): Uint8Array;
+  serializeMockNoteTransportNode(): Uint8Array;
+}

package/dist/{index.js → st/index.js}

@@ -1,10 +1,11 @@
 import loadWasm from './wasm.js';
-import { AccountArray as AccountArray$1, AccountIdArray as AccountIdArray$1, FeltArray as FeltArray$1, ForeignAccountArray as ForeignAccountArray$1, NoteAndArgsArray as NoteAndArgsArray$1, NoteArray as NoteArray$1, NoteIdAndArgsArray as NoteIdAndArgsArray$1, NoteRecipientArray as NoteRecipientArray$1, OutputNoteArray as OutputNoteArray$1, StorageSlotArray as StorageSlotArray$1, TransactionScriptInputPairArray as TransactionScriptInputPairArray$1 } from './Cargo-M3382VZc.js';
-export { Account, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapInfo, StorageMapUpdate, StorageSlot, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, setupLogging } from './Cargo-M3382VZc.js';
+import { AccountArray as AccountArray$1, AccountIdArray as AccountIdArray$1, FeltArray as FeltArray$1, ForeignAccountArray as ForeignAccountArray$1, NoteAndArgsArray as NoteAndArgsArray$1, NoteArray as NoteArray$1, NoteIdAndArgsArray as NoteIdAndArgsArray$1, NoteRecipientArray as NoteRecipientArray$1, OutputNoteArray as OutputNoteArray$1, StorageSlotArray as StorageSlotArray$1, TransactionScriptInputPairArray as TransactionScriptInputPairArray$1 } from './Cargo-jOTNoFyS.js';
+export { Account, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapInfo, StorageMapUpdate, StorageSlot, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, sequentialSumBench, setupLogging } from './Cargo-jOTNoFyS.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
   INIT_MOCK: "initMock",
+  INIT_THREAD_POOL: "initThreadPool",
   CALL_METHOD: "callMethod",
   EXECUTE_CALLBACK: "executeCallback",
 });
@@ -109,6 +110,7 @@ async function acquireSyncLock(dbId, timeoutMs = 0) {
       }
 
       const onResult = (result) => {
+        /* v8 ignore next 1 -- timeoutId only set when timeoutMs>0 AND another sync is in progress; combo rare in tests */
         if (timeoutId) clearTimeout(timeoutId);
         resolve({ acquired: false, coalescedResult: result });
       };
@@ -154,6 +156,7 @@ async function acquireSyncLock(dbId, timeoutMs = 0) {
 
       navigator.locks
         .request(lockName, { mode: "exclusive" }, async () => {
+          /* v8 ignore next 3 -- race: lock granted after timeout or newer generation */
           if (timedOut || state.syncGeneration !== currentGeneration) {
             return;
           }
@@ -166,6 +169,9 @@ async function acquireSyncLock(dbId, timeoutMs = 0) {
           });
         })
         .catch((err) => {
+          /* v8 ignore next 5 -- catch path requires Web Locks rejection combined with
+             optional timeout; tested via "rejects when Web Locks request rejects" but
+             the timeoutId-set branch needs Web Locks + timeout simultaneously */
           if (timeoutId) clearTimeout(timeoutId);
           if (state.syncGeneration === currentGeneration) {
             state.inProgress = false;
@@ -1553,6 +1559,52 @@ class MidenClient {
     this.keystore = new KeystoreResource(inner, this);
   }
 
+  /**
+   * Escape hatch: runs `fn` with exclusive access to the proxied JS
+   * WebClient that backs this MidenClient.
+   *
+   * The proxy forwards missing properties to the underlying wasm-bindgen
+   * `WebClient`, so `fn` can reach lower-level methods like
+   * `executeTransaction`, `proveTransaction[WithProver]`,
+   * `submitProvenTransaction`, `applyTransaction`,
+   * `newSendTransactionRequest`, `newConsumeTransactionRequest`, etc.
+   *
+   * Intended for advanced consumers that need to split the bundled
+   * execute → prove → submit → apply pipeline across contexts — for example,
+   * a Chrome MV3 extension that runs `executeTransaction` in its service
+   * worker, dispatches the prove step to a `chrome.offscreen` document
+   * (where wasm-bindgen-rayon can spawn a real thread pool), then runs
+   * `submitProvenTransaction` + `applyTransaction` back in the SW.
+   *
+   * The callback runs inside `_serializeWasmCall`, so the WASM RefCell is
+   * held for the duration of `fn`. Concurrent SDK calls (sync, other
+   * transactions, etc.) queue on the same chain and run after `fn`
+   * settles. Without this serialization, raw inner-client access would
+   * race the proxy's chain and trip wasm-bindgen's "recursive use of an
+   * object detected" panic.
+   *
+   * Stability: marked `@internal`. The shape of the proxied client is
+   * intentionally not part of the documented public API and may change
+   * between SDK versions. If you depend on this method, pin the SDK
+   * version and test the lower-level surface carefully on each upgrade.
+   * If your use case is common enough to warrant a stable public API,
+   * file an issue.
+   *
+   * @internal
+   * @template T
+   * @param {(inner: object) => Promise<T>} fn - Async callback receiving
+   *   the proxied JS WebClient. Must not return references that escape
+   *   the callback's lifetime (the lock is released on settle).
+   * @returns {Promise<T>} The resolved value of `fn`.
+   */
+  _withInnerWebClient(fn) {
+    this.assertNotTerminated();
+    if (typeof fn !== "function") {
+      throw new TypeError("_withInnerWebClient: fn must be a function");
+    }
+    return this.#inner._serializeWasmCall(() => fn(this.#inner));
+  }
+
   /**
    * Creates and initializes a new MidenClient.
    *
@@ -1581,6 +1633,13 @@ class MidenClient {
     const rpcUrl = resolveRpcUrl(options?.rpcUrl);
     const noteTransportUrl = resolveNoteTransportUrl(options?.noteTransportUrl);
 
+    // `useWorker: false` opts out of the Web Worker shim that wraps every
+    // WASM call. The shim exists to keep the main thread responsive in
+    // browser/extension contexts, but it serializes the prover via
+    // `TransactionProver.serialize()` — a format that has no encoding for
+    // `newCallbackProver(jsFn)` and silently downgrades it to `"local"`.
+    // Mobile/Tauri/native-prover consumers must pass `useWorker: false`.
+    const useWorker = options?.useWorker;
     let inner;
     if (options?.keystore) {
       inner = await WebClientClass.createClientWithExternalKeystore(
@@ -1590,14 +1649,18 @@ class MidenClient {
         options?.storeName,
         options.keystore.getKey,
         options.keystore.insertKey,
-        options.keystore.sign
+        options.keystore.sign,
+        undefined,
+        useWorker
       );
     } else {
       inner = await WebClientClass.createClient(
         rpcUrl,
         noteTransportUrl,
         seed,
-        options?.storeName
+        options?.storeName,
+        undefined,
+        useWorker
       );
     }
 
@@ -2341,6 +2404,15 @@ class WebClient {
    * @param {string | undefined} [logLevel] - Optional log verbosity level
    *   ("error", "warn", "info", "debug", "trace", "off", or "none").
    *   When set, Rust tracing output is routed to the browser console.
+   * @param {boolean} [useWorker=true] - When `false`, skip the Web Worker shim
+   *   and call the wasm-bindgen `WebClient` directly on the current thread.
+   *   The worker exists to keep the main thread responsive during WASM work
+   *   in browser/extension contexts, but it serializes the prover argument
+   *   via `TransactionProver.serialize()` — a format that has no encoding
+   *   for `newCallbackProver(jsFn)` and silently downgrades it to `"local"`.
+   *   Consumers that hand a `CallbackProver` (e.g. native iOS/Android plug-in
+   *   provers in Capacitor apps, or any other JS-side prover bridge) need
+   *   `useWorker: false` so the prover handle reaches the WASM binding intact.
    */
   constructor(
     rpcUrl,
@@ -2350,7 +2422,8 @@ class WebClient {
     getKeyCb,
     insertKeyCb,
     signCb,
-    logLevel
+    logLevel,
+    useWorker = true
   ) {
     this.rpcUrl = rpcUrl;
     this.noteTransportUrl = noteTransportUrl;
@@ -2360,9 +2433,12 @@ class WebClient {
     this.insertKeyCb = insertKeyCb;
     this.signCb = signCb;
     this.logLevel = logLevel;
+    this.useWorker = useWorker !== false;
 
-    // Check if Web Workers are available.
-    if (typeof Worker !== "undefined") {
+    // Check if Web Workers are available AND the caller didn't opt out via
+    // `useWorker: false`. The opt-out is load-bearing for `CallbackProver`
+    // consumers — see the constructor doc above.
+    if (this.useWorker && typeof Worker !== "undefined") {
       console.log("WebClient: Web Workers are available.");
       // Pick between the module and classic worker variants at runtime — see
       // `WebClient.workerMode` below. Both branches keep the
@@ -2476,8 +2552,12 @@ class WebClient {
       // Once the worker script has loaded, initialize the worker.
       this.loaded.then(() => this.initializeWorker());
     } else {
-      console.log("WebClient: Web Workers are not available.");
-      // Worker not available; set up fallback values.
+      console.log(
+        this.useWorker
+          ? "WebClient: Web Workers are not available."
+          : "WebClient: Web Worker shim disabled by caller (useWorker=false)."
+      );
+      // Worker not available or explicitly disabled; set up fallback values.
       this.worker = null;
       this.pendingRequests = null;
       this.loaded = Promise.resolve();
@@ -2548,6 +2628,22 @@ class WebClient {
   // More context here:
   // https://github.com/0xMiden/miden-client/pull/1645?notification_referrer_id=NT_kwHOA1yg7NoAJVJlcG9zaXRvcnk7NjU5MzQzNzAyO0lzc3VlOzM3OTY4OTU1Nzk&notifications_query=is%3Aunread#discussion_r2696075480
   initializeWorker() {
+    // Pass `numThreads` to the worker so it can call `wasm.initThreadPool(n)`
+    // inside its OWN WASM instance — the SDK worker's instance is separate
+    // from the main thread's, and rayon's global pool is per-instance.
+    // Default: navigator.hardwareConcurrency (or 1 if unavailable for any
+    // reason — e.g. the page isn't crossOriginIsolated, in which case the
+    // worker will skip pool init and parallelism falls back to sequential).
+    let numThreads = 1;
+    try {
+      if (
+        typeof self !== "undefined" &&
+        self.crossOriginIsolated &&
+        navigator?.hardwareConcurrency
+      ) {
+        numThreads = navigator.hardwareConcurrency;
+      }
+    } catch {}
     this.worker.postMessage({
       action: WorkerAction.INIT,
       args: [
@@ -2559,6 +2655,7 @@ class WebClient {
         !!this.insertKeyCb,
         !!this.signCb,
         this.logLevel,
+        numThreads,
       ],
     });
   }
@@ -2587,9 +2684,19 @@ class WebClient {
    * @param {string} seed - The seed for the account.
    * @param {string | undefined} network - Optional name for the store. Setting this allows multiple clients to be used in the same browser.
    * @param {string | undefined} logLevel - Optional log verbosity level ("error", "warn", "info", "debug", "trace", "off", or "none").
+   * @param {boolean} [useWorker=true] - When `false`, bypass the Web Worker shim
+   *   and run WASM calls on the current thread. Required for `CallbackProver`
+   *   consumers (the worker path serializes the prover and loses the callback).
    * @returns {Promise<WebClient>} The fully initialized WebClient.
    */
-  static async createClient(rpcUrl, noteTransportUrl, seed, network, logLevel) {
+  static async createClient(
+    rpcUrl,
+    noteTransportUrl,
+    seed,
+    network,
+    logLevel,
+    useWorker = true
+  ) {
     // Construct the instance (synchronously).
     const instance = new WebClient(
       rpcUrl,
@@ -2599,7 +2706,8 @@ class WebClient {
       undefined,
       undefined,
       undefined,
-      logLevel
+      logLevel,
+      useWorker
     );
 
     // Set up logging on the main thread before creating the client.
@@ -2630,6 +2738,9 @@ class WebClient {
    * @param {Function | undefined} insertKeyCb - The insert key callback.
    * @param {Function | undefined} signCb - The sign callback.
    * @param {string | undefined} logLevel - Optional log verbosity level ("error", "warn", "info", "debug", "trace", "off", or "none").
+   * @param {boolean} [useWorker=true] - When `false`, bypass the Web Worker shim
+   *   and run WASM calls on the current thread. Required for `CallbackProver`
+   *   consumers (the worker path serializes the prover and loses the callback).
    * @returns {Promise<WebClient>} The fully initialized WebClient.
    */
   static async createClientWithExternalKeystore(
@@ -2640,7 +2751,8 @@ class WebClient {
     getKeyCb,
     insertKeyCb,
     signCb,
-    logLevel
+    logLevel,
+    useWorker = true
   ) {
     // Construct the instance (synchronously).
     const instance = new WebClient(
@@ -2651,7 +2763,8 @@ class WebClient {
       getKeyCb,
       insertKeyCb,
       signCb,
-      logLevel
+      logLevel,
+      useWorker
     );
 
     // Set up logging on the main thread before creating the client.