@miden-sdk/miden-sdk 0.13.2 → 0.14.0-alpha

package/dist/index.js

@@ -1,5 +1,5 @@
 import loadWasm from './wasm.js';
-export { Account, AccountArray, AccountBuilder, AccountBuilderResult, AccountCode, AccountComponent, AccountComponentCode, AccountDelta, AccountFile, AccountHeader, AccountId, AccountIdArray, AccountInterface, 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, setupLogging } from './Cargo-e77f9a02.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, NetworkType, Note, NoteAndArgs, NoteAndArgsArray, NoteAssets, NoteAttachment, NoteAttachmentKind, NoteAttachmentScheme, NoteConsumability, NoteConsumptionStatus, NoteDetails, NoteDetailsAndTag, NoteDetailsAndTagArray, NoteExecutionHint, NoteExportFormat, NoteFile, NoteFilter, NoteFilterTypes, NoteHeader, NoteId, NoteIdAndArgs, NoteIdAndArgsArray, NoteInclusionProof, NoteLocation, NoteMetadata, NoteRecipient, NoteRecipientArray, NoteScript, NoteStorage, 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, WebClient, Word, createAuthFalcon512RpoMultisig, initSync, setupLogging } from './Cargo-D064yzd4.js';
 
 const WorkerAction = Object.freeze({
   INIT: "init",
@@ -16,8 +16,7 @@ const CallbackType = Object.freeze({
 
 const MethodName = Object.freeze({
   CREATE_CLIENT: "createClient",
-  NEW_WALLET: "newWallet",
-  NEW_FAUCET: "newFaucet",
+  APPLY_TRANSACTION: "applyTransaction",
   EXECUTE_TRANSACTION: "executeTransaction",
   PROVE_TRANSACTION: "proveTransaction",
   SUBMIT_NEW_TRANSACTION: "submitNewTransaction",
@@ -239,13 +238,1210 @@ function releaseSyncLockWithError(dbId, error) {
   }
 }
 
+/**
+ * Shared utility functions for the MidenClient resource classes.
+ * Each function accepts a `wasm` parameter (the WASM module) for constructing typed objects.
+ */
+
+/**
+ * Resolves an AccountRef (string | Account | AccountId) to an AccountId.
+ *
+ * - Strings starting with `0x`/`0X` are parsed as hex via `AccountId.fromHex()`.
+ * - Other strings are parsed as bech32 via `AccountId.fromBech32()`.
+ * - Objects with an `.id()` method (Account) are resolved by calling `.id()`.
+ * - Otherwise, the value is assumed to be an AccountId pass-through.
+ *
+ * @param {string | Account | AccountId} ref - The account reference to resolve.
+ * @param {object} wasm - The WASM module.
+ * @returns {AccountId} The resolved AccountId.
+ */
+function resolveAccountRef(ref, wasm) {
+  if (ref == null) {
+    throw new Error("Account reference cannot be null or undefined");
+  }
+  if (typeof ref === "string") {
+    if (ref.startsWith("0x") || ref.startsWith("0X")) {
+      return wasm.AccountId.fromHex(ref);
+    }
+    return wasm.AccountId.fromBech32(ref);
+  }
+  if (ref && typeof ref.id === "function") {
+    return ref.id();
+  }
+  return ref;
+}
+
+/**
+ * Resolves an AccountRef to a WASM Address object.
+ *
+ * - Strings starting with bech32 prefixes (`m`) are parsed via `Address.fromBech32()`.
+ * - Strings starting with `0x`/`0X` are parsed as hex AccountId, then wrapped in Address.
+ * - Account objects are resolved via `.id()` then wrapped in Address.
+ * - AccountId objects are wrapped in Address directly.
+ *
+ * @param {string | Account | AccountId} ref - The account reference to resolve.
+ * @param {object} wasm - The WASM module.
+ * @returns {Address} The resolved Address.
+ */
+function resolveAddress(ref, wasm) {
+  if (ref == null) {
+    throw new Error("Address reference cannot be null or undefined");
+  }
+  if (typeof ref === "string") {
+    if (ref.startsWith("0x") || ref.startsWith("0X")) {
+      const accountId = wasm.AccountId.fromHex(ref);
+      return wasm.Address.fromAccountId(accountId, undefined);
+    }
+    return wasm.Address.fromBech32(ref);
+  }
+  if (ref && typeof ref.id === "function") {
+    const accountId = ref.id();
+    return wasm.Address.fromAccountId(accountId, undefined);
+  }
+  return wasm.Address.fromAccountId(ref, undefined);
+}
+
+/**
+ * Resolves a NoteVisibility string to a WASM NoteType value.
+ *
+ * @param {string | undefined} type - "public" or "private". Defaults to "public".
+ * @param {object} wasm - The WASM module.
+ * @returns {number} The NoteType enum value.
+ */
+function resolveNoteType(type, wasm) {
+  if (type === "private") {
+    return wasm.NoteType.Private;
+  }
+  if (type === "public" || type == null) {
+    return wasm.NoteType.Public;
+  }
+  throw new Error(
+    `Unknown note type: "${type}". Expected "public" or "private".`
+  );
+}
+
+/**
+ * Resolves a storage mode string to a WASM AccountStorageMode instance.
+ *
+ * @param {string | undefined} mode - "private", "public", or "network". Defaults to "private".
+ * @param {object} wasm - The WASM module.
+ * @returns {AccountStorageMode} The storage mode instance.
+ */
+function resolveStorageMode(mode, wasm) {
+  switch (mode) {
+    case "public":
+      return wasm.AccountStorageMode.public();
+    case "network":
+      return wasm.AccountStorageMode.network();
+    case "private":
+    case undefined:
+    case null:
+      return wasm.AccountStorageMode.private();
+    default:
+      throw new Error(
+        `Unknown storage mode: "${mode}". Expected "private", "public", or "network".`
+      );
+  }
+}
+
+/**
+ * Resolves an auth scheme string to a WASM AuthScheme enum value.
+ *
+ * @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;
+  }
+  if (scheme === "falcon" || scheme == null) {
+    return wasm.AuthScheme.AuthRpoFalcon512;
+  }
+  throw new Error(
+    `Unknown auth scheme: "${scheme}". Expected "falcon" or "ecdsa".`
+  );
+}
+
+/**
+ * Resolves a simplified AccountType string to a boolean `mutable` flag
+ * for the underlying WASM `newWallet()` / `importPublicAccountFromSeed()` calls.
+ *
+ * @param {string | undefined} accountType - "MutableWallet", "ImmutableWallet", or undefined.
+ *   Defaults to mutable wallet when undefined.
+ * @returns {boolean} Whether the account code is mutable.
+ */
+function resolveAccountMutability(accountType) {
+  if (accountType == null || accountType === "MutableWallet") {
+    return true;
+  }
+  if (accountType === "ImmutableWallet") {
+    return false;
+  }
+  throw new Error(
+    `Unknown wallet account type: "${accountType}". Expected "MutableWallet" or "ImmutableWallet".`
+  );
+}
+
+/**
+ * Hashes a seed value. Strings are hashed via SHA-256 to produce a 32-byte Uint8Array.
+ * Uint8Array values are passed through unchanged.
+ *
+ * @param {string | Uint8Array} seed - The seed to hash.
+ * @returns {Promise<Uint8Array>} The hashed seed.
+ */
+async function hashSeed(seed) {
+  if (seed instanceof Uint8Array) {
+    return seed;
+  }
+  if (typeof seed === "string") {
+    const encoded = new TextEncoder().encode(seed);
+    const hash = await crypto.subtle.digest("SHA-256", encoded);
+    return new Uint8Array(hash);
+  }
+  throw new TypeError(
+    `Invalid seed type: expected string or Uint8Array, got ${typeof seed}`
+  );
+}
+
+class AccountsResource {
+  #inner;
+  #getWasm;
+  #client;
+
+  constructor(inner, getWasm, client) {
+    this.#inner = inner;
+    this.#getWasm = getWasm;
+    this.#client = client;
+  }
+
+  async create(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    if (opts?.type === "FungibleFaucet") {
+      const storageMode = resolveStorageMode(opts.storage ?? "public", wasm);
+      const authScheme = resolveAuthScheme(opts.auth, wasm);
+      return await this.#inner.newFaucet(
+        storageMode,
+        false,
+        opts.symbol,
+        opts.decimals,
+        BigInt(opts.maxSupply),
+        authScheme
+      );
+    }
+
+    // Default: wallet (mutable or immutable based on type)
+    const mutable = resolveAccountMutability(opts?.type);
+    const storageMode = resolveStorageMode(opts?.storage ?? "private", wasm);
+    const authScheme = resolveAuthScheme(opts?.auth, wasm);
+    const seed = opts?.seed ? await hashSeed(opts.seed) : undefined;
+    return await this.#inner.newWallet(storageMode, mutable, authScheme, seed);
+  }
+
+  async get(ref) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const id = resolveAccountRef(ref, wasm);
+    const account = await this.#inner.getAccount(id);
+    return account ?? null;
+  }
+
+  async list() {
+    this.#client.assertNotTerminated();
+    return await this.#inner.getAccounts();
+  }
+
+  async getDetails(ref) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const id = resolveAccountRef(ref, wasm);
+    const account = await this.#inner.getAccount(id);
+    if (!account) {
+      throw new Error(`Account not found: ${id.toString()}`);
+    }
+    const keys = await this.#inner.getPublicKeyCommitmentsOfAccount(id);
+    return {
+      account,
+      vault: account.vault(),
+      storage: account.storage(),
+      code: account.code() ?? null,
+      keys,
+    };
+  }
+
+  async getBalance(accountRef, tokenRef) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(accountRef, wasm);
+    const faucetId = resolveAccountRef(tokenRef, wasm);
+    const reader = this.#inner.accountReader(accountId);
+    return await reader.getBalance(faucetId);
+  }
+
+  async import(input) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    if (typeof input === "string") {
+      // Import by ID (hex or bech32 string)
+      const id = resolveAccountRef(input, wasm);
+      await this.#inner.importAccountById(id);
+      return await this.#inner.getAccount(id);
+    }
+
+    if (input.file) {
+      // Extract accountId before importAccountFile — WASM consumes the
+      // AccountFile by value, invalidating the JS wrapper after the call.
+      const accountId =
+        typeof input.file.accountId === "function"
+          ? input.file.accountId()
+          : null;
+      await this.#inner.importAccountFile(input.file);
+      if (accountId) {
+        return await this.#inner.getAccount(accountId);
+      }
+      throw new Error(
+        "Could not determine account ID from AccountFile. " +
+          "Ensure the file contains a valid account."
+      );
+    }
+
+    if (input.seed) {
+      // Import public account from seed
+      const authScheme = resolveAuthScheme(input.auth, wasm);
+      const mutable = resolveAccountMutability(input.type);
+      return await this.#inner.importPublicAccountFromSeed(
+        input.seed,
+        mutable,
+        authScheme
+      );
+    }
+
+    throw new Error(
+      "Invalid import input: expected a string, { file }, or { seed }"
+    );
+  }
+
+  async export(ref) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const id = resolveAccountRef(ref, wasm);
+    return await this.#inner.exportAccountFile(id);
+  }
+
+  async addAddress(ref, addr) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const id = resolveAccountRef(ref, wasm);
+    const address = wasm.Address.fromBech32(addr);
+    await this.#inner.insertAccountAddress(id, address);
+  }
+
+  async removeAddress(ref, addr) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const id = resolveAccountRef(ref, wasm);
+    const address = wasm.Address.fromBech32(addr);
+    await this.#inner.removeAccountAddress(id, address);
+  }
+}
+
+class TransactionsResource {
+  #inner;
+  #getWasm;
+  #client;
+
+  constructor(inner, getWasm, client) {
+    this.#inner = inner;
+    this.#getWasm = getWasm;
+    this.#client = client;
+  }
+
+  async send(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildSendRequest(opts, wasm);
+
+    const txId = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return txId;
+  }
+
+  async mint(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildMintRequest(opts, wasm);
+
+    const txId = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return txId;
+  }
+
+  async consume(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildConsumeRequest(opts, wasm);
+
+    const txId = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return txId;
+  }
+
+  async consumeAll(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    // getConsumableNotes takes AccountId by value (consumed by WASM).
+    // Save hex so we can reconstruct for submitNewTransaction.
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const accountIdHex = accountId.toString();
+    const consumable = await this.#inner.getConsumableNotes(accountId);
+
+    if (!consumable || consumable.length === 0) {
+      return { txId: null, consumed: 0, remaining: 0 };
+    }
+
+    const total = consumable.length;
+    const toConsume =
+      opts.maxNotes != null ? consumable.slice(0, opts.maxNotes) : consumable;
+
+    if (toConsume.length === 0) {
+      return { txId: null, consumed: 0, remaining: total };
+    }
+
+    const notes = toConsume.map((c) => c.inputNoteRecord().toNote());
+
+    const request = await this.#inner.newConsumeTransactionRequest(notes);
+
+    const txId = await this.#submitOrSubmitWithProver(
+      wasm.AccountId.fromHex(accountIdHex),
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return {
+      txId,
+      consumed: toConsume.length,
+      remaining: total - toConsume.length,
+    };
+  }
+
+  async swap(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const { accountId, request } = await this.#buildSwapRequest(opts, wasm);
+
+    const txId = await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts.prover
+    );
+
+    if (opts.waitForConfirmation) {
+      await this.waitFor(txId.toHex(), { timeout: opts.timeout });
+    }
+
+    return txId;
+  }
+
+  async preview(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    let accountId;
+    let request;
+
+    switch (opts.operation) {
+      case "send": {
+        ({ accountId, request } = await this.#buildSendRequest(opts, wasm));
+        break;
+      }
+      case "mint": {
+        ({ accountId, request } = await this.#buildMintRequest(opts, wasm));
+        break;
+      }
+      case "consume": {
+        ({ accountId, request } = await this.#buildConsumeRequest(opts, wasm));
+        break;
+      }
+      case "swap": {
+        ({ accountId, request } = await this.#buildSwapRequest(opts, wasm));
+        break;
+      }
+      default:
+        throw new Error(`Unknown preview operation: ${opts.operation}`);
+    }
+
+    return await this.#inner.executeForSummary(accountId, request);
+  }
+
+  async submit(account, request, opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(account, wasm);
+    return await this.#submitOrSubmitWithProver(
+      accountId,
+      request,
+      opts?.prover
+    );
+  }
+
+  async list(query) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+
+    let filter;
+    if (!query) {
+      filter = wasm.TransactionFilter.all();
+    } else if (query.status === "uncommitted") {
+      filter = wasm.TransactionFilter.uncommitted();
+    } else if (query.ids) {
+      const txIds = query.ids.map((id) => wasm.TransactionId.fromHex(id));
+      filter = wasm.TransactionFilter.ids(txIds);
+    } else if (query.expiredBefore !== undefined) {
+      filter = wasm.TransactionFilter.expiredBefore(query.expiredBefore);
+    } else {
+      filter = wasm.TransactionFilter.all();
+    }
+
+    return await this.#inner.getTransactions(filter);
+  }
+
+  /**
+   * Polls for transaction confirmation.
+   *
+   * @param {string} txId - Transaction ID hex string.
+   * @param {WaitOptions} [opts] - Polling options.
+   * @param {number} [opts.timeout=60000] - Wall-clock polling timeout in
+   *   milliseconds. This is NOT a block height — it controls how long the
+   *   client waits before giving up. Set to 0 to disable the timeout and poll
+   *   indefinitely until the transaction is committed or discarded.
+   * @param {number} [opts.interval=5000] - Polling interval in ms.
+   * @param {function} [opts.onProgress] - Called with the current status on
+   *   each poll iteration ("pending", "submitted", or "committed").
+   */
+  async waitFor(txId, opts) {
+    this.#client.assertNotTerminated();
+    const timeout = opts?.timeout ?? 60_000;
+    const interval = opts?.interval ?? 5_000;
+    const start = Date.now();
+
+    const wasm = await this.#getWasm();
+
+    while (true) {
+      const elapsed = Date.now() - start;
+      if (timeout > 0 && elapsed >= timeout) {
+        throw new Error(
+          `Transaction confirmation timed out after ${timeout}ms`
+        );
+      }
+
+      try {
+        await this.#inner.syncStateWithTimeout(0);
+      } catch {
+        // Sync may fail transiently; continue polling
+      }
+
+      // Recreate filter each iteration — WASM consumes it by value
+      const filter = wasm.TransactionFilter.ids([
+        wasm.TransactionId.fromHex(txId),
+      ]);
+      const txs = await this.#inner.getTransactions(filter);
+
+      if (txs && txs.length > 0) {
+        const tx = txs[0];
+        const status = tx.transactionStatus?.();
+
+        if (status) {
+          if (status.isCommitted()) {
+            opts?.onProgress?.("committed");
+            return;
+          }
+          if (status.isDiscarded()) {
+            throw new Error(`Transaction rejected: ${txId}`);
+          }
+        }
+
+        opts?.onProgress?.("submitted");
+      } else {
+        opts?.onProgress?.("pending");
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+
+  // ── Shared request builders ──
+
+  async #buildSendRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const targetId = resolveAccountRef(opts.to, wasm);
+    const faucetId = resolveAccountRef(opts.token, wasm);
+    const noteType = resolveNoteType(opts.type, wasm);
+    const amount = BigInt(opts.amount);
+
+    const request = await this.#inner.newSendTransactionRequest(
+      accountId,
+      targetId,
+      faucetId,
+      noteType,
+      amount,
+      opts.reclaimAfter,
+      opts.timelockUntil
+    );
+    return { accountId, request };
+  }
+
+  async #buildMintRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const targetId = resolveAccountRef(opts.to, wasm);
+    const noteType = resolveNoteType(opts.type, wasm);
+    const amount = BigInt(opts.amount);
+
+    // WASM signature: newMintTransactionRequest(target, faucet, noteType, amount)
+    const request = await this.#inner.newMintTransactionRequest(
+      targetId,
+      accountId,
+      noteType,
+      amount
+    );
+    return { accountId, request };
+  }
+
+  async #buildConsumeRequest(opts, wasm) {
+    const accountId = resolveAccountRef(opts.account, wasm);
+    const noteInputs = Array.isArray(opts.notes) ? opts.notes : [opts.notes];
+    const notes = await Promise.all(
+      noteInputs.map((input) => this.#resolveNoteInput(input))
+    );
+    const request = await this.#inner.newConsumeTransactionRequest(notes);
+    return { accountId, request };
+  }
+
+  async #buildSwapRequest(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.newSwapTransactionRequest(
+      accountId,
+      offeredFaucetId,
+      BigInt(opts.offer.amount),
+      requestedFaucetId,
+      BigInt(opts.request.amount),
+      noteType,
+      paybackNoteType
+    );
+    return { accountId, request };
+  }
+
+  async #resolveNoteInput(input) {
+    if (typeof input === "string") {
+      const record = await this.#inner.getInputNote(input);
+      if (!record) {
+        throw new Error(`Note not found: ${input}`);
+      }
+      return record.toNote();
+    }
+    // InputNoteRecord — unwrap to Note
+    if (input && typeof input.toNote === "function") {
+      return input.toNote();
+    }
+    // NoteId — look up the note by its hex ID
+    if (input && input.constructor?.name === "NoteId") {
+      const hex = input.toString();
+      const record = await this.#inner.getInputNote(hex);
+      if (!record) {
+        throw new Error(`Note not found: ${hex}`);
+      }
+      return record.toNote();
+    }
+    // Assume it's already a Note object
+    return input;
+  }
+
+  async #submitOrSubmitWithProver(accountId, request, perCallProver) {
+    const prover = perCallProver ?? this.#client.defaultProver;
+    if (prover) {
+      return await this.#inner.submitNewTransactionWithProver(
+        accountId,
+        request,
+        prover
+      );
+    }
+    return await this.#inner.submitNewTransaction(accountId, request);
+  }
+}
+
+class NotesResource {
+  #inner;
+  #getWasm;
+  #client;
+
+  constructor(inner, getWasm, client) {
+    this.#inner = inner;
+    this.#getWasm = getWasm;
+    this.#client = client;
+  }
+
+  async list(query) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const filter = buildNoteFilter(query, wasm);
+    return await this.#inner.getInputNotes(filter);
+  }
+
+  async get(noteId) {
+    this.#client.assertNotTerminated();
+    const result = await this.#inner.getInputNote(noteId);
+    return result ?? null;
+  }
+
+  async listSent(query) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const filter = buildNoteFilter(query, wasm);
+    return await this.#inner.getOutputNotes(filter);
+  }
+
+  async listAvailable(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const accountId = resolveAccountRef(opts.account, wasm);
+    return await this.#inner.getConsumableNotes(accountId);
+  }
+
+  async import(noteFile) {
+    this.#client.assertNotTerminated();
+    return await this.#inner.importNoteFile(noteFile);
+  }
+
+  async export(noteId, opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const format = opts?.format ?? wasm.NoteExportFormat.Full;
+    return await this.#inner.exportNoteFile(noteId, format);
+  }
+
+  async fetchPrivate(opts) {
+    this.#client.assertNotTerminated();
+    if (opts?.mode === "all") {
+      await this.#inner.fetchAllPrivateNotes();
+    } else {
+      await this.#inner.fetchPrivateNotes();
+    }
+  }
+
+  async sendPrivate(opts) {
+    this.#client.assertNotTerminated();
+    const wasm = await this.#getWasm();
+    const noteRecord = await this.#inner.getInputNote(opts.noteId);
+    if (!noteRecord) {
+      throw new Error(`Note not found: ${opts.noteId}`);
+    }
+    const note = noteRecord.toNote();
+    const address = resolveAddress(opts.to, wasm);
+    await this.#inner.sendPrivateNote(note, address);
+  }
+}
+
+function buildNoteFilter(query, wasm) {
+  if (!query) {
+    return new wasm.NoteFilter(wasm.NoteFilterTypes.All, undefined);
+  }
+
+  if (query.ids) {
+    const noteIds = query.ids.map((id) => wasm.NoteId.fromHex(id));
+    return new wasm.NoteFilter(wasm.NoteFilterTypes.List, noteIds);
+  }
+
+  if (query.status) {
+    const statusMap = {
+      consumed: wasm.NoteFilterTypes.Consumed,
+      committed: wasm.NoteFilterTypes.Committed,
+      expected: wasm.NoteFilterTypes.Expected,
+      processing: wasm.NoteFilterTypes.Processing,
+      unverified: wasm.NoteFilterTypes.Unverified,
+    };
+    const filterType = statusMap[query.status];
+    if (filterType === undefined) {
+      throw new Error(`Unknown note status: ${query.status}`);
+    }
+    return new wasm.NoteFilter(filterType, undefined);
+  }
+
+  return new wasm.NoteFilter(wasm.NoteFilterTypes.All, undefined);
+}
+
+class TagsResource {
+  #inner;
+  #client;
+
+  constructor(inner, getWasm, client) {
+    this.#inner = inner;
+    this.#client = client;
+  }
+
+  async add(tag) {
+    this.#client.assertNotTerminated();
+    await this.#inner.addTag(String(tag));
+  }
+
+  async remove(tag) {
+    this.#client.assertNotTerminated();
+    await this.#inner.removeTag(String(tag));
+  }
+
+  async list() {
+    this.#client.assertNotTerminated();
+    const tags = await this.#inner.listTags();
+    return Array.from(tags).map((t) => {
+      const n = Number(t);
+      if (Number.isNaN(n)) {
+        throw new Error(`Invalid tag value: ${t}`);
+      }
+      return n;
+    });
+  }
+}
+
+class SettingsResource {
+  #inner;
+  #client;
+
+  constructor(inner, _getWasm, client) {
+    this.#inner = inner;
+    this.#client = client;
+  }
+
+  async get(key) {
+    this.#client.assertNotTerminated();
+    const value = await this.#inner.getSetting(key);
+    return value === undefined ? null : value;
+  }
+
+  async set(key, value) {
+    this.#client.assertNotTerminated();
+    await this.#inner.setSetting(key, value);
+  }
+
+  async remove(key) {
+    this.#client.assertNotTerminated();
+    await this.#inner.removeSetting(key);
+  }
+
+  async listKeys() {
+    this.#client.assertNotTerminated();
+    return await this.#inner.listSettingKeys();
+  }
+}
+
+/**
+ * MidenClient wraps the existing proxy-wrapped WebClient with a resource-based API.
+ *
+ * Resource classes receive the proxy client and call its methods, handling all type
+ * conversions (string -> AccountId, number -> BigInt, string -> enum).
+ */
+class MidenClient {
+  // Injected by index.js to resolve circular imports
+  static _WasmWebClient = null;
+  static _MockWasmWebClient = null;
+  static _getWasmOrThrow = null;
+
+  #inner;
+  #getWasm;
+  #terminated = false;
+  #defaultProver = null;
+  #isMock = false;
+
+  constructor(inner, getWasm, defaultProver) {
+    this.#inner = inner;
+    this.#getWasm = getWasm;
+    this.#defaultProver = defaultProver ?? null;
+
+    this.accounts = new AccountsResource(inner, getWasm, this);
+    this.transactions = new TransactionsResource(inner, getWasm, this);
+    this.notes = new NotesResource(inner, getWasm, this);
+    this.tags = new TagsResource(inner, getWasm, this);
+    this.settings = new SettingsResource(inner, getWasm, this);
+  }
+
+  /**
+   * Creates and initializes a new MidenClient.
+   *
+   * @param {ClientOptions} [options] - Client configuration options.
+   * @returns {Promise<MidenClient>} A fully initialized client.
+   */
+  static async create(options) {
+    const getWasm = MidenClient._getWasmOrThrow;
+    const WebClientClass = MidenClient._WasmWebClient;
+
+    if (!WebClientClass || !getWasm) {
+      throw new Error(
+        "MidenClient not initialized. Import from the SDK package entry point."
+      );
+    }
+
+    const seed = options?.seed ? await hashSeed(options.seed) : undefined;
+
+    let inner;
+    if (options?.keystore) {
+      inner = await WebClientClass.createClientWithExternalKeystore(
+        options?.rpcUrl,
+        options?.noteTransportUrl,
+        seed,
+        options?.storeName,
+        options.keystore.getKey,
+        options.keystore.insertKey,
+        options.keystore.sign
+      );
+    } else {
+      inner = await WebClientClass.createClient(
+        options?.rpcUrl,
+        options?.noteTransportUrl,
+        seed,
+        options?.storeName
+      );
+    }
+
+    let defaultProver = null;
+    if (options?.proverUrl) {
+      const wasm = await getWasm();
+      defaultProver = wasm.TransactionProver.newRemoteProver(
+        options.proverUrl,
+        undefined
+      );
+    }
+
+    const client = new MidenClient(inner, getWasm, defaultProver);
+
+    if (options?.autoSync) {
+      await client.sync();
+    }
+
+    return client;
+  }
+
+  /**
+   * Creates a client preconfigured for testnet use.
+   * Defaults to autoSync: true.
+   *
+   * @param {object} [options] - Options (autoSync can be overridden).
+   * @returns {Promise<MidenClient>} A fully initialized testnet client.
+   */
+  static async createTestnet(options) {
+    return MidenClient.create({
+      ...options,
+      autoSync: options?.autoSync ?? true,
+    });
+  }
+
+  /**
+   * Creates a mock client for testing.
+   *
+   * @param {MockOptions} [options] - Mock client options.
+   * @returns {Promise<MidenClient>} A mock client.
+   */
+  static async createMock(options) {
+    const getWasm = MidenClient._getWasmOrThrow;
+    const MockWebClientClass = MidenClient._MockWasmWebClient;
+
+    if (!MockWebClientClass || !getWasm) {
+      throw new Error(
+        "MidenClient not initialized. Import from the SDK package entry point."
+      );
+    }
+
+    const seed = options?.seed ? await hashSeed(options.seed) : undefined;
+
+    const inner = await MockWebClientClass.createClient(
+      options?.serializedMockChain,
+      options?.serializedNoteTransport,
+      seed
+    );
+
+    const client = new MidenClient(inner, getWasm, null);
+    client.#isMock = true;
+    return client;
+  }
+
+  /** Returns the client-level default prover (set from ClientOptions.proverUrl). */
+  get defaultProver() {
+    return this.#defaultProver;
+  }
+
+  /**
+   * Syncs the client state with the Miden node.
+   *
+   * @param {object} [opts] - Sync options.
+   * @param {number} [opts.timeout] - Timeout in milliseconds (0 = no timeout).
+   * @returns {Promise<SyncSummary>} The sync summary.
+   */
+  async sync(opts) {
+    this.assertNotTerminated();
+    return await this.#inner.syncStateWithTimeout(opts?.timeout ?? 0);
+  }
+
+  /**
+   * Returns the current sync height.
+   *
+   * @returns {Promise<number>} The current sync height.
+   */
+  async getSyncHeight() {
+    this.assertNotTerminated();
+    return await this.#inner.getSyncHeight();
+  }
+
+  /**
+   * Terminates the underlying Web Worker. After this, all method calls will throw.
+   */
+  terminate() {
+    this.#terminated = true;
+    this.#inner.terminate?.();
+  }
+
+  [Symbol.dispose]() {
+    this.terminate();
+  }
+
+  async [Symbol.asyncDispose]() {
+    this.terminate();
+  }
+
+  /**
+   * Exports the client store as a versioned snapshot.
+   *
+   * @returns {Promise<StoreSnapshot>} The store snapshot.
+   */
+  async exportStore() {
+    this.assertNotTerminated();
+    const data = await this.#inner.exportStore();
+    return { version: 1, data };
+  }
+
+  /**
+   * Imports a previously exported store snapshot.
+   *
+   * @param {StoreSnapshot} snapshot - The store snapshot to import.
+   */
+  async importStore(snapshot) {
+    this.assertNotTerminated();
+    if (!snapshot || snapshot.version !== 1) {
+      throw new Error(
+        `Unsupported store snapshot version: ${snapshot?.version}. Expected version 1.`
+      );
+    }
+    // Second arg is the store password (empty string = no encryption)
+    await this.#inner.forceImportStore(snapshot.data, "");
+  }
+
+  // ── Mock-only methods ──
+
+  /** Advances the mock chain by one block. Only available on mock clients. */
+  proveBlock() {
+    this.assertNotTerminated();
+    this.#assertMock("proveBlock");
+    return this.#inner.proveBlock();
+  }
+
+  /** Returns true if this client uses a mock chain. */
+  usesMockChain() {
+    return this.#isMock;
+  }
+
+  /** Serializes the mock chain state for snapshot/restore in tests. */
+  serializeMockChain() {
+    this.assertNotTerminated();
+    this.#assertMock("serializeMockChain");
+    return this.#inner.serializeMockChain();
+  }
+
+  /** Serializes the mock note transport node state. */
+  serializeMockNoteTransportNode() {
+    this.assertNotTerminated();
+    this.#assertMock("serializeMockNoteTransportNode");
+    return this.#inner.serializeMockNoteTransportNode();
+  }
+
+  // ── Internal ──
+
+  /** @internal Throws if the client has been terminated. */
+  assertNotTerminated() {
+    if (this.#terminated) {
+      throw new Error("Client terminated");
+    }
+  }
+
+  #assertMock(method) {
+    if (!this.#isMock) {
+      throw new Error(`${method}() is only available on mock clients`);
+    }
+  }
+}
+
+// Module-level WASM reference, set by index.js after initialization
+let _wasm = null;
+let _WebClient = null;
+
+function _setWasm(wasm) {
+  _wasm = wasm;
+}
+
+function _setWebClient(WebClientClass) {
+  _WebClient = WebClientClass;
+}
+
+function getWasm() {
+  if (!_wasm) {
+    throw new Error(
+      "WASM not initialized. Ensure the SDK is loaded before calling standalone utilities."
+    );
+  }
+  return _wasm;
+}
+
+/**
+ * Creates a P2ID (Pay-to-ID) note.
+ *
+ * @param {NoteOptions} opts - Note creation options.
+ * @returns {OutputNote} The created output note.
+ */
+function createP2IDNote(opts) {
+  const wasm = getWasm();
+  const sender = resolveAccountRef(opts.from, wasm);
+  const target = resolveAccountRef(opts.to, wasm);
+  const noteAssets = buildNoteAssets(opts.assets, wasm);
+  const noteType = resolveNoteType(opts.type, wasm);
+  const attachment = opts.attachment
+    ? new wasm.NoteAttachment(opts.attachment)
+    : new wasm.NoteAttachment([]);
+
+  const note = wasm.Note.createP2IDNote(
+    sender,
+    target,
+    noteAssets,
+    noteType,
+    attachment
+  );
+  return wasm.OutputNote.full(note);
+}
+
+/**
+ * Creates a P2IDE (Pay-to-ID with Expiration) note.
+ *
+ * @param {P2IDEOptions} opts - Note creation options with timelock/reclaim.
+ * @returns {OutputNote} The created output note.
+ */
+function createP2IDENote(opts) {
+  const wasm = getWasm();
+  const sender = resolveAccountRef(opts.from, wasm);
+  const target = resolveAccountRef(opts.to, wasm);
+  const noteAssets = buildNoteAssets(opts.assets, wasm);
+  const noteType = resolveNoteType(opts.type, wasm);
+  const attachment = opts.attachment
+    ? new wasm.NoteAttachment(opts.attachment)
+    : new wasm.NoteAttachment([]);
+
+  const note = wasm.Note.createP2IDENote(
+    sender,
+    target,
+    noteAssets,
+    opts.reclaimAfter,
+    opts.timelockUntil,
+    noteType,
+    attachment
+  );
+  return wasm.OutputNote.full(note);
+}
+
+/**
+ * Builds a swap tag for note matching.
+ *
+ * @param {BuildSwapTagOptions} opts - Swap tag options.
+ * @returns {NoteTag} The computed swap tag.
+ */
+function buildSwapTag(opts) {
+  const wasm = getWasm();
+  if (!_WebClient || typeof _WebClient.buildSwapTag !== "function") {
+    throw new Error(
+      "WebClient.buildSwapTag is not available. Ensure the SDK is fully loaded."
+    );
+  }
+  const noteType = resolveNoteType(opts.type, wasm);
+  const offeredFaucetId = resolveAccountRef(opts.offer.token, wasm);
+  const requestedFaucetId = resolveAccountRef(opts.request.token, wasm);
+
+  return _WebClient.buildSwapTag(
+    noteType,
+    offeredFaucetId,
+    BigInt(opts.offer.amount),
+    requestedFaucetId,
+    BigInt(opts.request.amount)
+  );
+}
+
+function buildNoteAssets(assets, wasm) {
+  const assetArray = Array.isArray(assets) ? assets : [assets];
+  const fungibleAssets = assetArray.map((asset) => {
+    const faucetId = resolveAccountRef(asset.token, wasm);
+    return new wasm.FungibleAsset(faucetId, BigInt(asset.amount));
+  });
+  return new wasm.NoteAssets(fungibleAssets);
+}
+
+const AccountType = Object.freeze({
+  MutableWallet: "MutableWallet",
+  ImmutableWallet: "ImmutableWallet",
+  FungibleFaucet: "FungibleFaucet",
+});
+
+const AuthScheme = Object.freeze({
+  Falcon: "falcon",
+  ECDSA: "ecdsa",
+});
+
 const buildTypedArraysExport = (exportObject) => {
   return Object.entries(exportObject).reduce(
-    (exports, [exportName, _export]) => {
+    (exports$1, [exportName, _export]) => {
       if (exportName.endsWith("Array")) {
-        exports[exportName] = _export;
+        exports$1[exportName] = _export;
       }
-      return exports;
+      return exports$1;
     },
     {}
   );
@@ -291,6 +1487,8 @@ const ensureWasm = async () => {
           copyWebClientStatics(module.WebClient);
           webClientStaticsCopied = true;
         }
+        // Set WASM module for standalone utilities
+        _setWasm(module);
       }
       return module;
     });
@@ -332,6 +1530,28 @@ const getWasmOrThrow = async () => {
  * Because of this implementation, the only breaking change for end users is in the way the
  * web client is instantiated. Users should now use the WebClient.createClient static call.
  */
+/**
+ * Create a Proxy that forwards missing properties to the underlying WASM
+ * WebClient.
+ */
+function createClientProxy(instance) {
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (target.wasmWebClient && prop in target.wasmWebClient) {
+        const value = target.wasmWebClient[prop];
+        if (typeof value === "function") {
+          return value.bind(target.wasmWebClient);
+        }
+        return value;
+      }
+      return undefined;
+    },
+  });
+}
+
 class WebClient {
   /**
    * Create a WebClient wrapper.
@@ -477,6 +1697,25 @@ class WebClient {
     // Lazy initialize the underlying WASM WebClient when first requested.
     this.wasmWebClient = null;
     this.wasmWebClientPromise = null;
+
+    // Promise chain to serialize direct WASM calls that require exclusive
+    // (&mut self) access. Without this, concurrent calls on the same client
+    // would panic with "recursive use of an object detected" due to
+    // wasm-bindgen's internal RefCell.
+    this._wasmCallChain = Promise.resolve();
+  }
+
+  /**
+   * Serialize a WASM call that requires exclusive (&mut self) access.
+   * Concurrent calls are queued and executed one at a time.
+   *
+   * @param {() => Promise<any>} fn - The async function to execute.
+   * @returns {Promise<any>} The result of fn.
+   */
+  _serializeWasmCall(fn) {
+    const result = this._wasmCallChain.catch(() => {}).then(fn);
+    this._wasmCallChain = result.catch(() => {});
+    return result;
   }
 
   // TODO: This will soon conflict with some changes in main.
@@ -550,24 +1789,7 @@ class WebClient {
     // Wait for the worker to be ready
     await instance.ready;
 
-    // Return a proxy that forwards missing properties to wasmWebClient.
-    return new Proxy(instance, {
-      get(target, prop, receiver) {
-        // If the property exists on the wrapper, return it.
-        if (prop in target) {
-          return Reflect.get(target, prop, receiver);
-        }
-        // Otherwise, if the wasmWebClient has it, return that.
-        if (target.wasmWebClient && prop in target.wasmWebClient) {
-          const value = target.wasmWebClient[prop];
-          if (typeof value === "function") {
-            return value.bind(target.wasmWebClient);
-          }
-          return value;
-        }
-        return undefined;
-      },
-    });
+    return createClientProxy(instance);
   }
 
   /**
@@ -625,24 +1847,7 @@ class WebClient {
     );
 
     await instance.ready;
-    // Return a proxy that forwards missing properties to wasmWebClient.
-    return new Proxy(instance, {
-      get(target, prop, receiver) {
-        // If the property exists on the wrapper, return it.
-        if (prop in target) {
-          return Reflect.get(target, prop, receiver);
-        }
-        // Otherwise, if the wasmWebClient has it, return that.
-        if (target.wasmWebClient && prop in target.wasmWebClient) {
-          const value = target.wasmWebClient[prop];
-          if (typeof value === "function") {
-            return value.bind(target.wasmWebClient);
-          }
-          return value;
-        }
-        return undefined;
-      },
-    });
+    return createClientProxy(instance);
   }
 
   /**
@@ -671,30 +1876,15 @@ class WebClient {
   // ----- Explicitly Wrapped Methods (Worker-Forwarded) -----
 
   async newWallet(storageMode, mutable, authSchemeId, seed) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.newWallet(
-          storageMode,
-          mutable,
-          authSchemeId,
-          seed
-        );
-      }
-      const wasm = await getWasmOrThrow();
-      const serializedStorageMode = storageMode.asStr();
-      const serializedAccountBytes = await this.callMethodWithWorker(
-        MethodName.NEW_WALLET,
-        serializedStorageMode,
+    return this._serializeWasmCall(async () => {
+      const wasmWebClient = await this.getWasmWebClient();
+      return await wasmWebClient.newWallet(
+        storageMode,
         mutable,
         authSchemeId,
         seed
       );
-      return wasm.Account.deserialize(new Uint8Array(serializedAccountBytes));
-    } catch (error) {
-      console.error("INDEX.JS: Error in newWallet:", error);
-      throw error;
-    }
+    });
   }
 
   async newFaucet(
@@ -705,36 +1895,17 @@ class WebClient {
     maxSupply,
     authSchemeId
   ) {
-    try {
-      if (!this.worker) {
-        const wasmWebClient = await this.getWasmWebClient();
-        return await wasmWebClient.newFaucet(
-          storageMode,
-          nonFungible,
-          tokenSymbol,
-          decimals,
-          maxSupply,
-          authSchemeId
-        );
-      }
-      const wasm = await getWasmOrThrow();
-      const serializedStorageMode = storageMode.asStr();
-      const serializedMaxSupply = maxSupply.toString();
-      const serializedAccountBytes = await this.callMethodWithWorker(
-        MethodName.NEW_FAUCET,
-        serializedStorageMode,
+    return this._serializeWasmCall(async () => {
+      const wasmWebClient = await this.getWasmWebClient();
+      return await wasmWebClient.newFaucet(
+        storageMode,
         nonFungible,
         tokenSymbol,
         decimals,
-        serializedMaxSupply,
+        maxSupply,
         authSchemeId
       );
-
-      return wasm.Account.deserialize(new Uint8Array(serializedAccountBytes));
-    } catch (error) {
-      console.error("INDEX.JS: Error in newFaucet:", error);
-      throw error;
-    }
+    });
   }
 
   async submitNewTransaction(accountId, transactionRequest) {
@@ -854,6 +2025,33 @@ class WebClient {
     }
   }
 
+  async applyTransaction(transactionResult, submissionHeight) {
+    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
+      );
+
+      return wasm.TransactionStoreUpdate.deserialize(
+        new Uint8Array(serializedUpdateBytes)
+      );
+    } catch (error) {
+      console.error("INDEX.JS: Error in applyTransaction:", error);
+      throw error;
+    }
+  }
+
   /**
    * Syncs the client state with the node.
    *
@@ -920,6 +2118,15 @@ class WebClient {
     }
   }
 
+  /**
+   * Terminates the underlying Web Worker used by this WebClient instance.
+   *
+   * Call this method when you're done using a WebClient to free up browser
+   * resources. Each WebClient instance uses a dedicated Web Worker for
+   * computationally intensive operations. Terminating releases that thread.
+   *
+   * After calling terminate(), the WebClient should not be used.
+   */
   terminate() {
     if (this.worker) {
       this.worker.terminate();
@@ -973,24 +2180,7 @@ class MockWebClient extends WebClient {
     // Wait for the worker to be ready
     await instance.ready;
 
-    // Return a proxy that forwards missing properties to wasmWebClient.
-    return new Proxy(instance, {
-      get(target, prop, receiver) {
-        // If the property exists on the wrapper, return it.
-        if (prop in target) {
-          return Reflect.get(target, prop, receiver);
-        }
-        // Otherwise, if the wasmWebClient has it, return that.
-        if (target.wasmWebClient && prop in target.wasmWebClient) {
-          const value = target.wasmWebClient[prop];
-          if (typeof value === "function") {
-            return value.bind(target.wasmWebClient);
-          }
-          return value;
-        }
-        return undefined;
-      },
-    });
+    return createClientProxy(instance);
   }
 
   /**
@@ -1181,5 +2371,11 @@ function copyWebClientStatics(WasmWebClient) {
   });
 }
 
-export { MidenArrays, MockWebClient, WebClient };
+// Wire MidenClient dependencies (resolves circular import)
+MidenClient._WasmWebClient = WebClient;
+MidenClient._MockWasmWebClient = MockWebClient;
+MidenClient._getWasmOrThrow = getWasmOrThrow;
+_setWebClient(WebClient);
+
+export { AccountType, AuthScheme, MidenArrays, MidenClient, MockWebClient as MockWasmWebClient, WebClient as WasmWebClient, buildSwapTag, createP2IDENote, createP2IDNote, getWasmOrThrow };
 //# sourceMappingURL=index.js.map