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

package/dist/st/index.js

@@ -2540,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) => {
@@ -2653,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;
       }
@@ -3232,147 +3272,160 @@ 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;
+      }
+    });
   }
 
   /**
@@ -3389,18 +3442,24 @@ class WebClient {
     const methodId = MethodName.SYNC_STATE;
 
     try {
-      return await withSyncLock(dbId, methodId, 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)
-        );
-      });
+      // 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;
@@ -3417,14 +3476,16 @@ class WebClient {
     const methodId = MethodName.SYNC_NOTE_TRANSPORT;
 
     try {
-      await withSyncLock(dbId, methodId, async () => {
-        if (!this.worker) {
-          const wasmWebClient = await this.getWasmWebClient();
-          await wasmWebClient.syncNoteTransportImpl();
-        } else {
-          await this.callMethodWithWorker(methodId);
-        }
-      });
+      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;
@@ -3441,18 +3502,20 @@ class WebClient {
     const methodId = MethodName.SYNC_CHAIN;
 
     try {
-      return await withSyncLock(dbId, methodId, async () => {
-        if (!this.worker) {
-          const wasmWebClient = await this.getWasmWebClient();
-          return await wasmWebClient.syncChainImpl();
-        }
-        const wasm = await getWasmOrThrow();
-        const serializedSyncSummaryBytes =
-          await this.callMethodWithWorker(methodId);
-        return wasm.SyncSummary.deserialize(
-          new Uint8Array(serializedSyncSummaryBytes)
-        );
-      });
+      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(methodId);
+          return wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        })
+      );
     } catch (error) {
       console.error("INDEX.JS: Error in syncChain:", error);
       throw error;
@@ -3561,29 +3624,31 @@ class MockWebClient extends WebClient {
     const methodId = MethodName.SYNC_STATE;
 
     try {
-      return await withSyncLock(dbId, methodId, async () => {
-        const wasmWebClient = await this.getWasmWebClient();
-
-        if (!this.worker) {
-          return await wasmWebClient.syncStateImpl();
-        }
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
 
-        const serializedMockChain = (await wasmWebClient.serializeMockChain())
-          .buffer;
-        const serializedMockNoteTransportNode = (
-          await wasmWebClient.serializeMockNoteTransportNode()
-        ).buffer;
+          if (!this.worker) {
+            return await wasmWebClient.syncStateImpl();
+          }
 
-        const wasm = await getWasmOrThrow();
-        const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-          MethodName.SYNC_STATE_MOCK,
-          serializedMockChain,
-          serializedMockNoteTransportNode
-        );
-        return wasm.SyncSummary.deserialize(
-          new Uint8Array(serializedSyncSummaryBytes)
-        );
-      });
+          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;
@@ -3605,29 +3670,31 @@ class MockWebClient extends WebClient {
     const methodId = MethodName.SYNC_CHAIN;
 
     try {
-      return await withSyncLock(dbId, methodId, async () => {
-        const wasmWebClient = await this.getWasmWebClient();
-
-        if (!this.worker) {
-          return await wasmWebClient.syncChainImpl();
-        }
+      return await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
 
-        const serializedMockChain = (await wasmWebClient.serializeMockChain())
-          .buffer;
-        const serializedMockNoteTransportNode = (
-          await wasmWebClient.serializeMockNoteTransportNode()
-        ).buffer;
+          if (!this.worker) {
+            return await wasmWebClient.syncChainImpl();
+          }
 
-        const wasm = await getWasmOrThrow();
-        const serializedSyncSummaryBytes = await this.callMethodWithWorker(
-          MethodName.SYNC_CHAIN_MOCK,
-          serializedMockChain,
-          serializedMockNoteTransportNode
-        );
-        return wasm.SyncSummary.deserialize(
-          new Uint8Array(serializedSyncSummaryBytes)
-        );
-      });
+          const serializedMockChain = (await wasmWebClient.serializeMockChain())
+            .buffer;
+          const serializedMockNoteTransportNode = (
+            await wasmWebClient.serializeMockNoteTransportNode()
+          ).buffer;
+
+          const wasm = await getWasmOrThrow();
+          const serializedSyncSummaryBytes = await this.callMethodWithWorker(
+            MethodName.SYNC_CHAIN_MOCK,
+            serializedMockChain,
+            serializedMockNoteTransportNode
+          );
+          return wasm.SyncSummary.deserialize(
+            new Uint8Array(serializedSyncSummaryBytes)
+          );
+        })
+      );
     } catch (error) {
       console.error("INDEX.JS: Error in syncChain:", error);
       throw error;
@@ -3648,26 +3715,28 @@ class MockWebClient extends WebClient {
     const methodId = MethodName.SYNC_NOTE_TRANSPORT;
 
     try {
-      await withSyncLock(dbId, methodId, async () => {
-        const wasmWebClient = await this.getWasmWebClient();
+      await withSyncLock(dbId, methodId, async () =>
+        this._serializeWasmCall(async () => {
+          const wasmWebClient = await this.getWasmWebClient();
 
-        if (!this.worker) {
-          await wasmWebClient.syncNoteTransportImpl();
-          return;
-        }
+          if (!this.worker) {
+            await wasmWebClient.syncNoteTransportImpl();
+            return;
+          }
 
-        const serializedMockChain = (await wasmWebClient.serializeMockChain())
-          .buffer;
-        const serializedMockNoteTransportNode = (
-          await wasmWebClient.serializeMockNoteTransportNode()
-        ).buffer;
+          const serializedMockChain = (await wasmWebClient.serializeMockChain())
+            .buffer;
+          const serializedMockNoteTransportNode = (
+            await wasmWebClient.serializeMockNoteTransportNode()
+          ).buffer;
 
-        await this.callMethodWithWorker(
-          MethodName.SYNC_NOTE_TRANSPORT_MOCK,
-          serializedMockChain,
-          serializedMockNoteTransportNode
-        );
-      });
+          await this.callMethodWithWorker(
+            MethodName.SYNC_NOTE_TRANSPORT_MOCK,
+            serializedMockChain,
+            serializedMockNoteTransportNode
+          );
+        })
+      );
     } catch (error) {
       console.error("INDEX.JS: Error in syncNoteTransport:", error);
       throw error;