@miden-sdk/miden-sdk 0.13.0-next.1 → 0.13.0-next.3

package/dist/index.js

@@ -1,9 +1,17 @@
 import loadWasm from './wasm.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountType, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FeltArray, FetchedNote, FlattenedU8Vec, ForeignAccount, ForeignAccountArray, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, Note, NoteAndArgs, NoteAndArgsArray, NoteAssets, NoteConsumability, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExecutionMode, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteInputs, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNotes, OutputNotesArray, Package, PartialNote, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, ScriptBuilder, SecretKey, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, StorageMap, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, Word, initSync } from './Cargo-15e14c5a.js';
+export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountType, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthScheme, 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, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteInputs, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteArray, OutputNoteRecord, OutputNoteState, OutputNotes, OutputNotesArray, Package, PartialNote, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageSlot, StorageSlotArray, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionScriptInputPairArray, TransactionStatus, TransactionStoreUpdate, TransactionSummary, Word, createAuthFalcon512RpoMultisig, initSync } from './Cargo-eb2eb6d6.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
+  INIT_MOCK: "initMock",
   CALL_METHOD: "callMethod",
+  EXECUTE_CALLBACK: "executeCallback",
+});
+
+const CallbackType = Object.freeze({
+  GET_KEY: "getKey",
+  INSERT_KEY: "insertKey",
+  SIGN: "sign",
 });
 
 const MethodName = Object.freeze({
@@ -14,10 +22,223 @@ const MethodName = Object.freeze({
   PROVE_TRANSACTION: "proveTransaction",
   SUBMIT_NEW_TRANSACTION: "submitNewTransaction",
   SUBMIT_NEW_TRANSACTION_MOCK: "submitNewTransactionMock",
+  SUBMIT_NEW_TRANSACTION_WITH_PROVER: "submitNewTransactionWithProver",
+  SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK: "submitNewTransactionWithProverMock",
   SYNC_STATE: "syncState",
   SYNC_STATE_MOCK: "syncStateMock",
 });
 
+/**
+ * Sync Lock Module
+ *
+ * Provides coordination for concurrent syncState() calls using the Web Locks API
+ * with an in-process mutex fallback for older browsers.
+ *
+ * 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
+ */
+
+/**
+ * Check if the Web Locks API is available.
+ */
+function hasWebLocks() {
+  return (
+    typeof navigator !== "undefined" &&
+    navigator.locks !== undefined &&
+    typeof navigator.locks.request === "function"
+  );
+}
+
+/**
+ * Internal state for tracking in-progress syncs and waiters per database.
+ */
+const syncStates = 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;
+}
+
+/**
+ * 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()
+ *
+ * @param {string} dbId - The database ID to lock
+ * @param {number} timeoutMs - Optional timeout in milliseconds (0 = no timeout)
+ * @returns {Promise<{acquired: boolean, coalescedResult?: any}>}
+ */
+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) => {
+        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 () => {
+          if (timedOut || state.syncGeneration !== currentGeneration) {
+            return;
+          }
+
+          if (timeoutId) clearTimeout(timeoutId);
+
+          return new Promise((releaseLock) => {
+            state.releaseLock = releaseLock;
+            resolve({ acquired: true });
+          });
+        })
+        .catch((err) => {
+          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 };
+  }
+}
+
+/**
+ * Release the sync lock with a successful result.
+ *
+ * This notifies all waiting callers with the result and releases the lock.
+ *
+ * @param {string} dbId - The database ID
+ * @param {any} result - The sync result to pass to waiters
+ */
+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;
+  }
+}
+
+/**
+ * Release the sync lock due to an error.
+ *
+ * This notifies all waiting callers that the sync failed.
+ *
+ * @param {string} dbId - The database ID
+ * @param {Error} error - The error to pass to waiters
+ */
+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;
+  }
+}
+
 const buildTypedArraysExport = (exportObject) => {
   return Object.entries(exportObject).reduce(
     (exports, [exportName, _export]) => {
@@ -30,6 +251,27 @@ const buildTypedArraysExport = (exportObject) => {
   );
 };
 
+const deserializeError = (errorLike) => {
+  if (!errorLike) {
+    return new Error("Unknown error received from worker");
+  }
+  const { name, message, stack, cause, ...rest } = errorLike;
+  const reconstructedError = new Error(message ?? "Unknown worker error");
+  reconstructedError.name = name ?? reconstructedError.name;
+  if (stack) {
+    reconstructedError.stack = stack;
+  }
+  if (cause) {
+    reconstructedError.cause = deserializeError(cause);
+  }
+  Object.entries(rest).forEach(([key, value]) => {
+    if (value !== undefined) {
+      reconstructedError[key] = value;
+    }
+  });
+  return reconstructedError;
+};
+
 const MidenArrays = {};
 
 let wasmModule = null;
@@ -96,36 +338,41 @@ class WebClient {
    *
    * @param {string | undefined} rpcUrl - RPC endpoint URL used by the client.
    * @param {Uint8Array | undefined} seed - Optional seed for account initialization.
+   * @param {string | undefined} storeName - Optional name for the store to be used by the client.
    * @param {(pubKey: Uint8Array) => Promise<Uint8Array | null | undefined> | Uint8Array | null | undefined} [getKeyCb]
    *   - Callback to retrieve the secret key bytes for a given public key. The `pubKey`
    *   parameter is the serialized public key (from `PublicKey.serialize()`). Return the
    *   corresponding secret key as a `Uint8Array`, or `null`/`undefined` if not found. The
    *   return value may be provided synchronously or via a `Promise`.
-   * @param {(pubKey: Uint8Array, secretKey: Uint8Array) => Promise<void> | void} [insertKeyCb]
+   * @param {(pubKey: Uint8Array, AuthSecretKey: Uint8Array) => Promise<void> | void} [insertKeyCb]
    *   - Callback to persist a secret key. `pubKey` is the serialized public key, and
-   *   `secretKey` is the serialized secret key (from `SecretKey.serialize()`). May return
+   *   `authSecretKey` is the serialized secret key (from `AuthSecretKey.serialize()`). May return
    *   `void` or a `Promise<void>`.
-   * @param {(pubKey: Uint8Array, signingInputs: Uint8Array) => Promise<Array<number | string>> | Array<number | string>} [signCb]
-   *   - Callback to produce signature elements for the provided inputs. `pubKey` is the
+   * @param {(pubKey: Uint8Array, signingInputs: Uint8Array) => Promise<Uint8Array> | Uint8Array} [signCb]
+   *   - Callback to produce serialized signature bytes for the provided inputs. `pubKey` is the
    *   serialized public key, and `signingInputs` is a `Uint8Array` produced by
-   *   `SigningInputs.serialize()`. Must return an array of numeric values (numbers or numeric
-   *   strings) representing the signature elements, either directly or wrapped in a `Promise`.
+   *   `SigningInputs.serialize()`. Must return a `Uint8Array` containing the serialized
+   *   signature, either directly or wrapped in a `Promise`.
    */
-  constructor(rpcUrl, noteTransportUrl, seed, getKeyCb, insertKeyCb, signCb) {
+  constructor(
+    rpcUrl,
+    noteTransportUrl,
+    seed,
+    storeName,
+    getKeyCb,
+    insertKeyCb,
+    signCb
+  ) {
     this.rpcUrl = rpcUrl;
     this.noteTransportUrl = noteTransportUrl;
     this.seed = seed;
+    this.storeName = storeName;
     this.getKeyCb = getKeyCb;
     this.insertKeyCb = insertKeyCb;
     this.signCb = signCb;
 
     // Check if Web Workers are available.
-    if (
-      typeof Worker !== "undefined" &&
-      !this.getKeyCb &&
-      !this.insertKeyCb &&
-      !this.signCb
-    ) {
+    if (typeof Worker !== "undefined") {
       console.log("WebClient: Web Workers are available.");
       // Create the worker.
       this.worker = new Worker(
@@ -147,7 +394,7 @@ class WebClient {
       });
 
       // Listen for messages from the worker.
-      this.worker.addEventListener("message", (event) => {
+      this.worker.addEventListener("message", async (event) => {
         const data = event.data;
 
         // Worker script loaded.
@@ -162,17 +409,49 @@ class WebClient {
           return;
         }
 
+        if (data.action === WorkerAction.EXECUTE_CALLBACK) {
+          const { callbackType, args, requestId } = data;
+          try {
+            const callbackMapping = {
+              [CallbackType.GET_KEY]: this.getKeyCb,
+              [CallbackType.INSERT_KEY]: this.insertKeyCb,
+              [CallbackType.SIGN]: this.signCb,
+            };
+            if (!callbackMapping[callbackType]) {
+              throw new Error(`Callback ${callbackType} not available`);
+            }
+            const callbackFunction = callbackMapping[callbackType];
+            let result = callbackFunction.apply(this, args);
+            if (result instanceof Promise) {
+              result = await result;
+            }
+
+            this.worker.postMessage({
+              callbackResult: result,
+              callbackRequestId: requestId,
+            });
+          } catch (error) {
+            this.worker.postMessage({
+              callbackError: error.message,
+              callbackRequestId: requestId,
+            });
+          }
+          return;
+        }
+
         // Handle responses for method calls.
         const { requestId, error, result, methodName } = data;
         if (requestId && this.pendingRequests.has(requestId)) {
           const { resolve, reject } = this.pendingRequests.get(requestId);
           this.pendingRequests.delete(requestId);
           if (error) {
+            const workerError =
+              error instanceof Error ? error : deserializeError(error);
             console.error(
               `WebClient: Error from worker in ${methodName}:`,
-              error
+              workerError
             );
-            reject(new Error(error));
+            reject(workerError);
           } else {
             resolve(result);
           }
@@ -180,19 +459,7 @@ class WebClient {
       });
 
       // Once the worker script has loaded, initialize the worker.
-      this.loaded.then(() => {
-        this.worker.postMessage({
-          action: WorkerAction.INIT,
-          args: [
-            this.rpcUrl,
-            this.noteTransportUrl,
-            this.seed,
-            this.getKeyCb,
-            this.insertKeyCb,
-            this.signCb,
-          ],
-        });
-      });
+      this.loaded.then(() => this.initializeWorker());
     } else {
       console.log("WebClient: Web Workers are not available.");
       // Worker not available; set up fallback values.
@@ -207,6 +474,24 @@ class WebClient {
     this.wasmWebClientPromise = null;
   }
 
+  // TODO: This will soon conflict with some changes in main.
+  // More context here:
+  // https://github.com/0xMiden/miden-client/pull/1645?notification_referrer_id=NT_kwHOA1yg7NoAJVJlcG9zaXRvcnk7NjU5MzQzNzAyO0lzc3VlOzM3OTY4OTU1Nzk&notifications_query=is%3Aunread#discussion_r2696075480
+  initializeWorker() {
+    this.worker.postMessage({
+      action: WorkerAction.INIT,
+      args: [
+        this.rpcUrl,
+        this.noteTransportUrl,
+        this.seed,
+        this.storeName,
+        !!this.getKeyCb,
+        !!this.insertKeyCb,
+        !!this.signCb,
+      ],
+    });
+  }
+
   async getWasmWebClient() {
     if (this.wasmWebClient) {
       return this.wasmWebClient;
@@ -229,15 +514,16 @@ class WebClient {
    * @param {string} rpcUrl - The RPC URL.
    * @param {string} noteTransportUrl - The note transport URL (optional).
    * @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.
    * @returns {Promise<WebClient>} The fully initialized WebClient.
    */
-  static async createClient(rpcUrl, noteTransportUrl, seed) {
+  static async createClient(rpcUrl, noteTransportUrl, seed, network) {
     // Construct the instance (synchronously).
-    const instance = new WebClient(rpcUrl, noteTransportUrl, seed);
+    const instance = new WebClient(rpcUrl, noteTransportUrl, seed, network);
 
     // Wait for the underlying wasmWebClient to be initialized.
     const wasmWebClient = await instance.getWasmWebClient();
-    await wasmWebClient.createClient(rpcUrl, noteTransportUrl, seed);
+    await wasmWebClient.createClient(rpcUrl, noteTransportUrl, seed, network);
 
     // Wait for the worker to be ready
     await instance.ready;
@@ -269,6 +555,7 @@ class WebClient {
    * @param {string} rpcUrl - The RPC URL.
    * @param {string | undefined} noteTransportUrl - The note transport URL (optional).
    * @param {string | undefined} seed - The seed for the account.
+   * @param {string | undefined} storeName - Optional name for the store. Setting this allows multiple clients to be used in the same browser.
    * @param {Function | undefined} getKeyCb - The get key callback.
    * @param {Function | undefined} insertKeyCb - The insert key callback.
    * @param {Function | undefined} signCb - The sign callback.
@@ -278,6 +565,7 @@ class WebClient {
     rpcUrl,
     noteTransportUrl,
     seed,
+    storeName,
     getKeyCb,
     insertKeyCb,
     signCb
@@ -287,19 +575,23 @@ class WebClient {
       rpcUrl,
       noteTransportUrl,
       seed,
+      storeName,
       getKeyCb,
       insertKeyCb,
       signCb
     );
+    // Wait for the underlying wasmWebClient to be initialized.
     const wasmWebClient = await instance.getWasmWebClient();
     await wasmWebClient.createClientWithExternalKeystore(
       rpcUrl,
       noteTransportUrl,
       seed,
+      storeName,
       getKeyCb,
       insertKeyCb,
       signCb
     );
+
     await instance.ready;
     // Return a proxy that forwards missing properties to wasmWebClient.
     return new Proxy(instance, {
@@ -368,7 +660,7 @@ class WebClient {
       );
       return wasm.Account.deserialize(new Uint8Array(serializedAccountBytes));
     } catch (error) {
-      console.error("INDEX.JS: Error in newWallet:", error.toString());
+      console.error("INDEX.JS: Error in newWallet:", error);
       throw error;
     }
   }
@@ -408,7 +700,7 @@ class WebClient {
 
       return wasm.Account.deserialize(new Uint8Array(serializedAccountBytes));
     } catch (error) {
-      console.error("INDEX.JS: Error in newFaucet:", error.toString());
+      console.error("INDEX.JS: Error in newFaucet:", error);
       throw error;
     }
   }
@@ -437,83 +729,69 @@ class WebClient {
 
       return transactionResult.id();
     } catch (error) {
-      console.error(
-        "INDEX.JS: Error in submitNewTransaction:",
-        error.toString()
-      );
+      console.error("INDEX.JS: Error in submitNewTransaction:", error);
       throw error;
     }
   }
 
-  async executeTransaction(accountId, transactionRequest) {
+  async submitNewTransactionWithProver(accountId, transactionRequest, prover) {
     try {
       if (!this.worker) {
         const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.executeTransaction(
+        return await wasmWebClient.submitNewTransactionWithProver(
           accountId,
-          transactionRequest
+          transactionRequest,
+          prover
         );
       }
 
       const wasm = await getWasmOrThrow();
       const serializedTransactionRequest = transactionRequest.serialize();
-      const serializedResultBytes = await this.callMethodWithWorker(
-        MethodName.EXECUTE_TRANSACTION,
+      const proverPayload = prover.serialize();
+      const result = await this.callMethodWithWorker(
+        MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER,
         accountId.toString(),
-        serializedTransactionRequest
+        serializedTransactionRequest,
+        proverPayload
       );
 
-      return wasm.TransactionResult.deserialize(
-        new Uint8Array(serializedResultBytes)
+      const transactionResult = wasm.TransactionResult.deserialize(
+        new Uint8Array(result.serializedTransactionResult)
       );
+
+      return transactionResult.id();
     } catch (error) {
-      console.error("INDEX.JS: Error in executeTransaction:", error.toString());
+      console.error(
+        "INDEX.JS: Error in submitNewTransactionWithProver:",
+        error
+      );
       throw error;
     }
   }
 
-  async submitTransaction(transactionResult, prover) {
+  async executeTransaction(accountId, transactionRequest) {
     try {
       if (!this.worker) {
         const wasmWebClient = await this.getWasmWebClient();
-        const proven = await wasmWebClient.proveTransaction(
-          transactionResult,
-          prover
-        );
-        const submissionHeight = await wasmWebClient.submitProvenTransaction(
-          proven,
-          transactionResult
-        );
-        return await wasmWebClient.applyTransaction(
-          transactionResult,
-          submissionHeight
+        return await wasmWebClient.executeTransaction(
+          accountId,
+          transactionRequest
         );
       }
 
       const wasm = await getWasmOrThrow();
-      const serializedTransactionResult = transactionResult.serialize();
-      const proverPayload = prover ? prover.serialize() : null;
-
-      const { submissionHeight, serializedTransactionUpdate } =
-        await this.callMethodWithWorker(
-          MethodName.SUBMIT_TRANSACTION,
-          serializedTransactionResult,
-          proverPayload
-        );
-
-      if (this instanceof MockWebClient) {
-        return wasm.TransactionStoreUpdate.deserialize(
-          new Uint8Array(serializedTransactionUpdate)
-        );
-      }
+      const serializedTransactionRequest = transactionRequest.serialize();
+      const serializedResultBytes = await this.callMethodWithWorker(
+        MethodName.EXECUTE_TRANSACTION,
+        accountId.toString(),
+        serializedTransactionRequest
+      );
 
-      const wasmWebClient = await this.getWasmWebClient();
-      return await wasmWebClient.applyTransaction(
-        transactionResult,
-        submissionHeight
+      return wasm.TransactionResult.deserialize(
+        new Uint8Array(serializedResultBytes)
       );
     } catch (error) {
-      console.error("INDEX.JS: Error in submitTransaction:", error.toString());
+      console.error("INDEX.JS: Error in executeTransaction:", error);
       throw error;
     }
   }
@@ -539,28 +817,73 @@ class WebClient {
         new Uint8Array(serializedProvenBytes)
       );
     } catch (error) {
-      console.error("INDEX.JS: Error in proveTransaction:", error.toString());
+      console.error("INDEX.JS: Error in proveTransaction:", error);
       throw error;
     }
   }
 
+  /**
+   * Syncs the client state with the node.
+   *
+   * 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).
+   *
+   * @returns {Promise<SyncSummary>} The sync summary
+   */
   async syncState() {
+    return this.syncStateWithTimeout(0);
+  }
+
+  /**
+   * 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).
+   *
+   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
+   * @returns {Promise<SyncSummary>} The sync summary
+   */
+  async syncStateWithTimeout(timeoutMs = 0) {
+    // Use storeName as the database ID for lock coordination
+    const dbId = this.storeName || "default";
+
     try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.syncState();
+      // Acquire the sync lock (coordinates concurrent calls)
+      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
+
+      if (!lockHandle.acquired) {
+        // We're coalescing - return the result from the in-progress sync
+        return lockHandle.coalescedResult;
       }
 
-      const wasm = await getWasmOrThrow();
-      const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-        MethodName.SYNC_STATE
-      );
+      // We acquired the lock - perform the sync
+      try {
+        let result;
+        if (!this.worker) {
+          const wasmWebClient = await this.getWasmWebClient();
+          result = await wasmWebClient.syncStateImpl();
+        } else {
+          const wasm = await getWasmOrThrow();
+          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+            MethodName.SYNC_STATE
+          );
+          result = wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        }
 
-      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.toString());
+      console.error("INDEX.JS: Error in syncState:", error);
       throw error;
     }
   }
@@ -574,7 +897,14 @@ class WebClient {
 
 class MockWebClient extends WebClient {
   constructor(seed) {
-    super(null, seed);
+    super(null, null, seed, "mock");
+  }
+
+  initializeWorker() {
+    this.worker.postMessage({
+      action: WorkerAction.INIT_MOCK,
+      args: [this.seed],
+    });
   }
 
   /**
@@ -624,65 +954,103 @@ class MockWebClient extends WebClient {
     });
   }
 
+  /**
+   * Syncs the mock client state.
+   *
+   * 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).
+   *
+   * @returns {Promise<SyncSummary>} The sync summary
+   */
   async syncState() {
+    return this.syncStateWithTimeout(0);
+  }
+
+  /**
+   * Syncs the mock client state with an optional timeout.
+   *
+   * @param {number} timeoutMs - Timeout in milliseconds (0 = no timeout)
+   * @returns {Promise<SyncSummary>} The sync summary
+   */
+  async syncStateWithTimeout(timeoutMs = 0) {
+    const dbId = this.storeName || "mock";
+
     try {
-      const wasmWebClient = await this.getWasmWebClient();
-      if (!this.worker) {
-        return await wasmWebClient.syncState();
+      const lockHandle = await acquireSyncLock(dbId, timeoutMs);
+
+      if (!lockHandle.acquired) {
+        return lockHandle.coalescedResult;
       }
 
-      let serializedMockChain = wasmWebClient.serializeMockChain().buffer;
-      let serializedMockNoteTransportNode =
-        wasmWebClient.serializeMockNoteTransportNode().buffer;
+      try {
+        let result;
+        const wasmWebClient = await this.getWasmWebClient();
 
-      const wasm = await getWasmOrThrow();
+        if (!this.worker) {
+          result = await wasmWebClient.syncStateImpl();
+        } else {
+          let serializedMockChain = wasmWebClient.serializeMockChain().buffer;
+          let serializedMockNoteTransportNode =
+            wasmWebClient.serializeMockNoteTransportNode().buffer;
 
-      const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-        MethodName.SYNC_STATE_MOCK,
-        serializedMockChain,
-        serializedMockNoteTransportNode
-      );
+          const wasm = await getWasmOrThrow();
 
-      return wasm.SyncSummary.deserialize(
-        new Uint8Array(serializedSyncSummaryBytes)
-      );
+          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+            MethodName.SYNC_STATE_MOCK,
+            serializedMockChain,
+            serializedMockNoteTransportNode
+          );
+
+          result = wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        }
+
+        releaseSyncLock(dbId, result);
+        return result;
+      } catch (error) {
+        releaseSyncLockWithError(dbId, error);
+        throw error;
+      }
     } catch (error) {
-      console.error("INDEX.JS: Error in syncState:", error.toString());
+      console.error("INDEX.JS: Error in syncState:", error);
       throw error;
     }
   }
 
-  async submitTransaction(transactionResult, prover) {
+  async submitNewTransaction(accountId, transactionRequest) {
     try {
       if (!this.worker) {
-        return await super.submitTransaction(transactionResult, prover);
+        return await super.submitNewTransaction(accountId, transactionRequest);
       }
 
       const wasmWebClient = await this.getWasmWebClient();
       const wasm = await getWasmOrThrow();
-      const serializedTransactionResult = transactionResult.serialize();
-      const proverPayload = prover ? prover.serialize() : null;
+      const serializedTransactionRequest = transactionRequest.serialize();
       const serializedMockChain = wasmWebClient.serializeMockChain().buffer;
       const serializedMockNoteTransportNode =
         wasmWebClient.serializeMockNoteTransportNode().buffer;
 
       const result = await this.callMethodWithWorker(
-        MethodName.SUBMIT_TRANSACTION_MOCK,
-        serializedTransactionResult,
-        proverPayload,
+        MethodName.SUBMIT_NEW_TRANSACTION_MOCK,
+        accountId.toString(),
+        serializedTransactionRequest,
         serializedMockChain,
         serializedMockNoteTransportNode
       );
+
       const newMockChain = new Uint8Array(result.serializedMockChain);
       const newMockNoteTransportNode = result.serializedMockNoteTransportNode
         ? new Uint8Array(result.serializedMockNoteTransportNode)
         : undefined;
 
+      const transactionResult = wasm.TransactionResult.deserialize(
+        new Uint8Array(result.serializedTransactionResult)
+      );
+
       if (!(this instanceof MockWebClient)) {
-        return await wasmWebClient.applyTransaction(
-          transactionResult,
-          result.submissionHeight
-        );
+        return transactionResult.id();
       }
 
       this.wasmWebClient = new wasm.WebClient();
@@ -693,32 +1061,36 @@ class MockWebClient extends WebClient {
         newMockNoteTransportNode
       );
 
-      return wasm.TransactionStoreUpdate.deserialize(
-        new Uint8Array(result.serializedTransactionUpdate)
-      );
+      return transactionResult.id();
     } catch (error) {
-      console.error("INDEX.JS: Error in submitTransaction:", error.toString());
+      console.error("INDEX.JS: Error in submitNewTransaction:", error);
       throw error;
     }
   }
 
-  async submitNewTransaction(accountId, transactionRequest) {
+  async submitNewTransactionWithProver(accountId, transactionRequest, prover) {
     try {
       if (!this.worker) {
-        return await super.submitNewTransaction(accountId, transactionRequest);
+        return await super.submitNewTransactionWithProver(
+          accountId,
+          transactionRequest,
+          prover
+        );
       }
 
       const wasmWebClient = await this.getWasmWebClient();
       const wasm = await getWasmOrThrow();
       const serializedTransactionRequest = transactionRequest.serialize();
+      const proverPayload = prover.serialize();
       const serializedMockChain = wasmWebClient.serializeMockChain().buffer;
       const serializedMockNoteTransportNode =
         wasmWebClient.serializeMockNoteTransportNode().buffer;
 
       const result = await this.callMethodWithWorker(
-        MethodName.SUBMIT_NEW_TRANSACTION_MOCK,
+        MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK,
         accountId.toString(),
         serializedTransactionRequest,
+        proverPayload,
         serializedMockChain,
         serializedMockNoteTransportNode
       );
@@ -747,8 +1119,8 @@ class MockWebClient extends WebClient {
       return transactionResult.id();
     } catch (error) {
       console.error(
-        "INDEX.JS: Error in submitNewTransaction:",
-        error.toString()
+        "INDEX.JS: Error in submitNewTransactionWithProver:",
+        error
       );
       throw error;
     }