@miden-sdk/miden-sdk 0.15.0-alpha.5 → 0.15.0-alpha.7

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, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, 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, 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, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-smJQCGjz.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, ExecutedTransaction, Felt, FeltArray, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, 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, 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-C9UbiAcT.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -26,20 +26,24 @@ const MethodName = Object.freeze({
   SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK: "submitNewTransactionWithProverMock",
   SYNC_STATE: "syncState",
   SYNC_STATE_MOCK: "syncStateMock",
+  SYNC_CHAIN: "syncChain",
+  SYNC_CHAIN_MOCK: "syncChainMock",
+  SYNC_NOTE_TRANSPORT: "syncNoteTransport",
+  SYNC_NOTE_TRANSPORT_MOCK: "syncNoteTransportMock",
 });
 
 /**
  * Sync Lock Module
  *
- * Provides coordination for concurrent syncState() calls using the Web Locks API
- * with an in-process mutex fallback for older browsers.
+ * Coordinates concurrent sync calls using the Web Locks API.
  *
  * Behavior:
- * - Uses "coalescing": if a sync is in progress, subsequent callers wait and receive
- *   the same result
- * - Web Locks for cross-tab coordination (Chrome 69+, Safari 15.4+)
- * - In-process mutex fallback when Web Locks unavailable
- * - Optional timeout support
+ * - Same-method coalescing: if a sync of the same method is in progress,
+ *   subsequent callers share its result promise
+ * - Different-method serialization: different methods (e.g. syncState vs
+ *   syncNoteTransport) wait for each other via the Web Lock, or via an
+ *   in-process per-dbId promise chain when Web Locks are unavailable
+ * - Web Locks also serialize across tabs (Chrome 69+, Safari 15.4+)
  */
 
 /**
@@ -53,195 +57,86 @@ function hasWebLocks() {
   );
 }
 
-/**
- * Internal state for tracking in-progress syncs and waiters per database.
- */
-const syncStates = new Map();
+// Coalesce map keyed by `${dbId}:${methodId}` -> in-flight promise.
+const inFlight = new Map();
 
-/**
- * Get or create sync state for a database.
- */
-function getSyncState(dbId) {
-  let state = syncStates.get(dbId);
-  if (!state) {
-    state = {
-      inProgress: false,
-      result: null,
-      error: null,
-      waiters: [],
-      releaseLock: null,
-      syncGeneration: 0,
-    };
-    syncStates.set(dbId, state);
-  }
-  return state;
-}
+// Per-dbId promise tail used to serialize cross-method calls when Web Locks
+// are unavailable. Each new task chains onto the current tail so different
+// methods on the same dbId run sequentially within the tab.
+const fallbackTails = new Map();
 
 /**
- * Acquire a sync lock for the given database.
- *
- * If a sync is already in progress:
- * - Returns { acquired: false, coalescedResult } after waiting for the result
- *
- * If no sync is in progress:
- * - Returns { acquired: true } and the caller should perform the sync,
- *   then call releaseSyncLock() or releaseSyncLockWithError()
+ * Build the coalesce-map key for an in-flight sync of `(dbId, methodId)`.
  *
- * @param {string} dbId - The database ID to lock
- * @param {number} timeoutMs - Optional timeout in milliseconds (0 = no timeout)
- * @returns {Promise<{acquired: boolean, coalescedResult?: any}>}
+ * @param {string} dbId
+ * @param {string} methodId
+ * @returns {string}
  */
-async function acquireSyncLock(dbId, timeoutMs = 0) {
-  const state = getSyncState(dbId);
-
-  // If a sync is already in progress, wait for it to complete (coalescing)
-  if (state.inProgress) {
-    return new Promise((resolve, reject) => {
-      let timeoutId;
-      if (timeoutMs > 0) {
-        timeoutId = setTimeout(() => {
-          const idx = state.waiters.findIndex((w) => w.resolve === onResult);
-          if (idx !== -1) {
-            state.waiters.splice(idx, 1);
-          }
-          reject(new Error("Sync lock acquisition timed out"));
-        }, timeoutMs);
-      }
-
-      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 });
-      };
-
-      const onError = (error) => {
-        if (timeoutId) clearTimeout(timeoutId);
-        reject(error);
-      };
-
-      state.waiters.push({ resolve: onResult, reject: onError });
-    });
-  }
-
-  // Mark sync as in progress and increment generation
-  state.inProgress = true;
-  state.result = null;
-  state.error = null;
-  state.syncGeneration++;
-  const currentGeneration = state.syncGeneration;
-
-  // Try to acquire Web Lock if available
-  if (hasWebLocks()) {
-    const lockName = `miden-sync-${dbId}`;
-
-    return new Promise((resolve, reject) => {
-      let timeoutId;
-      let timedOut = false;
-
-      if (timeoutMs > 0) {
-        timeoutId = setTimeout(() => {
-          timedOut = true;
-          if (state.syncGeneration === currentGeneration) {
-            state.inProgress = false;
-            const error = new Error("Sync lock acquisition timed out");
-            for (const waiter of state.waiters) {
-              waiter.reject(error);
-            }
-            state.waiters = [];
-          }
-          reject(new Error("Sync lock acquisition timed out"));
-        }, timeoutMs);
-      }
-
-      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;
-          }
-
-          if (timeoutId) clearTimeout(timeoutId);
-
-          return new Promise((releaseLock) => {
-            state.releaseLock = releaseLock;
-            resolve({ acquired: true });
-          });
-        })
-        .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;
-          }
-          reject(err instanceof Error ? err : new Error(String(err)));
-        });
-    });
-  } else {
-    // Fallback: no Web Locks, just use in-process state
-    return { acquired: true };
-  }
+function coalesceKey(dbId, methodId) {
+  return `${dbId}:${methodId}`;
 }
 
 /**
- * Release the sync lock with a successful result.
- *
- * This notifies all waiting callers with the result and releases the lock.
+ * Run `fn` while holding the per-db Web Lock. When Web Locks are unavailable,
+ * serializes `fn` against any other in-flight call on the same `dbId` via an
+ * in-process promise chain — the wasm-bindgen `WebClient` uses a synchronous
+ * `RefCell` for interior mutability in the browser, so overlapping
+ * cross-method borrows would throw "recursive use of an object detected
+ * which would lead to unsafe aliasing in rust".
  *
- * @param {string} dbId - The database ID
- * @param {any} result - The sync result to pass to waiters
+ * @param {string} dbId
+ * @param {() => Promise<T>} fn
+ * @returns {Promise<T>}
+ * @template T
  */
-function releaseSyncLock(dbId, result) {
-  const state = getSyncState(dbId);
-
-  if (!state.inProgress) {
-    console.warn("releaseSyncLock called but no sync was in progress");
-    return;
-  }
-
-  state.result = result;
-  state.inProgress = false;
-
-  for (const waiter of state.waiters) {
-    waiter.resolve(result);
-  }
-  state.waiters = [];
-
-  if (state.releaseLock) {
-    state.releaseLock();
-    state.releaseLock = null;
+function runUnderLock(dbId, fn) {
+  if (!hasWebLocks()) {
+    const prev = fallbackTails.get(dbId) ?? Promise.resolve();
+    const next = prev.catch(() => {}).then(fn);
+    const guarded = next.catch(() => {});
+    fallbackTails.set(dbId, guarded);
+    guarded.then(() => {
+      // Drop the slot only if no successor chained onto this tail.
+      if (fallbackTails.get(dbId) === guarded) fallbackTails.delete(dbId);
+    });
+    return next;
   }
+  return navigator.locks.request(
+    `miden-sync-${dbId}`,
+    { mode: "exclusive" },
+    fn
+  );
 }
 
 /**
- * Release the sync lock due to an error.
+ * Run `fn` under the sync lock for (dbId, methodId).
  *
- * This notifies all waiting callers that the sync failed.
+ * Concurrent calls with the same (dbId, methodId) share the same promise
+ * (coalescing). Concurrent calls on the same dbId with different methodIds
+ * serialize via the Web Lock.
  *
- * @param {string} dbId - The database ID
- * @param {Error} error - The error to pass to waiters
+ * @param {string} dbId - Database ID
+ * @param {string} methodId - Method identifier (see MethodName constants)
+ * @param {() => Promise<T>} fn - Work to run under the lock
+ * @returns {Promise<T>}
  */
-function releaseSyncLockWithError(dbId, error) {
-  const state = getSyncState(dbId);
-
-  if (!state.inProgress) {
-    console.warn("releaseSyncLockWithError called but no sync was in progress");
-    return;
-  }
-
-  state.error = error;
-  state.inProgress = false;
-
-  for (const waiter of state.waiters) {
-    waiter.reject(error);
-  }
-  state.waiters = [];
-
-  if (state.releaseLock) {
-    state.releaseLock();
-    state.releaseLock = null;
-  }
+function withSyncLock(dbId, methodId, fn) {
+  const key = coalesceKey(dbId, methodId);
+
+  let work = inFlight.get(key);
+  if (!work) {
+    work = runUnderLock(dbId, fn);
+    inFlight.set(key, work);
+    // Swallow on the derived promise so a rejection here doesn't surface as
+    // an unhandled rejection; the caller still sees the error through `work`.
+    work
+      .finally(() => {
+        if (inFlight.get(key) === work) inFlight.delete(key);
+      })
+      .catch(() => {});
+  }
+
+  return work;
 }
 
 /**
@@ -1128,7 +1023,10 @@ class TransactionsResource {
       }
 
       try {
-        await this.#inner.syncStateWithTimeout(0);
+        // Chain-only sync is sufficient: confirmation only needs on-chain
+        // state, and skipping NTL keeps polling alive when the note
+        // transport endpoint is unavailable.
+        await this.#inner.syncChain();
       } catch {
         // Sync may fail transiently; continue polling
       }
@@ -1945,15 +1843,34 @@ class MidenClient {
   }
 
   /**
-   * Syncs the client state with the Miden node.
+   * Syncs the client: fetches private notes from the Note Transport Layer, then syncs on-chain
+   * state with the Miden node. Fails fast on either.
    *
-   * @param {object} [opts] - Sync options.
-   * @param {number} [opts.timeout] - Timeout in milliseconds (0 = no timeout).
    * @returns {Promise<SyncSummary>} The sync summary.
    */
-  async sync(opts) {
+  async sync() {
+    this.assertNotTerminated();
+    return await this.#inner.syncState();
+  }
+
+  /**
+   * Syncs on-chain state only (no NTL fetch).
+   *
+   * @returns {Promise<SyncSummary>}
+   */
+  async syncChain() {
+    this.assertNotTerminated();
+    return await this.#inner.syncChain();
+  }
+
+  /**
+   * Fetches private notes from the Note Transport Layer.
+   *
+   * @returns {Promise<void>}
+   */
+  async syncNoteTransport() {
     this.assertNotTerminated();
-    return await this.#inner.syncStateWithTimeout(opts?.timeout ?? 0);
+    return await this.#inner.syncNoteTransport();
   }
 
   /**
@@ -2623,6 +2540,34 @@ const Linking = Object.freeze({
   Static: "static",
 });
 
+// Method classification sets — used by scripts/check-method-classification.js to ensure
+// every WASM export is explicitly categorised. Update when adding new WASM methods.
+//
+// Naming note: "SYNC_METHODS" is a historical misnomer. This set groups methods
+// that are forwarded transparently to the underlying WASM via the Proxy in
+// `createClientProxy` — meaning they don't need an explicit JS-class wrapper
+// here. It does NOT mean "the method is synchronous"; several entries
+// (e.g. newSwapTransactionRequest, newPswapCreateTransactionRequest) are
+// `async fn` in Rust because they take the client's RNG via an async lock.
+const SYNC_METHODS = new Set([
+  "buildSwapTag",
+  "createCodeBuilder",
+  "lastAuthError",
+  "newConsumeTransactionRequest",
+  "newMintTransactionRequest",
+  "newPswapCancelTransactionRequest",
+  "newPswapConsumeTransactionRequest",
+  "newPswapCreateTransactionRequest",
+  "newSendTransactionRequest",
+  "newSwapTransactionRequest",
+  "proveBlock",
+  "serializeMockChain",
+  "serializeMockNoteTransportNode",
+  "setDebugMode",
+  "storeIdentifier",
+  "usesMockChain",
+]);
+
 const MOCK_STORE_NAME = "mock_client_db";
 
 const buildTypedArraysExport = (exportObject) => {
@@ -2736,7 +2681,19 @@ function createClientProxy(instance) {
       if (target.wasmWebClient && prop in target.wasmWebClient) {
         const value = target.wasmWebClient[prop];
         if (typeof value === "function") {
-          return value.bind(target.wasmWebClient);
+          // SYNC_METHODS are safe to bind raw (synchronous in JS, or
+          // documented exceptions). Everything else holds the WASM
+          // client's internal RefCell across its awaits, so it MUST join
+          // `_serializeWasmCall` — an unserialized fallback overlapping
+          // any in-flight call panics with "RefCell already borrowed"
+          // and poisons the instance for every later call.
+          if (typeof prop === "string" && SYNC_METHODS.has(prop)) {
+            return value.bind(target.wasmWebClient);
+          }
+          return (...args) =>
+            target._serializeWasmCall(() =>
+              value.apply(target.wasmWebClient, args)
+            );
         }
         return value;
       }
@@ -2884,10 +2841,19 @@ class WebClient {
         this.loadedResolver = resolve;
       });
 
-      // Create a promise that resolves when the worker signals that it is fully initialized.
-      this.ready = new Promise((resolve) => {
+      // Create a promise that resolves when the worker signals that it is
+      // fully initialized, and rejects if initialization fails. Every
+      // worker-forwarded method awaits `ready` first, so an init failure must
+      // reject it — otherwise those calls would await a promise that never
+      // settles and hang forever.
+      this.ready = new Promise((resolve, reject) => {
         this.readyResolver = resolve;
+        this.readyRejecter = reject;
       });
+      // Init can fail before any caller awaits `ready`; this no-op handler
+      // suppresses the unhandledrejection event without consuming the
+      // rejection for real awaiters.
+      this.ready.catch(() => {});
 
       // Listen for messages from the worker.
       this.worker.addEventListener("message", async (event) => {
@@ -2951,6 +2917,21 @@ class WebClient {
           } else {
             resolve(result);
           }
+          return;
+        }
+
+        // An error with no request attached comes from worker initialization
+        // (INIT is the only requestId-less action that can fail). Reject
+        // `ready` so queued and future method calls fail with the real cause
+        // instead of awaiting forever.
+        if (error && !requestId) {
+          const workerError =
+            error instanceof Error ? error : deserializeError(error);
+          console.error(
+            "WebClient: worker initialization failed:",
+            workerError
+          );
+          this.readyRejecter(workerError);
         }
       });
 
@@ -3291,151 +3272,164 @@ class WebClient {
   }
 
   async submitNewTransaction(accountId, transactionRequest) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.submitNewTransaction(
-          accountId,
-          transactionRequest
-        );
-      }
+    return this._serializeWasmCall(async () => {
+      try {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.submitNewTransaction(
+            accountId,
+            transactionRequest
+          );
+        }
 
-      const wasm = await getWasmOrThrow();
-      const serializedTransactionRequest = transactionRequest.serialize();
-      const result = await this.callMethodWithWorker(
-        MethodName.SUBMIT_NEW_TRANSACTION,
-        accountId.toString(),
-        serializedTransactionRequest
-      );
+        const wasm = await getWasmOrThrow();
+        const serializedTransactionRequest = transactionRequest.serialize();
+        const result = await this.callMethodWithWorker(
+          MethodName.SUBMIT_NEW_TRANSACTION,
+          accountId.toString(),
+          serializedTransactionRequest
+        );
 
-      const transactionResult = wasm.TransactionResult.deserialize(
-        new Uint8Array(result.serializedTransactionResult)
-      );
+        const transactionResult = wasm.TransactionResult.deserialize(
+          new Uint8Array(result.serializedTransactionResult)
+        );
 
-      return transactionResult.id();
-    } catch (error) {
-      console.error("INDEX.JS: Error in submitNewTransaction:", error);
-      throw error;
-    }
+        return transactionResult.id();
+      } catch (error) {
+        console.error("INDEX.JS: Error in submitNewTransaction:", error);
+        throw error;
+      }
+    });
   }
 
   async submitNewTransactionWithProver(accountId, transactionRequest, prover) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.submitNewTransactionWithProver(
-          accountId,
-          transactionRequest,
-          prover
-        );
-      }
+    return this._serializeWasmCall(async () => {
+      try {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.submitNewTransactionWithProver(
+            accountId,
+            transactionRequest,
+            prover
+          );
+        }
 
-      const wasm = await getWasmOrThrow();
-      const serializedTransactionRequest = transactionRequest.serialize();
-      const proverPayload = prover.serialize();
-      const result = await this.callMethodWithWorker(
-        MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER,
-        accountId.toString(),
-        serializedTransactionRequest,
-        proverPayload
-      );
+        const wasm = await getWasmOrThrow();
+        const serializedTransactionRequest = transactionRequest.serialize();
+        const proverPayload = prover.serialize();
+        const result = await this.callMethodWithWorker(
+          MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER,
+          accountId.toString(),
+          serializedTransactionRequest,
+          proverPayload
+        );
 
-      const transactionResult = wasm.TransactionResult.deserialize(
-        new Uint8Array(result.serializedTransactionResult)
-      );
+        const transactionResult = wasm.TransactionResult.deserialize(
+          new Uint8Array(result.serializedTransactionResult)
+        );
 
-      return transactionResult.id();
-    } catch (error) {
-      console.error(
-        "INDEX.JS: Error in submitNewTransactionWithProver:",
-        error
-      );
-      throw error;
-    }
+        return transactionResult.id();
+      } catch (error) {
+        console.error(
+          "INDEX.JS: Error in submitNewTransactionWithProver:",
+          error
+        );
+        throw error;
+      }
+    });
   }
 
   async executeTransaction(accountId, transactionRequest) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.executeTransaction(
-          accountId,
-          transactionRequest
-        );
-      }
+    return this._serializeWasmCall(async () => {
+      try {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.executeTransaction(
+            accountId,
+            transactionRequest
+          );
+        }
 
-      const wasm = await getWasmOrThrow();
-      const serializedTransactionRequest = transactionRequest.serialize();
-      const serializedResultBytes = await this.callMethodWithWorker(
-        MethodName.EXECUTE_TRANSACTION,
-        accountId.toString(),
-        serializedTransactionRequest
-      );
+        const wasm = await getWasmOrThrow();
+        const serializedTransactionRequest = transactionRequest.serialize();
+        const serializedResultBytes = await this.callMethodWithWorker(
+          MethodName.EXECUTE_TRANSACTION,
+          accountId.toString(),
+          serializedTransactionRequest
+        );
 
-      return wasm.TransactionResult.deserialize(
-        new Uint8Array(serializedResultBytes)
-      );
-    } catch (error) {
-      console.error("INDEX.JS: Error in executeTransaction:", error);
-      throw error;
-    }
+        return wasm.TransactionResult.deserialize(
+          new Uint8Array(serializedResultBytes)
+        );
+      } catch (error) {
+        console.error("INDEX.JS: Error in executeTransaction:", error);
+        throw error;
+      }
+    });
   }
 
   async proveTransaction(transactionResult, prover) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.proveTransaction(transactionResult, prover);
-      }
+    return this._serializeWasmCall(async () => {
+      try {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.proveTransaction(
+            transactionResult,
+            prover
+          );
+        }
 
-      const wasm = await getWasmOrThrow();
-      const serializedTransactionResult = transactionResult.serialize();
-      const proverPayload = prover ? prover.serialize() : null;
+        const wasm = await getWasmOrThrow();
+        const serializedTransactionResult = transactionResult.serialize();
+        const proverPayload = prover ? prover.serialize() : null;
 
-      const serializedProvenBytes = await this.callMethodWithWorker(
-        MethodName.PROVE_TRANSACTION,
-        serializedTransactionResult,
-        proverPayload
-      );
+        const serializedProvenBytes = await this.callMethodWithWorker(
+          MethodName.PROVE_TRANSACTION,
+          serializedTransactionResult,
+          proverPayload
+        );
 
-      return wasm.ProvenTransaction.deserialize(
-        new Uint8Array(serializedProvenBytes)
-      );
-    } catch (error) {
-      console.error("INDEX.JS: Error in proveTransaction:", error);
-      throw error;
-    }
+        return wasm.ProvenTransaction.deserialize(
+          new Uint8Array(serializedProvenBytes)
+        );
+      } catch (error) {
+        console.error("INDEX.JS: Error in proveTransaction:", error);
+        throw error;
+      }
+    });
   }
 
   async applyTransaction(transactionResult, submissionHeight) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.applyTransaction(
-          transactionResult,
+    return this._serializeWasmCall(async () => {
+      try {
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          return await wasmWebClient.applyTransaction(
+            transactionResult,
+            submissionHeight
+          );
+        }
+
+        const wasm = await getWasmOrThrow();
+        const serializedTransactionResult = transactionResult.serialize();
+        const serializedUpdateBytes = await this.callMethodWithWorker(
+          MethodName.APPLY_TRANSACTION,
+          serializedTransactionResult,
           submissionHeight
         );
-      }
 
-      const wasm = await getWasmOrThrow();
-      const serializedTransactionResult = transactionResult.serialize();
-      const serializedUpdateBytes = await this.callMethodWithWorker(
-        MethodName.APPLY_TRANSACTION,
-        serializedTransactionResult,
-        submissionHeight
-      );
-
-      return wasm.TransactionStoreUpdate.deserialize(
-        new Uint8Array(serializedUpdateBytes)
-      );
-    } catch (error) {
-      console.error("INDEX.JS: Error in applyTransaction:", error);
-      throw error;
-    }
+        return wasm.TransactionStoreUpdate.deserialize(
+          new Uint8Array(serializedUpdateBytes)
+        );
+      } catch (error) {
+        console.error("INDEX.JS: Error in applyTransaction:", error);
+        throw error;
+      }
+    });
   }
 
   /**
-   * Syncs the client state with the node.
+   * Syncs the client (NTL followed by chain sync, failing fast on either).
    *
    * This method coordinates concurrent sync calls using the Web Locks API when available,
    * with an in-process mutex fallback for older browsers. If a sync is already in progress,
@@ -3444,58 +3438,86 @@ class WebClient {
    * @returns {Promise<SyncSummary>} The sync summary
    */
   async syncState() {
-    return this.syncStateWithTimeout(0);
+    const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_STATE;
+
+    try {
+      // The sync lock coalesces concurrent sync callers; the inner
+      // `_serializeWasmCall` keeps the WASM phase from racing any other
+      // serialized method on this instance. Lock order is always
+      // sync lock → chain, so the two can't deadlock.
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          if (!this.worker) {
+            const wasmWebClient = await this.getWasmWebClient();
+            return await wasmWebClient.syncStateImpl();
+          }
+          const wasm = await getWasmOrThrow();
+          const serializedSyncSummaryBytes =
+            await this.callMethodWithWorker(methodId);
+          return wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        })
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncState:", error);
+      throw error;
+    }
   }
 
   /**
-   * Syncs the client state with the node with an optional timeout.
-   *
-   * This method coordinates concurrent sync calls using the Web Locks API when available,
-   * with an in-process mutex fallback for older browsers. If a sync is already in progress,
-   * subsequent callers will wait and receive the same result (coalescing behavior).
+   * Fetches private notes from the Note Transport Layer.
    *
-   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
-   * @returns {Promise<SyncSummary>} The sync summary
+   * @returns {Promise<void>}
    */
-  async syncStateWithTimeout(timeoutMs = 0) {
-    // Use storeName as the database ID for lock coordination
+  async syncNoteTransport() {
     const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_NOTE_TRANSPORT;
 
     try {
-      // Acquire the sync lock (coordinates concurrent calls)
-      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
+      await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          if (!this.worker) {
+            const wasmWebClient = await this.getWasmWebClient();
+            await wasmWebClient.syncNoteTransportImpl();
+          } else {
+            await this.callMethodWithWorker(methodId);
+          }
+        })
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncNoteTransport:", error);
+      throw error;
+    }
+  }
 
-      if (!lockHandle.acquired) {
-        // We're coalescing - return the result from the in-progress sync
-        return lockHandle.coalescedResult;
-      }
+  /**
+   * Syncs on-chain state only (no NTL fetch).
+   *
+   * @returns {Promise<SyncSummary>}
+   */
+  async syncChain() {
+    const dbId = this.storeName || "default";
+    const methodId = MethodName.SYNC_CHAIN;
 
-      // We acquired the lock - perform the sync
-      try {
-        let result;
-        if (!this.worker) {
-          const wasmWebClient = await this.getWasmWebClient();
-          result = await wasmWebClient.syncStateImpl();
-        } else {
+    try {
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          if (!this.worker) {
+            const wasmWebClient = await this.getWasmWebClient();
+            return await wasmWebClient.syncChainImpl();
+          }
           const wasm = await getWasmOrThrow();
-          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-            MethodName.SYNC_STATE
-          );
-          result = wasm.SyncSummary.deserialize(
+          const serializedSyncSummaryBytes =
+            await this.callMethodWithWorker(methodId);
+          return wasm.SyncSummary.deserialize(
             new Uint8Array(serializedSyncSummaryBytes)
           );
-        }
-
-        // Release the lock with the result
-        releaseSyncLock(dbId, result);
-        return result;
-      } catch (error) {
-        // Release the lock with the error
-        releaseSyncLockWithError(dbId, error);
-        throw error;
-      }
+        })
+      );
     } catch (error) {
-      console.error("INDEX.JS: Error in syncState:", error);
+      console.error("INDEX.JS: Error in syncChain:", error);
       throw error;
     }
   }
@@ -3531,9 +3553,23 @@ class MockWebClient extends WebClient {
   }
 
   initializeWorker() {
+    // Pass `numThreads` exactly like the real INIT path: every prove runs
+    // inside the worker's own WASM instance, and rayon's pool is
+    // per-instance — without this, mock-client proving (including the
+    // integration suite) silently runs single-threaded.
+    let numThreads = 1;
+    try {
+      if (
+        typeof self !== "undefined" &&
+        self.crossOriginIsolated &&
+        navigator?.hardwareConcurrency
+      ) {
+        numThreads = navigator.hardwareConcurrency;
+      }
+    } catch {}
     this.worker.postMessage({
       action: WorkerAction.INIT_MOCK,
-      args: [this.seed, this.logLevel],
+      args: [this.seed, this.logLevel, numThreads],
     });
   }
 
@@ -3584,59 +3620,125 @@ class MockWebClient extends WebClient {
    * @returns {Promise<SyncSummary>} The sync summary
    */
   async syncState() {
-    return this.syncStateWithTimeout(0);
+    const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_STATE;
+
+    try {
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
+
+          if (!this.worker) {
+            return await wasmWebClient.syncStateImpl();
+          }
+
+          const serializedMockChain = (await wasmWebClient.serializeMockChain())
+            .buffer;
+          const serializedMockNoteTransportNode = (
+            await wasmWebClient.serializeMockNoteTransportNode()
+          ).buffer;
+
+          const wasm = await getWasmOrThrow();
+          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+            MethodName.SYNC_STATE_MOCK,
+            serializedMockChain,
+            serializedMockNoteTransportNode
+          );
+          return wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        })
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncState:", error);
+      throw error;
+    }
   }
 
   /**
-   * Syncs the mock client state with an optional timeout.
+   * Syncs only the on-chain mock state (no note transport fetch).
    *
-   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
-   * @returns {Promise<SyncSummary>} The sync summary
+   * In worker mode, the main-thread mock chain + note-transport-node state
+   * is serialized and shipped to the worker before the sync, so a prior
+   * `proveBlock()` on the main thread is reflected in the worker's WASM
+   * client. The no-worker path uses the main-thread WASM client directly.
+   *
+   * @returns {Promise<SyncSummary>}
    */
-  async syncStateWithTimeout(timeoutMs = 0) {
+  async syncChain() {
     const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_CHAIN;
 
     try {
-      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
-
-      if (!lockHandle.acquired) {
-        return lockHandle.coalescedResult;
-      }
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
 
-      try {
-        let result;
-        const wasmWebClient = await this.getWasmWebClient();
+          if (!this.worker) {
+            return await wasmWebClient.syncChainImpl();
+          }
 
-        if (!this.worker) {
-          result = await wasmWebClient.syncStateImpl();
-        } else {
-          let serializedMockChain = (await wasmWebClient.serializeMockChain())
+          const serializedMockChain = (await wasmWebClient.serializeMockChain())
             .buffer;
-          let serializedMockNoteTransportNode = (
+          const serializedMockNoteTransportNode = (
             await wasmWebClient.serializeMockNoteTransportNode()
           ).buffer;
 
           const wasm = await getWasmOrThrow();
-
           const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-            MethodName.SYNC_STATE_MOCK,
+            MethodName.SYNC_CHAIN_MOCK,
             serializedMockChain,
             serializedMockNoteTransportNode
           );
-
-          result = wasm.SyncSummary.deserialize(
+          return wasm.SyncSummary.deserialize(
             new Uint8Array(serializedSyncSummaryBytes)
           );
-        }
+        })
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in syncChain:", error);
+      throw error;
+    }
+  }
 
-        releaseSyncLock(dbId, result);
-        return result;
-      } catch (error) {
-        releaseSyncLockWithError(dbId, error);
-        throw error;
-      }
+  /**
+   * Syncs only the mock note-transport state (no chain fetch).
+   *
+   * Mirrors {@link MockWebClient#syncChain}: in worker mode, the
+   * main-thread mock chain + note-transport-node state is serialized
+   * and shipped to the worker first.
+   *
+   * @returns {Promise<void>}
+   */
+  async syncNoteTransport() {
+    const dbId = this.storeName || "mock";
+    const methodId = MethodName.SYNC_NOTE_TRANSPORT;
+
+    try {
+      await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
+
+          if (!this.worker) {
+            await wasmWebClient.syncNoteTransportImpl();
+            return;
+          }
+
+          const serializedMockChain = (await wasmWebClient.serializeMockChain())
+            .buffer;
+          const serializedMockNoteTransportNode = (
+            await wasmWebClient.serializeMockNoteTransportNode()
+          ).buffer;
+
+          await this.callMethodWithWorker(
+            MethodName.SYNC_NOTE_TRANSPORT_MOCK,
+            serializedMockChain,
+            serializedMockNoteTransportNode
+          );
+        })
+      );
     } catch (error) {
-      console.error("INDEX.JS: Error in syncState:", error);
+      console.error("INDEX.JS: Error in syncNoteTransport:", error);
       throw error;
     }
   }
@@ -3774,5 +3876,5 @@ MidenClient._MockWasmWebClient = MockWebClient;
 MidenClient._getWasmOrThrow = getWasmOrThrow;
 _setWebClient(WebClient);
 
-export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, wordToBigInt };
+export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, withSyncLock, wordToBigInt };
 //# sourceMappingURL=index.js.map