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

package/dist/mt/index.js

@@ -1,6 +1,5 @@
 import loadWasm from './wasm.js';
-import { AccountArray as AccountArray$1, AccountIdArray as AccountIdArray$1, FeltArray as FeltArray$1, ForeignAccountArray as ForeignAccountArray$1, NoteAndArgsArray as NoteAndArgsArray$1, NoteArray as NoteArray$1, NoteIdAndArgsArray as NoteIdAndArgsArray$1, NoteRecipientArray as NoteRecipientArray$1, OutputNoteArray as OutputNoteArray$1, StorageSlotArray as StorageSlotArray$1, TransactionScriptInputPairArray as TransactionScriptInputPairArray$1 } from './Cargo-CZopJ--X.js';
-export { Account, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountInterface, AccountProof, AccountReader, AccountStatus, AccountStorage, AccountStorageDelta, AccountStorageMode, AccountStorageRequirements, AccountVaultDelta, Address, AdviceInputs, AdviceMap, AssetVault, AuthFalcon512RpoMultisigConfig, AuthSecretKey, BasicFungibleFaucetComponent, BlockHeader, CodeBuilder, CommittedNote, ConsumableNoteRecord, Endpoint, ExecutedTransaction, Felt, FetchedAccount, FetchedNote, FlattenedU8Vec, ForeignAccount, FungibleAsset, FungibleAssetDelta, FungibleAssetDeltaItem, GetProceduresResultItem, InputNote, InputNoteRecord, InputNoteState, InputNotes, IntoUnderlyingByteSource, IntoUnderlyingSink, IntoUnderlyingSource, JsAccountUpdate, JsStateSyncUpdate, JsStorageMapEntry, JsStorageSlot, JsVaultAsset, Library, MerklePath, NetworkId, NetworkType, Note, NoteAndArgs, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteScript, NoteStorage, NoteSyncBlock, NoteSyncInfo, NoteTag, NoteType, OutputNote, OutputNoteRecord, OutputNoteState, OutputNotes, Package, PartialNote, Poseidon2, ProcedureThreshold, Program, ProvenTransaction, PublicKey, RpcClient, Rpo256, SerializedInputNoteData, SerializedOutputNoteData, SerializedTransactionData, Signature, SigningInputs, SigningInputsType, SlotAndKeys, SparseMerklePath, StorageMap, StorageMapEntry, StorageMapInfo, StorageMapUpdate, StorageSlot, SyncSummary, TestUtils, TokenSymbol, TransactionArgs, TransactionFilter, TransactionId, TransactionProver, TransactionRecord, TransactionRequest, TransactionRequestBuilder, TransactionResult, TransactionScript, TransactionScriptInputPair, TransactionStatus, TransactionStoreUpdate, TransactionSummary, WebClient, WebKeystoreApi, Word, createAuthFalcon512RpoMultisig, exportStore, importStore, initSync, initThreadPool, parallelSumBench, rayonThreadCount, sequentialSumBench, setupLogging, wbg_rayon_PoolBuilder, wbg_rayon_start_worker } from './Cargo-CZopJ--X.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';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -352,31 +351,18 @@ function resolveStorageMode(mode, wasm) {
 }
 
 /**
- * Resolves an auth scheme string to a WASM `AuthScheme` enum numeric value.
+ * Resolves an auth scheme string to a WASM AuthScheme enum value.
  *
- * The public `AuthScheme` constant exposes SDK-friendly strings
- * (`"falcon"` / `"ecdsa"`), but low-level wasm-bindgen methods such as
- * `AccountComponent.createAuthComponentFromCommitment(commitment, scheme)`
- * expect the numeric variant from the Rust `AuthScheme` enum. This helper
- * bridges the two so callers never touch wasm-bindgen internals directly.
- *
- * `wasm` is optional: when provided (by internal callers who already have
- * the module loaded), the numeric value is read from the binding itself,
- * keeping the mapping robust if wasm-bindgen ever renumbers the enum. When
- * omitted (public callers who don't have a handle to the WASM module), the
- * hardcoded discriminants below are used — these are pinned to the Rust
- * enum order by a cross-check test in `test/account_component.test.ts`.
- *
- * @param {"falcon" | "ecdsa" | undefined} scheme - Defaults to `"falcon"`.
- * @param {object} [wasm] - Optional WASM module handle.
- * @returns {number} The AuthScheme enum numeric value (1 or 2).
+ * @param {string | undefined} scheme - "falcon" or "ecdsa". Defaults to "falcon".
+ * @param {object} wasm - The WASM module.
+ * @returns {number} The AuthScheme enum value.
  */
 function resolveAuthScheme(scheme, wasm) {
   if (scheme === "ecdsa") {
-    return wasm?.AuthScheme?.AuthEcdsaK256Keccak ?? 1;
+    return wasm.AuthScheme.AuthEcdsaK256Keccak;
   }
   if (scheme === "falcon" || scheme == null) {
-    return wasm?.AuthScheme?.AuthRpoFalcon512 ?? 2;
+    return wasm.AuthScheme.AuthRpoFalcon512;
   }
   throw new Error(
     `Unknown auth scheme: "${scheme}". Expected "falcon" or "ecdsa".`
@@ -519,6 +505,7 @@ class AccountsResource {
       return await this.#inner.newFaucet(
         storageMode,
         type === 1 || type === "NonFungibleFaucet",
+        opts.name ?? opts.symbol,
         opts.symbol,
         opts.decimals,
         BigInt(opts.maxSupply),
@@ -551,21 +538,27 @@ class AccountsResource {
     if (!opts.auth)
       throw new Error("Contract creation requires an 'auth' (AuthSecretKey)");
 
-    // Default to immutable when type is omitted (safer for contracts)
-    const mutable = opts.type === "MutableContract" || opts.type === 3;
-    const accountTypeEnum = mutable
-      ? wasm.AccountType.RegularAccountUpdatableCode
-      : wasm.AccountType.RegularAccountImmutableCode;
+    // The 0.15 protocol has no code-mutability distinction, so the `type`
+    // ("ImmutableContract" / "MutableContract") only steers routing here; the
+    // account's on-chain visibility is set entirely by `storageMode`.
     const storageMode = resolveStorageMode(opts.storage ?? "public", wasm);
     const authComponent =
       wasm.AccountComponent.createAuthComponentFromSecretKey(opts.auth);
 
+    // Schema commitment from `build()` is not a substitute for contract code; require explicit
+    // `components` so auth-only contracts are rejected at this layer.
+    const components = opts.components ?? [];
+    if (components.length === 0) {
+      throw new Error(
+        "Contract accounts require at least one non-auth procedure: pass at least one entry in `components`."
+      );
+    }
+
     let builder = new wasm.AccountBuilder(opts.seed)
-      .accountType(accountTypeEnum)
       .storageMode(storageMode)
       .withAuthComponent(authComponent);
 
-    for (const component of opts.components ?? []) {
+    for (const component of components) {
       builder = builder.withComponent(component);
     }
 
@@ -607,7 +600,9 @@ class AccountsResource {
     if (!account) {
       throw new Error(`Account not found: ${id.toString()}`);
     }
-    const keys = await this.#inner.keystore.getCommitments(id);
+    const keys = this.#inner.keystore
+      ? await this.#inner.keystore.getCommitments(id)
+      : await this.#inner.getPublicKeyCommitmentsOfAccount(id);
     return {
       account,
       vault: account.vault(),
@@ -622,7 +617,7 @@ class AccountsResource {
     const wasm = await this.#getWasm();
     const accountId = resolveAccountRef(accountRef, wasm);
     const faucetId = resolveAccountRef(tokenRef, wasm);
-    const reader = this.#inner.accountReader(accountId);
+    const reader = await this.#inner.accountReader(accountId);
     return await reader.getBalance(faucetId);
   }
 
@@ -870,6 +865,72 @@ class TransactionsResource {
     return { txId, result };
   }
 
+  /** Create a partial-swap (PSWAP) note. See {@link PswapCreateOptions}. */
+  async pswapCreate(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapCreateRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
+  /** Consume (fully or partially fill) a PSWAP note. See {@link PswapConsumeOptions}. */
+  async pswapConsume(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapConsumeRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
+  /** Cancel a PSWAP note as its creator and reclaim the offered asset. See {@link PswapCancelOptions}. */
+  async pswapCancel(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildPswapCancelRequest(
+      opts,
+      wasm
+    );
+
+    const { txId, result } = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return { txId, result };
+  }
+
   async preview(opts) {
     this.#client.assertNotTerminated();
     const wasm = await this.#getWasm();
@@ -894,6 +955,27 @@ class TransactionsResource {
         ({ accountId, request } = await this.#buildSwapRequest(opts, wasm));
         break;
       }
+      case "pswapCreate": {
+        ({ accountId, request } = await this.#buildPswapCreateRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
+      case "pswapConsume": {
+        ({ accountId, request } = await this.#buildPswapConsumeRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
+      case "pswapCancel": {
+        ({ accountId, request } = await this.#buildPswapCancelRequest(
+          opts,
+          wasm
+        ));
+        break;
+      }
       case "custom": {
         accountId = resolveAccountRef(opts.account, wasm);
         request = opts.request;
@@ -1180,6 +1262,53 @@ class TransactionsResource {
     return { accountId, request };
   }
 
+  async #buildPswapCreateRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const offeredFaucetId = resolveAccountRef(opts.offer.token, wasm);
+    const requestedFaucetId = resolveAccountRef(opts.request.token, wasm);
+    const noteType = resolveNoteType(opts.type, wasm);
+    const paybackNoteType = resolveNoteType(
+      opts.paybackType ?? opts.type,
+      wasm
+    );
+
+    const request = await this.#inner.newPswapCreateTransactionRequest(
+      accountId,
+      offeredFaucetId,
+      BigInt(opts.offer.amount),
+      requestedFaucetId,
+      BigInt(opts.request.amount),
+      noteType,
+      paybackNoteType
+    );
+    return { accountId, request };
+  }
+
+  async #buildPswapConsumeRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const note = await this.#resolveNoteInput(opts.note);
+    const noteFillAmount = opts.noteFillAmount ?? 0n;
+
+    const request = await this.#inner.newPswapConsumeTransactionRequest(
+      note,
+      accountId,
+      BigInt(opts.fillAmount),
+      BigInt(noteFillAmount)
+    );
+    return { accountId, request };
+  }
+
+  async #buildPswapCancelRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const note = await this.#resolveNoteInput(opts.note);
+
+    const request = await this.#inner.newPswapCancelTransactionRequest(
+      note,
+      accountId
+    );
+    return { accountId, request };
+  }
+
   async #resolveNoteInput(input) {
     if (typeof input === "string") {
       const record = await this.#inner.getInputNote(input);
@@ -1215,13 +1344,8 @@ class TransactionsResource {
   async #submitOrSubmitWithProver(accountId, request, perCallProver) {
     const result = await this.#inner.executeTransaction(accountId, request);
     const prover = perCallProver ?? this.#client.defaultProver;
-    // Use proveTransactionWithProver (by-reference) when a prover is
-    // provided, so the JS-side handle is NOT consumed by wasm-bindgen.
-    // Passing the prover by value would transfer ownership and invalidate
-    // the JS object after one call, causing silent fallback to local
-    // proving on reuse.
     const proven = prover
-      ? await this.#inner.proveTransactionWithProver(result, prover)
+      ? await this.#inner.proveTransaction(result, prover)
       : await this.#inner.proveTransaction(result);
     const txId = result.id();
     const height = await this.#inner.submitProvenTransaction(proven, result);
@@ -1432,7 +1556,7 @@ class CompilerResource {
   async component({ code, slots = [], supportAllTypes = true }) {
     this.#client?.assertNotTerminated();
     const wasm = await this.#getWasm();
-    const builder = this.#inner.createCodeBuilder();
+    const builder = await this.#inner.createCodeBuilder();
     const compiled = builder.compileAccountComponentCode(code);
     const component = wasm.AccountComponent.compile(compiled, slots);
     return supportAllTypes ? component.withSupportsAllTypes() : component;
@@ -1448,7 +1572,7 @@ class CompilerResource {
     this.#client?.assertNotTerminated();
     // Ensure WASM is initialized (result unused — only #inner needs it)
     await this.#getWasm();
-    const builder = this.#inner.createCodeBuilder();
+    const builder = await this.#inner.createCodeBuilder();
     linkLibraries(builder, libraries);
     return builder.compileTxScript(code);
   }
@@ -1462,7 +1586,7 @@ class CompilerResource {
   async noteScript({ code, libraries = [] }) {
     this.#client?.assertNotTerminated();
     await this.#getWasm();
-    const builder = this.#inner.createCodeBuilder();
+    const builder = await this.#inner.createCodeBuilder();
     linkLibraries(builder, libraries);
     return builder.compileNoteScript(code);
   }
@@ -1498,32 +1622,47 @@ class KeystoreResource {
 
   async insert(accountId, secretKey) {
     this.#client.assertNotTerminated();
-    const ks = this.#inner.keystore;
-    return await ks.insert(accountId, secretKey);
+    if (this.#inner.keystore) {
+      return await this.#inner.keystore.insert(accountId, secretKey);
+    }
+    return await this.#inner.addAccountSecretKeyToWebStore(
+      accountId,
+      secretKey
+    );
   }
 
   async get(pubKeyCommitment) {
     this.#client.assertNotTerminated();
-    const ks = this.#inner.keystore;
-    return await ks.get(pubKeyCommitment);
+    if (this.#inner.keystore) {
+      return await this.#inner.keystore.get(pubKeyCommitment);
+    }
+    return await this.#inner.getAccountAuthByPubKeyCommitment(pubKeyCommitment);
   }
 
   async remove(pubKeyCommitment) {
     this.#client.assertNotTerminated();
-    const ks = this.#inner.keystore;
-    return await ks.remove(pubKeyCommitment);
+    if (this.#inner.keystore) {
+      return await this.#inner.keystore.remove(pubKeyCommitment);
+    }
+    throw new Error("remove() is not supported on this platform");
   }
 
   async getCommitments(accountId) {
     this.#client.assertNotTerminated();
-    const ks = this.#inner.keystore;
-    return await ks.getCommitments(accountId);
+    if (this.#inner.keystore) {
+      return await this.#inner.keystore.getCommitments(accountId);
+    }
+    return await this.#inner.getPublicKeyCommitmentsOfAccount(accountId);
   }
 
   async getAccountId(pubKeyCommitment) {
     this.#client.assertNotTerminated();
-    const ks = this.#inner.keystore;
-    return await ks.getAccountId(pubKeyCommitment);
+    if (this.#inner.keystore) {
+      return await this.#inner.keystore.getAccountId(pubKeyCommitment);
+    }
+    const account =
+      await this.#inner.getAccountByKeyCommitment(pubKeyCommitment);
+    return account ? account.id() : undefined;
   }
 }
 
@@ -1678,7 +1817,7 @@ class MidenClient {
         options.keystore.getKey,
         options.keystore.insertKey,
         options.keystore.sign,
-        undefined,
+        options?.debugMode,
         useWorker
       );
     } else {
@@ -1687,7 +1826,7 @@ class MidenClient {
         noteTransportUrl,
         seed,
         options?.storeName,
-        undefined,
+        options?.debugMode,
         useWorker
       );
     }
@@ -1868,6 +2007,13 @@ class MidenClient {
    * otherwise erase. Call immediately after catching a failed
    * `transactions.submit` / `transactions.send` / `transactions.consume`.
    *
+   * Meaningful only with `useWorker: false`: under the worker shim the
+   * sign callback fires against the worker's WASM keystore, while this
+   * accessor reads the main-thread instance — which never signed — so it
+   * returns `null`. Consumers that need this signal (e.g. external
+   * keystores with lock-aware sign callbacks) already require
+   * `useWorker: false` for the callback to be reachable at all.
+   *
    * @returns {any} The raw thrown value, or `null`.
    */
   lastAuthError() {
@@ -1896,9 +2042,9 @@ class MidenClient {
    *
    * @returns {string} The store identifier.
    */
-  storeIdentifier() {
+  async storeIdentifier() {
     this.assertNotTerminated();
-    return this.#inner.storeIdentifier();
+    return await this.#inner.storeIdentifier();
   }
 
   // ── Mock-only methods ──
@@ -2112,55 +2258,337 @@ function buildNoteAssets(assets, wasm) {
 }
 
 /**
- * Non-consuming wrappers for wasm-bindgen-generated array classes.
+ * StorageView wraps the raw WASM AccountStorage to provide a developer-friendly
+ * (and AI-agent-friendly) API.
  *
- * The default wasm-bindgen-generated constructor for an exported `Vec<T>`
- * parameter (e.g. `pub fn new(elements: Option<Vec<Note>>) -> Self`) takes
- * each input element by value: the Rust-side value is moved out of the
- * caller's JS handle. The handle is left dangling — its `__wbg_ptr` field
- * is unchanged so the JS object looks fine, but any subsequent method call
- * panics inside WASM with the opaque `"null pointer passed to rust"`
- * error from wasm-bindgen.
+ * Key behavior: `getItem()` returns a `StorageResult` that works intuitively for
+ * both Value and StorageMap slots. The result has `.toBigInt()`, `.toHex()`, and
+ * `.toString()` methods that do the right thing automatically. For StorageMap slots,
+ * `.entries` provides access to all map entries.
  *
- * That's a footgun for JS users, who don't expect "this object can no
- * longer be used" semantics from a constructor like
- * `new NoteArray([note])`. So we wrap each affected array with a class
- * that builds the same array via `push(&T)` — which already borrows +
- * clones — leaving the originals fully usable afterwards.
+ * Numeric ergonomics: `StorageResult` is usable directly in template strings,
+ * JSX, and arithmetic via `toString()` (lossless, BigInt-backed) and `valueOf()`
+ * (returns a JS number for values that fit, throws on overflow — never silently
+ * corrupts). For exact u64 access use `.toBigInt()`.
  *
- * The wrapper extends the wasm-bindgen base class, so `instanceof` checks
- * (including `_assertClass(...)` in other auto-generated wasm-bindgen
- * methods) keep working transparently.
+ * The raw WASM AccountStorage is still accessible via `.raw` for advanced use cases
+ * that need the original behavior (e.g., comparing map commitment roots).
  */
+/** @param {string} hex @param {typeof Word} WordClass @returns {Word | undefined} */
+function hexToWord(hex, WordClass) {
+  if (!hex || !WordClass) return undefined;
+  try {
+    return WordClass.fromHex(hex);
+  } catch {
+    return undefined;
+  }
+}
 
+class StorageView {
+  #storage;
+  #WordClass;
 
-function makeSafeArray(Base) {
-  return class extends Base {
-    constructor(elements) {
-      super(); // empty Rust Vec — no consume
-      if (Array.isArray(elements)) {
-        for (const el of elements) {
-          // push(&T) on Base borrows and clones — input handles stay valid.
-          this.push(el);
-        }
-      }
+  /**
+   * @param {AccountStorage} wasmStorage
+   * @param {typeof Word} WordClass
+   */
+  constructor(wasmStorage, WordClass) {
+    this.#storage = wasmStorage;
+    this.#WordClass = WordClass;
+  }
+
+  /**
+   * The raw WASM AccountStorage, for cases where you need the original
+   * primitive behavior (e.g., reading map commitment roots via raw.getItem()).
+   */
+  get raw() {
+    return this.#storage;
+  }
+
+  /**
+   * Returns the commitment to the full account storage.
+   */
+  commitment() {
+    return this.#storage.commitment();
+  }
+
+  /**
+   * Returns the names of all storage slots on this account.
+   * @returns {string[]}
+   */
+  getSlotNames() {
+    return this.#storage.getSlotNames();
+  }
+
+  /**
+   * Returns a StorageResult for the given slot.
+   *
+   * The result has convenience methods that work for both Value and StorageMap slots:
+   * - `.toBigInt()` — first felt as BigInt (full u64 precision)
+   * - `.toHex()` — first felt's Word as hex string
+   * - `.toString()` — renders as the BigInt value (works in JSX: {result})
+   * - `.isMap` — true if this is a StorageMap slot
+   * - `.entries` — all map entries (undefined for Value slots)
+   * - `.word` — the underlying Word value
+   *
+   * The result is also usable directly in arithmetic (`+result`, `result * 2`)
+   * via `valueOf()`, which returns a JS number for values that fit and throws
+   * `RangeError` for values exceeding `Number.MAX_SAFE_INTEGER` — use `.toBigInt()`
+   * for exact access to large u64 values.
+   *
+   * For explicit key-based map reads, use `getMapItem(slotName, key)`.
+   * For the raw commitment hash, use `raw.getItem(slotName)`.
+   *
+   * @param {string} slotName
+   * @returns {StorageResult | undefined}
+   */
+  getItem(slotName) {
+    // Type detection + value retrieval in one pass.
+    // We call getMapEntries to detect maps, but defer parsing the entries
+    // until .entries is actually accessed (lazy). Only the first entry's
+    // Word is parsed eagerly for the convenience methods (toBigInt, etc.).
+    const rawEntries = this.#storage.getMapEntries(slotName);
+    if (rawEntries !== undefined && rawEntries !== null) {
+      // StorageMap — parse only the first entry eagerly
+      const firstWord =
+        rawEntries.length > 0
+          ? hexToWord(rawEntries[0].value, this.#WordClass)
+          : undefined;
+      return new StorageResult(firstWord, true, rawEntries, this.#WordClass);
     }
-  };
+
+    // Value slot — use raw getItem
+    const word = this.#storage.getItem(slotName);
+    if (!word) return undefined;
+    return new StorageResult(word, false, undefined, this.#WordClass);
+  }
+
+  /**
+   * Returns the value for a key in a StorageMap slot.
+   * Delegates directly to the raw WASM method.
+   *
+   * @param {string} slotName
+   * @param {Word} key
+   * @returns {Word | undefined}
+   */
+  getMapItem(slotName, key) {
+    return this.#storage.getMapItem(slotName, key);
+  }
+
+  /**
+   * Get all key-value pairs from a StorageMap slot.
+   * Returns undefined if the slot isn't a map, or an empty array if the map is empty.
+   */
+  getMapEntries(slotName) {
+    return this.#storage.getMapEntries(slotName);
+  }
+
+  /**
+   * Returns the commitment root of a storage slot as a Word.
+   *
+   * For Value slots, this is the stored Word itself.
+   * For StorageMap slots, this is the Merkle root hash of the map — useful for:
+   * - Verifying state hasn't changed between transactions
+   * - Merkle inclusion proofs against the account state
+   * - Comparing map state across accounts or sync cycles
+   *
+   * This is the raw protocol-level value. For reading stored data, use `getItem()`.
+   *
+   * @param {string} slotName
+   * @returns {Word | undefined}
+   */
+  getCommitment(slotName) {
+    return this.#storage.getItem(slotName);
+  }
 }
 
-const AccountArray = makeSafeArray(AccountArray$1);
-const AccountIdArray = makeSafeArray(AccountIdArray$1);
-const FeltArray = makeSafeArray(FeltArray$1);
-const ForeignAccountArray = makeSafeArray(ForeignAccountArray$1);
-const NoteAndArgsArray = makeSafeArray(NoteAndArgsArray$1);
-const NoteArray = makeSafeArray(NoteArray$1);
-const NoteIdAndArgsArray = makeSafeArray(NoteIdAndArgsArray$1);
-const NoteRecipientArray = makeSafeArray(NoteRecipientArray$1);
-const OutputNoteArray = makeSafeArray(OutputNoteArray$1);
-const StorageSlotArray = makeSafeArray(StorageSlotArray$1);
-const TransactionScriptInputPairArray = makeSafeArray(
-  TransactionScriptInputPairArray$1
-);
+/**
+ * Result of reading a storage slot. Works for both Value and StorageMap slots.
+ *
+ * Provides a unified interface so code like `storage.getItem(name).toBigInt()`
+ * works regardless of the underlying slot type.
+ *
+ * For StorageMap slots, the convenience methods (toHex, toBigInt) operate on
+ * the first entry's value. The full map data is available via `.entries`.
+ * Note: Miden storage maps are Merkle-based, so "first" is determined by key hash
+ * order — deterministic for a given map state, but not meaningful as an ordering.
+ */
+class StorageResult {
+  #word;
+  #isMap;
+  #rawEntries; // Raw JsStorageMapEntry[] from WASM — parsed lazily
+  #parsedEntries; // Parsed entries with Word objects — created on first .entries access
+  #WordClass;
+
+  /**
+   * @param {Word | undefined} word — the primary Word value (first entry for maps)
+   * @param {boolean} isMap — whether this came from a StorageMap slot
+   * @param {Array | undefined} rawEntries — raw WASM entries (parsed lazily on .entries access)
+   * @param {typeof Word} WordClass — Word constructor for hex parsing
+   */
+  constructor(word, isMap, rawEntries, WordClass) {
+    this.#word = word;
+    this.#isMap = isMap;
+    this.#rawEntries = rawEntries;
+    this.#WordClass = WordClass;
+  }
+
+  /** True if this slot is a StorageMap. */
+  get isMap() {
+    return this.#isMap;
+  }
+
+  /**
+   * All entries from a StorageMap slot (lazily parsed on first access).
+   * Each entry has { key: string (hex), value: string (hex), word: Word | undefined }.
+   * Returns undefined for Value slots.
+   */
+  get entries() {
+    if (!this.#isMap) return undefined;
+    if (this.#parsedEntries) return this.#parsedEntries;
+    if (!this.#rawEntries) return [];
+
+    // Parse entries lazily — only when the user actually accesses .entries
+    this.#parsedEntries = this.#rawEntries.map((e) => ({
+      key: e.key,
+      value: e.value,
+      word: hexToWord(e.value, this.#WordClass),
+    }));
+    this.#rawEntries = undefined; // Free raw entries
+    return this.#parsedEntries;
+  }
+
+  /**
+   * The underlying Word value.
+   * For Value slots: the stored Word.
+   * For StorageMap slots: the first entry's value as a Word (or undefined if empty).
+   */
+  get word() {
+    return this.#word;
+  }
+
+  /**
+   * Returns all four Felts of the stored Word as an array.
+   * Pass-through to Word.toFelts() — ensures code that expects a Word-like
+   * object (e.g., `result.toFelts()[0].asInt()`) works on StorageResult.
+   * @returns {Felt[]}
+   */
+  toFelts() {
+    if (!this.#word) return [];
+    return this.#word.toFelts();
+  }
+
+  /**
+   * The first Felt of the stored Word.
+   * Returns the WASM Felt object — use .asInt() to get its BigInt value.
+   * @returns {Felt | undefined}
+   */
+  felt() {
+    if (!this.#word) return undefined;
+    const felts = this.#word.toFelts();
+    return felts?.[0];
+  }
+
+  /**
+   * First felt as a BigInt. Preserves full u64 precision.
+   * @returns {bigint}
+   */
+  toBigInt() {
+    if (!this.#word) return 0n;
+    return wordToBigInt(this.#word);
+  }
+
+  /**
+   * The Word's hex representation.
+   * For Value slots: the stored Word hex.
+   * For StorageMap slots: the first entry's value Word hex.
+   * @returns {string}
+   */
+  toHex() {
+    if (!this.#word) return "0x" + "0".repeat(64);
+    return this.#word.toHex();
+  }
+
+  /**
+   * Renders as the BigInt value (lossless). Makes `{storageResult}` work in JSX
+   * and template literals: `` `value: ${result}` ``.
+   * @returns {string}
+   */
+  toString() {
+    return this.toBigInt().toString();
+  }
+
+  /**
+   * JSON serialization — returns the value as a string to avoid
+   * precision loss for large u64 felt values.
+   */
+  toJSON() {
+    return this.toBigInt().toString();
+  }
+
+  /**
+   * Allows `+result`, `result * 2`, etc. to work as expected.
+   *
+   * Returns a JS number for values that fit in `Number.MAX_SAFE_INTEGER`
+   * (2^53 - 1). For larger u64 values, throws `RangeError` rather than
+   * silently losing precision — use `.toBigInt()` to access the exact value.
+   *
+   * @returns {number}
+   * @throws {RangeError} if the underlying felt exceeds Number.MAX_SAFE_INTEGER
+   */
+  valueOf() {
+    const big = this.toBigInt();
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError(
+        `StorageResult value ${big} exceeds Number.MAX_SAFE_INTEGER ` +
+          `(${Number.MAX_SAFE_INTEGER}) — use .toBigInt() to read the exact value.`
+      );
+    }
+    return Number(big);
+  }
+}
+
+/**
+ * Convert a Word's first felt to a BigInt.
+ * Uses BigInt to preserve full u64 precision (felts are u64-backed).
+ * Handles the little-endian byte order of felt serialization.
+ *
+ * @param {Word} word
+ * @returns {bigint}
+ */
+function wordToBigInt(word) {
+  try {
+    const hex = word.toHex();
+    // Word.toHex() returns "0x" + 64 hex chars (4 felts × 16 hex chars each).
+    // Each felt is serialized as 8 little-endian bytes, so we take the first 16
+    // hex chars (first felt) and reverse the byte pairs to get the integer value.
+    const feltHex = hex.slice(2, 18);
+    const bytes = feltHex.match(/../g);
+    if (!bytes) return 0n;
+    return BigInt("0x" + bytes.reverse().join(""));
+  } catch {
+    return 0n;
+  }
+}
+
+/**
+ * Install the StorageView wrapper on Account.prototype.storage().
+ * After this, `account.storage()` returns a StorageView instead of raw AccountStorage.
+ *
+ * @param {object} wasmModule — the loaded WASM module containing Account, Word, etc.
+ */
+function installStorageView(wasmModule) {
+  const AccountProto = wasmModule.Account?.prototype;
+  if (!AccountProto || !AccountProto.storage) return;
+
+  const originalStorage = AccountProto.storage;
+  const WordClass = wasmModule.Word;
+
+  AccountProto.storage = function () {
+    const raw = originalStorage.call(this);
+    return new StorageView(raw, WordClass);
+  };
+}
 
 const AccountType = Object.freeze({
   // WASM-compatible numeric values — usable with AccountBuilder directly
@@ -2188,7 +2616,6 @@ const NoteVisibility = Object.freeze({
 const StorageMode = Object.freeze({
   Public: "public",
   Private: "private",
-  Network: "network",
 });
 
 const Linking = Object.freeze({
@@ -2196,43 +2623,6 @@ 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.
-//
-// Note on `SYNC_METHODS`: the classifier is "synchronous in JS" — i.e.
-// `pub fn ...` in Rust, not `pub async fn ...`. Two sub-cases:
-//   1. Factory methods that return a non-Promise value (`accountReader`
-//      returns `AccountReader`; the transaction-request builders return
-//      `TransactionRequestBuilder`; `createCodeBuilder` returns a builder).
-//      Wrapping these in `_serializeWasmCall` would turn their return
-//      value into `Promise<T>` and break callers that use the result
-//      immediately (e.g. `const reader = client.accountReader(id);
-//      await reader.nonce();`).
-//   2. Sync methods that still take `&mut self` in Rust (`proveBlock`,
-//      `serializeMockChain`, `setDebugMode`). Safe to opt out because JS
-//      is single-threaded — the event loop cannot interleave another
-//      call during their synchronous execution, so the RefCell borrow
-//      is always released before any other borrow can start.
-// Do NOT move a sync-in-JS method into `WRITE_METHODS` / `READ_METHODS`
-// just because it takes `&mut self` or `&self`; wrapping changes its
-// return shape and breaks every caller.
-const SYNC_METHODS = new Set([
-  "accountReader",
-  "buildSwapTag",
-  "createCodeBuilder",
-  "lastAuthError",
-  "newConsumeTransactionRequest",
-  "newMintTransactionRequest",
-  "newSendTransactionRequest",
-  "newSwapTransactionRequest",
-  "proveBlock",
-  "serializeMockChain",
-  "serializeMockNoteTransportNode",
-  "setDebugMode",
-  "storeIdentifier",
-  "usesMockChain",
-]);
-
 const MOCK_STORE_NAME = "mock_client_db";
 
 const buildTypedArraysExport = (exportObject) => {
@@ -2289,6 +2679,9 @@ const ensureWasm = async () => {
         }
         // Set WASM module for standalone utilities
         _setWasm(module);
+        // Install StorageView: account.storage() now returns a developer-friendly
+        // wrapper that makes getItem() work correctly for StorageMap slots.
+        installStorageView(module);
       }
       return module;
     });
@@ -2333,16 +2726,6 @@ const getWasmOrThrow = async () => {
 /**
  * Create a Proxy that forwards missing properties to the underlying WASM
  * WebClient.
- *
- * Async proxy-fallback methods (every WASM method that borrows the
- * WebClient's RefCell — reads included, since `&self` and `&mut self` both
- * trip wasm-bindgen's "recursive use of an object detected" panic if
- * another borrow is live) are routed through `_serializeWasmCall` so they
- * queue on the same chain as the explicitly-wrapped methods.
- *
- * `SYNC_METHODS` opts out: they are synchronous in JS and wrapping them
- * would change their return type to `Promise<T>`, which is a breaking
- * change for consumers that use them as plain getters or builders.
  */
 function createClientProxy(instance) {
   return new Proxy(instance, {
@@ -2353,13 +2736,7 @@ function createClientProxy(instance) {
       if (target.wasmWebClient && prop in target.wasmWebClient) {
         const value = target.wasmWebClient[prop];
         if (typeof value === "function") {
-          if (typeof prop === "string" && SYNC_METHODS.has(prop)) {
-            return value.bind(target.wasmWebClient);
-          }
-          return (...args) =>
-            target._serializeWasmCall(() =>
-              value.apply(target.wasmWebClient, args)
-            );
+          return value.bind(target.wasmWebClient);
         }
         return value;
       }
@@ -2879,6 +3256,7 @@ class WebClient {
   async newFaucet(
     storageMode,
     nonFungible,
+    tokenName,
     tokenSymbol,
     decimals,
     maxSupply,
@@ -2889,6 +3267,7 @@ class WebClient {
       return await wasmWebClient.newFaucet(
         storageMode,
         nonFungible,
+        tokenName,
         tokenSymbol,
         decimals,
         maxSupply,
@@ -2912,171 +3291,147 @@ class WebClient {
   }
 
   async 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
+    try {
+      if (!this.worker) {
+        const wasmWebClient = await this.getWasmWebClient();
+        return await wasmWebClient.submitNewTransaction(
+          accountId,
+          transactionRequest
         );
+      }
 
-        const transactionResult = wasm.TransactionResult.deserialize(
-          new Uint8Array(result.serializedTransactionResult)
-        );
+      const wasm = await getWasmOrThrow();
+      const serializedTransactionRequest = transactionRequest.serialize();
+      const result = await this.callMethodWithWorker(
+        MethodName.SUBMIT_NEW_TRANSACTION,
+        accountId.toString(),
+        serializedTransactionRequest
+      );
 
-        return transactionResult.id();
-      } catch (error) {
-        console.error("INDEX.JS: Error in submitNewTransaction:", error);
-        throw error;
-      }
-    });
+      const transactionResult = wasm.TransactionResult.deserialize(
+        new Uint8Array(result.serializedTransactionResult)
+      );
+
+      return transactionResult.id();
+    } catch (error) {
+      console.error("INDEX.JS: Error in submitNewTransaction:", error);
+      throw error;
+    }
   }
 
   async 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
+    try {
+      if (!this.worker) {
+        const wasmWebClient = await this.getWasmWebClient();
+        return await wasmWebClient.submitNewTransactionWithProver(
+          accountId,
+          transactionRequest,
+          prover
         );
+      }
 
-        const transactionResult = wasm.TransactionResult.deserialize(
-          new Uint8Array(result.serializedTransactionResult)
-        );
+      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
+      );
 
-        return transactionResult.id();
-      } catch (error) {
-        console.error(
-          "INDEX.JS: Error in submitNewTransactionWithProver:",
-          error
-        );
-        throw error;
-      }
-    });
+      const transactionResult = wasm.TransactionResult.deserialize(
+        new Uint8Array(result.serializedTransactionResult)
+      );
+
+      return transactionResult.id();
+    } catch (error) {
+      console.error(
+        "INDEX.JS: Error in submitNewTransactionWithProver:",
+        error
+      );
+      throw error;
+    }
   }
 
   async 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
-        );
-
-        return wasm.TransactionResult.deserialize(
-          new Uint8Array(serializedResultBytes)
+    try {
+      if (!this.worker) {
+        const wasmWebClient = await this.getWasmWebClient();
+        return await wasmWebClient.executeTransaction(
+          accountId,
+          transactionRequest
         );
-      } catch (error) {
-        console.error("INDEX.JS: Error in executeTransaction:", error);
-        throw error;
       }
-    });
+
+      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;
+    }
   }
 
   async proveTransaction(transactionResult, prover) {
-    return this._serializeWasmCall(async () => {
-      try {
-        if (!this.worker) {
-          const wasmWebClient = await this.getWasmWebClient();
-          return prover
-            ? await wasmWebClient.proveTransactionWithProver(
-                transactionResult,
-                prover
-              )
-            : await wasmWebClient.proveTransaction(transactionResult);
-        }
-
-        const wasm = await getWasmOrThrow();
-        const serializedTransactionResult = transactionResult.serialize();
-        const proverPayload = prover ? prover.serialize() : null;
+    try {
+      if (!this.worker) {
+        const wasmWebClient = await this.getWasmWebClient();
+        return await wasmWebClient.proveTransaction(transactionResult, prover);
+      }
 
-        const serializedProvenBytes = await this.callMethodWithWorker(
-          MethodName.PROVE_TRANSACTION,
-          serializedTransactionResult,
-          proverPayload
-        );
+      const wasm = await getWasmOrThrow();
+      const serializedTransactionResult = transactionResult.serialize();
+      const proverPayload = prover ? prover.serialize() : null;
 
-        return wasm.ProvenTransaction.deserialize(
-          new Uint8Array(serializedProvenBytes)
-        );
-      } catch (error) {
-        console.error("INDEX.JS: Error in proveTransaction:", error);
-        throw error;
-      }
-    });
-  }
+      const serializedProvenBytes = await this.callMethodWithWorker(
+        MethodName.PROVE_TRANSACTION,
+        serializedTransactionResult,
+        proverPayload
+      );
 
-  // Delegates to `proveTransaction`, which already routes through
-  // `_serializeWasmCall` and dispatches to the WASM `proveTransactionWithProver`
-  // binding when `prover` is present. Kept as a wrapper (rather than elided)
-  // so the method classification lint sees an explicit match for the WASM
-  // method name.
-  async proveTransactionWithProver(transactionResult, prover) {
-    return this.proveTransaction(transactionResult, prover);
+      return wasm.ProvenTransaction.deserialize(
+        new Uint8Array(serializedProvenBytes)
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in proveTransaction:", error);
+      throw error;
+    }
   }
 
   async applyTransaction(transactionResult, submissionHeight) {
-    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,
+    try {
+      if (!this.worker) {
+        const wasmWebClient = await this.getWasmWebClient();
+        return await wasmWebClient.applyTransaction(
+          transactionResult,
           submissionHeight
         );
-
-        return wasm.TransactionStoreUpdate.deserialize(
-          new Uint8Array(serializedUpdateBytes)
-        );
-      } catch (error) {
-        console.error("INDEX.JS: Error in applyTransaction:", error);
-        throw error;
       }
-    });
+
+      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;
+    }
   }
 
   /**
@@ -3115,25 +3470,21 @@ class WebClient {
         return lockHandle.coalescedResult;
       }
 
-      // We acquired the lock - perform the sync. Wrap the actual WASM
-      // call in _serializeWasmCall so it can't race with any other
-      // mutating method (executeTransaction, submitNewTransaction, etc.)
-      // on the same WebClient. The outer coalescing lock stays in place
-      // so concurrent syncState callers still share one in-flight sync.
+      // We acquired the lock - perform the sync
       try {
-        const result = await this._serializeWasmCall(async () => {
-          if (!this.worker) {
-            const wasmWebClient = await this.getWasmWebClient();
-            return await wasmWebClient.syncStateImpl();
-          }
+        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
           );
-          return wasm.SyncSummary.deserialize(
+          result = wasm.SyncSummary.deserialize(
             new Uint8Array(serializedSyncSummaryBytes)
           );
-        });
+        }
 
         // Release the lock with the result
         releaseSyncLock(dbId, result);
@@ -3212,9 +3563,9 @@ class MockWebClient extends WebClient {
     // Wait for the underlying wasmWebClient to be initialized.
     const wasmWebClient = await instance.getWasmWebClient();
     await wasmWebClient.createMockClient(
-      seed,
-      serializedMockChain,
-      serializedMockNoteTransportNode
+      seed ?? null,
+      serializedMockChain ?? null,
+      serializedMockNoteTransportNode ?? null
     );
 
     // Wait for the worker to be ready
@@ -3259,9 +3610,11 @@ class MockWebClient extends WebClient {
         if (!this.worker) {
           result = await wasmWebClient.syncStateImpl();
         } else {
-          let serializedMockChain = wasmWebClient.serializeMockChain().buffer;
-          let serializedMockNoteTransportNode =
-            wasmWebClient.serializeMockNoteTransportNode().buffer;
+          let serializedMockChain = (await wasmWebClient.serializeMockChain())
+            .buffer;
+          let serializedMockNoteTransportNode = (
+            await wasmWebClient.serializeMockNoteTransportNode()
+          ).buffer;
 
           const wasm = await getWasmOrThrow();
 
@@ -3297,9 +3650,11 @@ class MockWebClient extends WebClient {
       const wasmWebClient = await this.getWasmWebClient();
       const wasm = await getWasmOrThrow();
       const serializedTransactionRequest = transactionRequest.serialize();
-      const serializedMockChain = wasmWebClient.serializeMockChain().buffer;
-      const serializedMockNoteTransportNode =
-        wasmWebClient.serializeMockNoteTransportNode().buffer;
+      const serializedMockChain = (await wasmWebClient.serializeMockChain())
+        .buffer;
+      const serializedMockNoteTransportNode = (
+        await wasmWebClient.serializeMockNoteTransportNode()
+      ).buffer;
 
       const result = await this.callMethodWithWorker(
         MethodName.SUBMIT_NEW_TRANSACTION_MOCK,
@@ -3351,9 +3706,11 @@ class MockWebClient extends WebClient {
       const wasm = await getWasmOrThrow();
       const serializedTransactionRequest = transactionRequest.serialize();
       const proverPayload = prover.serialize();
-      const serializedMockChain = wasmWebClient.serializeMockChain().buffer;
-      const serializedMockNoteTransportNode =
-        wasmWebClient.serializeMockNoteTransportNode().buffer;
+      const serializedMockChain = (await wasmWebClient.serializeMockChain())
+        .buffer;
+      const serializedMockNoteTransportNode = (
+        await wasmWebClient.serializeMockNoteTransportNode()
+      ).buffer;
 
       const result = await this.callMethodWithWorker(
         MethodName.SUBMIT_NEW_TRANSACTION_WITH_PROVER_MOCK,
@@ -3417,5 +3774,5 @@ MidenClient._MockWasmWebClient = MockWebClient;
 MidenClient._getWasmOrThrow = getWasmOrThrow;
 _setWebClient(WebClient);
 
-export { AccountArray, AccountIdArray, AccountType, AuthScheme, CompilerResource, FeltArray, ForeignAccountArray, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, NoteAndArgsArray, NoteArray, NoteIdAndArgsArray, NoteRecipientArray, NoteVisibility, OutputNoteArray, StorageMode, StorageSlotArray, TransactionScriptInputPairArray, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, resolveAuthScheme };
+export { AccountType, AuthScheme, CompilerResource, Linking, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, MockWebClient, NoteVisibility, StorageMode, StorageResult, StorageView, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow, wordToBigInt };
 //# sourceMappingURL=index.js.map