@miden-sdk/react 0.13.3 → 0.14.0

package/dist/index.mjs

@@ -17,24 +17,33 @@ var initialSyncState = {
   lastSyncTime: null,
   error: null
 };
-var initialState = {
-  client: null,
-  isReady: false,
-  isInitializing: false,
-  initError: null,
-  config: {},
-  sync: initialSyncState,
-  accounts: [],
-  accountDetails: /* @__PURE__ */ new Map(),
-  notes: [],
-  consumableNotes: [],
-  assetMetadata: /* @__PURE__ */ new Map(),
-  noteFirstSeen: /* @__PURE__ */ new Map(),
-  isLoadingAccounts: false,
-  isLoadingNotes: false
-};
+function freshCachedState() {
+  return {
+    sync: { ...initialSyncState },
+    syncPaused: false,
+    accounts: [],
+    accountDetails: /* @__PURE__ */ new Map(),
+    notes: [],
+    consumableNotes: [],
+    assetMetadata: /* @__PURE__ */ new Map(),
+    noteFirstSeen: /* @__PURE__ */ new Map(),
+    isLoadingAccounts: false,
+    isLoadingNotes: false
+  };
+}
+function freshState() {
+  return {
+    client: null,
+    isReady: false,
+    isInitializing: false,
+    initError: null,
+    config: {},
+    signerConnected: null,
+    ...freshCachedState()
+  };
+}
 var useMidenStore = create()((set) => ({
-  ...initialState,
+  ...freshState(),
   setClient: (client) => set({
     client,
     isReady: client !== null,
@@ -48,9 +57,11 @@ var useMidenStore = create()((set) => ({
     isReady: false
   }),
   setConfig: (config) => set({ config }),
+  setSignerConnected: (signerConnected) => set({ signerConnected }),
   setSyncState: (sync) => set((state) => ({
     sync: { ...state.sync, ...sync }
   })),
+  setSyncPaused: (syncPaused) => set({ syncPaused }),
   setAccounts: (accounts) => set({ accounts }),
   setAccountDetails: (accountId, account) => set((state) => {
     const newMap = new Map(state.accountDetails);
@@ -132,7 +143,8 @@ var useMidenStore = create()((set) => ({
   }),
   setLoadingAccounts: (isLoadingAccounts) => set({ isLoadingAccounts }),
   setLoadingNotes: (isLoadingNotes) => set({ isLoadingNotes }),
-  reset: () => set(initialState)
+  resetInMemoryState: () => set(freshCachedState()),
+  reset: () => set(freshState())
 }));
 var useSyncStateStore = () => useMidenStore((state) => state.sync);
 var useAccountsStore = () => useMidenStore((state) => state.accounts);
@@ -157,11 +169,13 @@ var parseAccountIdFromString = (value) => {
   return AccountId.fromHex(normalizeHexInput(value));
 };
 var parseAccountId = (value) => {
-  if (typeof value !== "string") {
-    return value;
+  if (typeof value === "string") {
+    return parseAccountIdFromString(normalizeAccountIdInput(value));
   }
-  const normalized = normalizeAccountIdInput(value);
-  return parseAccountIdFromString(normalized);
+  if (typeof value.id === "function") {
+    return value.id();
+  }
+  return value;
 };
 function isFaucetId(accountId) {
   try {
@@ -177,6 +191,10 @@ function isFaucetId(accountId) {
   }
 }
 var parseAddress = (value, accountId) => {
+  if (typeof value !== "string") {
+    const resolvedId = accountId ?? parseAccountId(value);
+    return Address.fromAccountId(resolvedId, "BasicWallet");
+  }
   const normalized = normalizeAccountIdInput(value);
   if (isBech32Input(normalized)) {
     try {
@@ -288,16 +306,17 @@ import {
   useMemo,
   useState
 } from "react";
-import { WebClient } from "@miden-sdk/miden-sdk";
+import { WasmWebClient as WebClient } from "@miden-sdk/miden-sdk";
 
 // src/types/index.ts
+import { AuthScheme } from "@miden-sdk/miden-sdk";
 var DEFAULTS = {
   RPC_URL: void 0,
   // Will use SDK's testnet default
   AUTO_SYNC_INTERVAL: 15e3,
   STORAGE_MODE: "private",
   WALLET_MUTABLE: true,
-  AUTH_SCHEME: 0,
+  AUTH_SCHEME: AuthScheme.AuthRpoFalcon512,
   NOTE_TYPE: "private",
   FAUCET_DECIMALS: 8
 };
@@ -351,9 +370,35 @@ function resolveTransactionProver(config) {
   if (!prover) {
     return null;
   }
-  if (typeof prover === "string") {
-    const normalized = prover.trim().toLowerCase();
-    if (normalized === "local") {
+  if (isFallbackConfig(prover)) {
+    return resolveProverTarget(prover.primary, config);
+  }
+  return resolveProverTarget(prover, config);
+}
+async function proveWithFallback(proveFn, config) {
+  const primaryProver = resolveTransactionProver(config);
+  try {
+    return await proveFn(primaryProver ?? void 0);
+  } catch (primaryError) {
+    const { prover } = config;
+    if (!prover || !isFallbackConfig(prover) || !prover.fallback) {
+      throw primaryError;
+    }
+    if (prover.disableFallback?.()) {
+      throw primaryError;
+    }
+    const fallbackProver = resolveProverTarget(prover.fallback, config);
+    prover.onFallback?.();
+    return await proveFn(fallbackProver ?? void 0);
+  }
+}
+function isFallbackConfig(prover) {
+  return typeof prover === "object" && "primary" in prover;
+}
+function resolveProverTarget(target, config) {
+  if (typeof target === "string") {
+    const normalized = target.trim().toLowerCase();
+    if (normalized === "local" || normalized === "localhost") {
       return TransactionProver.newLocalProver();
     }
     if (normalized === "devnet" || normalized === "testnet") {
@@ -367,11 +412,11 @@ function resolveTransactionProver(config) {
       );
     }
     return TransactionProver.newRemoteProver(
-      prover,
+      target,
       normalizeTimeout(config.proverTimeoutMs)
     );
   }
-  return createRemoteProver(prover, config.proverTimeoutMs);
+  return createRemoteProver(target, config.proverTimeoutMs);
 }
 function createRemoteProver(config, fallbackTimeout) {
   const { url, timeoutMs } = config;
@@ -401,35 +446,41 @@ function useSigner() {
 }
 
 // src/utils/signerAccount.ts
-async function getAccountType(accountType) {
-  const { AccountType } = await import("@miden-sdk/miden-sdk");
-  switch (accountType) {
-    case "RegularAccountImmutableCode":
-      return AccountType.RegularAccountImmutableCode;
-    case "RegularAccountUpdatableCode":
-      return AccountType.RegularAccountUpdatableCode;
-    case "FungibleFaucet":
-      return AccountType.FungibleFaucet;
-    case "NonFungibleFaucet":
-      return AccountType.NonFungibleFaucet;
-    default:
-      return AccountType.RegularAccountImmutableCode;
-  }
+var WASM_ACCOUNT_TYPE = {
+  FungibleFaucet: 0,
+  NonFungibleFaucet: 1,
+  RegularAccountImmutableCode: 2,
+  RegularAccountUpdatableCode: 3
+};
+function getAccountType(accountType) {
+  return WASM_ACCOUNT_TYPE[accountType] ?? WASM_ACCOUNT_TYPE.RegularAccountImmutableCode;
 }
 function isPrivateStorageMode(storageMode) {
   return storageMode.toString() === "private";
 }
 async function initializeSignerAccount(client, config) {
-  const { AccountBuilder, AccountComponent, Word: Word2 } = await import("@miden-sdk/miden-sdk");
+  const { AccountBuilder, AccountComponent, AuthScheme: AuthScheme2, Word: Word2 } = await import("@miden-sdk/miden-sdk");
   await client.syncState();
+  if (config.importAccountId) {
+    const accountId2 = parseAccountId(config.importAccountId);
+    try {
+      await client.importAccountById(accountId2);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("already being tracked")) {
+        throw e;
+      }
+    }
+    await client.syncState();
+    return config.importAccountId;
+  }
   const commitmentWord = Word2.deserialize(config.publicKeyCommitment);
   const seed = config.accountSeed ?? crypto.getRandomValues(new Uint8Array(32));
-  const accountType = await getAccountType(config.accountType);
+  const accountType = getAccountType(config.accountType);
   let builder = new AccountBuilder(seed).withAuthComponent(
     AccountComponent.createAuthComponentFromCommitment(
       commitmentWord,
-      1
-      // ECDSA auth scheme (K256/Keccak)
+      AuthScheme2.AuthEcdsaK256Keccak
     )
   ).accountType(accountType).storageMode(config.storageMode).withBasicWalletComponent();
   if (config.customComponents?.length) {
@@ -480,15 +531,19 @@ function MidenProvider({
     isReady,
     isInitializing,
     initError,
+    signerConnected,
     setClient,
     setInitializing,
     setInitError,
     setConfig,
-    setSyncState
+    setSyncState,
+    setSignerConnected
   } = useMidenStore();
   const syncIntervalRef = useRef(null);
   const isInitializedRef = useRef(false);
   const clientLockRef = useRef(new AsyncLock());
+  const currentStoreNameRef = useRef(null);
+  const signCbRef = useRef(null);
   const signerContext = useSigner();
   const [signerAccountId, setSignerAccountId] = useState(null);
   const resolvedConfig = useMemo(
@@ -516,35 +571,62 @@ function MidenProvider({
     const store = useMidenStore.getState();
     if (store.sync.isSyncing) return;
     setSyncState({ isSyncing: true, error: null });
-    await runExclusive(async () => {
-      try {
-        const summary = await client.syncState();
-        const syncHeight = summary.blockNum();
-        setSyncState({
-          syncHeight,
-          isSyncing: false,
-          lastSyncTime: Date.now(),
-          error: null
-        });
-        const accounts = await client.getAccounts();
-        useMidenStore.getState().setAccounts(accounts);
-      } catch (error) {
-        setSyncState({
-          isSyncing: false,
-          error: error instanceof Error ? error : new Error(String(error))
-        });
+    try {
+      const summary = await client.syncState();
+      const syncHeight = summary.blockNum();
+      setSyncState({
+        syncHeight,
+        isSyncing: false,
+        lastSyncTime: Date.now(),
+        error: null
+      });
+      const accounts = await client.getAccounts();
+      useMidenStore.getState().setAccounts(accounts);
+    } catch (error) {
+      setSyncState({
+        isSyncing: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }, [client, isReady, setSyncState]);
+  const signerIsConnected = signerContext?.isConnected ?? null;
+  const signerStoreName = signerContext?.storeName ?? null;
+  const signerAccountType = signerContext?.accountConfig?.accountType ?? null;
+  const signerStorageMode = signerContext?.accountConfig?.storageMode?.toString() ?? null;
+  useEffect(() => {
+    signCbRef.current = signerContext?.signCb ?? null;
+  }, [signerContext?.signCb]);
+  const wrappedSignCb = useCallback(
+    async (pubKey, signingInputs) => {
+      const cb = signCbRef.current;
+      if (!cb) {
+        throw new Error("Signer is disconnected. Cannot sign.");
       }
-    });
-  }, [client, isReady, runExclusive, setSyncState]);
+      return cb(pubKey, signingInputs);
+    },
+    []
+  );
   useEffect(() => {
-    if (!signerContext && isInitializedRef.current) return;
-    if (signerContext && !signerContext.isConnected) {
-      if (useMidenStore.getState().client) {
-        useMidenStore.getState().reset();
+    if (signerIsConnected === null && isInitializedRef.current) return;
+    if (signerIsConnected === false) {
+      const store = useMidenStore.getState();
+      if (store.signerConnected !== false) {
+        setSignerConnected(false);
+      }
+      return;
+    }
+    if (signerIsConnected === true && signerStoreName !== null) {
+      const store = useMidenStore.getState();
+      if (currentStoreNameRef.current === signerStoreName && store.client !== null) {
+        store.client.setSignCb(wrappedSignCb);
+        setSignerConnected(true);
+        return;
+      }
+      if (currentStoreNameRef.current !== null && currentStoreNameRef.current !== signerStoreName) {
+        store.resetInMemoryState();
         setClient(null);
         setSignerAccountId(null);
       }
-      return;
     }
     let cancelled = false;
     const initClient = async () => {
@@ -555,18 +637,17 @@ function MidenProvider({
         try {
           let webClient;
           let didSignerInit = false;
-          if (signerContext && signerContext.isConnected) {
+          if (signerContext && signerIsConnected === true) {
             const storeName = `MidenClientDB_${signerContext.storeName}`;
+            signCbRef.current = signerContext.signCb;
             webClient = await WebClient.createClientWithExternalKeystore(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               resolvedConfig.seed,
               storeName,
-              void 0,
-              // getKeyCb - not needed for public accounts
-              void 0,
-              // insertKeyCb - not needed for public accounts
-              signerContext.signCb
+              signerContext.getKeyCb,
+              signerContext.insertKeyCb,
+              wrappedSignCb
             );
             if (cancelled) return;
             const accountId = await initializeSignerAccount(
@@ -576,6 +657,7 @@ function MidenProvider({
             if (cancelled) return;
             setSignerAccountId(accountId);
             didSignerInit = true;
+            currentStoreNameRef.current = signerContext.storeName;
           } else {
             const seed = resolvedConfig.seed;
             webClient = await WebClient.createClient(
@@ -609,6 +691,9 @@ function MidenProvider({
               isInitializedRef.current = true;
             }
             setClient(webClient);
+            if (signerIsConnected === true) {
+              setSignerConnected(true);
+            }
           }
         } catch (error) {
           if (!cancelled) {
@@ -632,14 +717,26 @@ function MidenProvider({
     setInitError,
     setInitializing,
     setSyncState,
-    signerContext
+    setSignerConnected,
+    signerIsConnected,
+    signerStoreName,
+    signerAccountType,
+    signerStorageMode,
+    wrappedSignCb
+    // Note: signerContext is intentionally NOT a dep — we use stable primitives
+    // (signerIsConnected, signerStoreName, signerAccountType, signerStorageMode)
+    // to avoid re-running when the signer provider creates a new object ref.
+    // signCb changes are handled by the dedicated useEffect + signCbRef above,
+    // not by this effect.
   ]);
   useEffect(() => {
     if (!isReady || !client) return;
     const interval = config.autoSyncInterval ?? DEFAULTS.AUTO_SYNC_INTERVAL;
     if (interval <= 0) return;
     syncIntervalRef.current = setInterval(() => {
-      sync();
+      if (!useMidenStore.getState().syncPaused) {
+        sync();
+      }
     }, interval);
     return () => {
       if (syncIntervalRef.current) {
@@ -648,6 +745,20 @@ function MidenProvider({
       }
     };
   }, [isReady, client, config.autoSyncInterval, sync]);
+  useEffect(() => {
+    if (!isReady || !client) return;
+    const unsubscribe = client.onStateChanged?.(async () => {
+      try {
+        const accounts = await client.getAccounts();
+        useMidenStore.getState().setAccounts(accounts);
+        setSyncState({ lastSyncTime: Date.now() });
+      } catch {
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  }, [isReady, client, setSyncState]);
   if (isInitializing && loadingComponent) {
     return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent });
   }
@@ -665,7 +776,8 @@ function MidenProvider({
     sync,
     runExclusive,
     prover: defaultProver,
-    signerAccountId
+    signerAccountId,
+    signerConnected
   };
   return /* @__PURE__ */ jsx(MidenContext.Provider, { value: contextValue, children });
 }
@@ -686,35 +798,191 @@ function useMidenClient() {
   return client;
 }
 
-// src/hooks/useAccounts.ts
-import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
-
-// src/utils/runExclusive.ts
-var runExclusiveDirect = async (fn) => fn();
+// src/context/MultiSignerProvider.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useState as useState2,
+  useCallback as useCallback2,
+  useMemo as useMemo2
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var MultiSignerRegistryContext = createContext3(null);
+var MultiSignerContext = createContext3(null);
+function MultiSignerProvider({ children }) {
+  const signersRef = useRef2(/* @__PURE__ */ new Map());
+  const [signersSnapshot, setSignersSnapshot] = useState2(
+    []
+  );
+  const [activeSignerName, setActiveSignerName] = useState2(null);
+  const activeSignerNameRef = useRef2(null);
+  const generationRef = useRef2(0);
+  const updateSnapshot = useCallback2(() => {
+    setSignersSnapshot(Array.from(signersRef.current.values()));
+  }, []);
+  const register = useCallback2(
+    (value) => {
+      const prev = signersRef.current.get(value.name);
+      signersRef.current.set(value.name, value);
+      if (!prev || prev.name !== value.name || prev.isConnected !== value.isConnected || prev.storeName !== value.storeName || prev.accountConfig !== value.accountConfig) {
+        updateSnapshot();
+      }
+    },
+    [updateSnapshot]
+  );
+  const unregister = useCallback2(
+    (name) => {
+      signersRef.current.delete(name);
+      setActiveSignerName((current) => current === name ? null : current);
+      updateSnapshot();
+    },
+    [updateSnapshot]
+  );
+  const registry = useMemo2(
+    () => ({ register, unregister }),
+    [register, unregister]
+  );
+  const activeSigner = activeSignerName ? signersSnapshot.find((s) => s.name === activeSignerName) ?? null : null;
+  const stableSignCb = useCallback2(
+    async (pubKey, signingInputs) => {
+      const name = activeSignerName;
+      if (!name) throw new Error("No active signer (signer was disconnected)");
+      const signer = signersRef.current.get(name);
+      if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+      return signer.signCb(pubKey, signingInputs);
+    },
+    [activeSignerName]
+  );
+  const stableConnect = useCallback2(async () => {
+    const name = activeSignerName;
+    if (!name) throw new Error("No active signer (signer was disconnected)");
+    const signer = signersRef.current.get(name);
+    if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+    return signer.connect();
+  }, [activeSignerName]);
+  const stableDisconnect = useCallback2(async () => {
+    const name = activeSignerName;
+    if (!name) throw new Error("No active signer (signer was disconnected)");
+    const signer = signersRef.current.get(name);
+    if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+    return signer.disconnect();
+  }, [activeSignerName]);
+  const forwardedValue = useMemo2(() => {
+    if (!activeSigner) return null;
+    return {
+      name: activeSigner.name,
+      isConnected: activeSigner.isConnected,
+      storeName: activeSigner.storeName,
+      accountConfig: activeSigner.accountConfig,
+      signCb: stableSignCb,
+      connect: stableConnect,
+      disconnect: stableDisconnect
+    };
+  }, [
+    activeSigner?.name,
+    activeSigner?.isConnected,
+    activeSigner?.storeName,
+    activeSigner?.accountConfig,
+    stableSignCb,
+    stableConnect,
+    stableDisconnect
+  ]);
+  const setActiveName = useCallback2((name) => {
+    activeSignerNameRef.current = name;
+    setActiveSignerName(name);
+  }, []);
+  const connectSigner = useCallback2(
+    async (name) => {
+      const currentName = activeSignerNameRef.current;
+      const currentSigner = currentName ? signersRef.current.get(currentName) : null;
+      if (currentName === name && currentSigner?.isConnected) return;
+      const newSigner = signersRef.current.get(name);
+      if (!newSigner) throw new Error(`Signer "${name}" not found`);
+      const generation = ++generationRef.current;
+      setActiveName(name);
+      if (currentSigner?.isConnected) {
+        currentSigner.disconnect().catch((err) => {
+          console.warn("Failed to disconnect previous signer:", err);
+        });
+      }
+      try {
+        await newSigner.connect();
+        if (generation !== generationRef.current) return;
+      } catch (err) {
+        if (generation !== generationRef.current) return;
+        setActiveName(null);
+        throw err;
+      }
+    },
+    [setActiveName]
+  );
+  const disconnectSigner = useCallback2(async () => {
+    ++generationRef.current;
+    const currentName = activeSignerNameRef.current;
+    const signer = currentName ? signersRef.current.get(currentName) : null;
+    setActiveName(null);
+    if (signer?.isConnected) {
+      signer.disconnect().catch((err) => {
+        console.warn("Failed to disconnect signer:", err);
+      });
+    }
+  }, [setActiveName]);
+  const multiSignerValue = useMemo2(
+    () => ({
+      signers: signersSnapshot,
+      activeSigner,
+      connectSigner,
+      disconnectSigner
+    }),
+    [signersSnapshot, activeSigner, connectSigner, disconnectSigner]
+  );
+  return /* @__PURE__ */ jsx2(SignerContext.Provider, { value: forwardedValue, children: /* @__PURE__ */ jsx2(MultiSignerRegistryContext.Provider, { value: registry, children: /* @__PURE__ */ jsx2(MultiSignerContext.Provider, { value: multiSignerValue, children }) }) });
+}
+function SignerSlot() {
+  const signerValue = useSigner();
+  const registry = useContext3(MultiSignerRegistryContext);
+  const nameRef = useRef2();
+  useEffect2(() => {
+    if (!signerValue || !registry) return;
+    nameRef.current = signerValue.name;
+    registry.register(signerValue);
+  }, [signerValue, registry]);
+  useEffect2(() => {
+    return () => {
+      if (nameRef.current && registry) {
+        registry.unregister(nameRef.current);
+      }
+    };
+  }, [registry]);
+  return null;
+}
+function useMultiSigner() {
+  return useContext3(MultiSignerContext);
+}
 
 // src/hooks/useAccounts.ts
+import { useCallback as useCallback3, useEffect as useEffect3 } from "react";
 function useAccounts() {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const accounts = useAccountsStore();
   const isLoadingAccounts = useMidenStore((state) => state.isLoadingAccounts);
   const setLoadingAccounts = useMidenStore((state) => state.setLoadingAccounts);
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const refetch = useCallback2(async () => {
+  const refetch = useCallback3(async () => {
     if (!client || !isReady) return;
     setLoadingAccounts(true);
     try {
-      const fetchedAccounts = await runExclusiveSafe(
-        () => client.getAccounts()
-      );
+      const fetchedAccounts = await client.getAccounts();
       setAccounts(fetchedAccounts);
     } catch (error) {
       console.error("Failed to fetch accounts:", error);
     } finally {
       setLoadingAccounts(false);
     }
-  }, [client, isReady, runExclusive, setAccounts, setLoadingAccounts]);
-  useEffect2(() => {
+  }, [client, isReady, setAccounts, setLoadingAccounts]);
+  useEffect3(() => {
     if (isReady && accounts.length === 0) {
       refetch();
     }
@@ -740,10 +1008,10 @@ function useAccounts() {
 }
 
 // src/hooks/useAccount.ts
-import { useCallback as useCallback3, useEffect as useEffect4, useState as useState2, useMemo as useMemo3 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect5, useState as useState3, useMemo as useMemo4 } from "react";
 
 // src/hooks/useAssetMetadata.ts
-import { useEffect as useEffect3, useMemo as useMemo2 } from "react";
+import { useEffect as useEffect4, useMemo as useMemo3 } from "react";
 import {
   BasicFungibleFaucetComponent,
   Endpoint,
@@ -783,12 +1051,12 @@ function useAssetMetadata(assetIds = []) {
   const assetMetadata = useAssetMetadataStore();
   const setAssetMetadata = useMidenStore((state) => state.setAssetMetadata);
   const rpcUrl = useMidenStore((state) => state.config.rpcUrl);
-  const rpcClient = useMemo2(() => getRpcClient(rpcUrl), [rpcUrl]);
-  const uniqueAssetIds = useMemo2(
+  const rpcClient = useMemo3(() => getRpcClient(rpcUrl), [rpcUrl]);
+  const uniqueAssetIds = useMemo3(
     () => Array.from(new Set(assetIds.filter(Boolean))),
     [assetIds]
   );
-  useEffect3(() => {
+  useEffect4(() => {
     if (!rpcClient || uniqueAssetIds.length === 0) return;
     uniqueAssetIds.forEach((assetId) => {
       const existing = assetMetadata.get(assetId);
@@ -807,31 +1075,25 @@ function useAssetMetadata(assetIds = []) {
 
 // src/hooks/useAccount.ts
 function useAccount(accountId) {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const accountDetails = useMidenStore((state) => state.accountDetails);
   const setAccountDetails = useMidenStore((state) => state.setAccountDetails);
   const { lastSyncTime } = useSyncStateStore();
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const accountIdStr = useMemo3(() => {
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const accountIdStr = useMemo4(() => {
     if (!accountId) return void 0;
     if (typeof accountId === "string") return accountId;
-    if (typeof accountId.toString === "function") {
-      return accountId.toString();
-    }
-    return String(accountId);
+    return parseAccountId(accountId).toString();
   }, [accountId]);
   const account = accountIdStr ? accountDetails.get(accountIdStr) ?? null : null;
-  const refetch = useCallback3(async () => {
+  const refetch = useCallback4(async () => {
     if (!client || !isReady || !accountIdStr) return;
     setIsLoading(true);
     setError(null);
     try {
       const accountIdObj = parseAccountId(accountIdStr);
-      const fetchedAccount = await runExclusiveSafe(
-        () => client.getAccount(accountIdObj)
-      );
+      const fetchedAccount = await client.getAccount(accountIdObj);
       if (fetchedAccount) {
         ensureAccountBech32(fetchedAccount);
         setAccountDetails(accountIdStr, fetchedAccount);
@@ -841,17 +1103,17 @@ function useAccount(accountId) {
     } finally {
       setIsLoading(false);
     }
-  }, [client, isReady, runExclusive, accountIdStr, setAccountDetails]);
-  useEffect4(() => {
+  }, [client, isReady, accountIdStr, setAccountDetails]);
+  useEffect5(() => {
     if (isReady && accountIdStr && !account) {
       refetch();
     }
   }, [isReady, accountIdStr, account, refetch]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!isReady || !accountIdStr || !lastSyncTime) return;
     refetch();
   }, [isReady, accountIdStr, lastSyncTime, refetch]);
-  const rawAssets = useMemo3(() => {
+  const rawAssets = useMemo4(() => {
     if (!account) return [];
     try {
       const vault = account.vault();
@@ -868,12 +1130,12 @@ function useAccount(accountId) {
       return [];
     }
   }, [account]);
-  const assetIds = useMemo3(
+  const assetIds = useMemo4(
     () => rawAssets.map((asset) => asset.assetId),
     [rawAssets]
   );
   const { assetMetadata } = useAssetMetadata(assetIds);
-  const assets = useMemo3(
+  const assets = useMemo4(
     () => rawAssets.map((asset) => {
       const metadata = assetMetadata.get(asset.assetId);
       return {
@@ -884,7 +1146,7 @@ function useAccount(accountId) {
     }),
     [rawAssets, assetMetadata]
   );
-  const getBalance = useCallback3(
+  const getBalance = useCallback4(
     (assetId) => {
       const asset = assets.find((a) => a.assetId === assetId);
       return asset?.amount ?? 0n;
@@ -902,17 +1164,18 @@ function useAccount(accountId) {
 }
 
 // src/hooks/useNotes.ts
-import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo4, useState as useState3 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useState as useState4 } from "react";
 import { NoteFilter } from "@miden-sdk/miden-sdk";
 
 // src/utils/amounts.ts
 var formatAssetAmount = (amount, decimals) => {
+  const amt = BigInt(amount);
   if (!decimals || decimals <= 0) {
-    return amount.toString();
+    return amt.toString();
   }
   const factor = 10n ** BigInt(decimals);
-  const whole = amount / factor;
-  const fraction = amount % factor;
+  const whole = amt / factor;
+  const fraction = amt % factor;
   if (fraction === 0n) {
     return whole.toString();
   }
@@ -1069,8 +1332,7 @@ function normalizeHex(value) {
 
 // src/hooks/useNotes.ts
 function useNotes(options) {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const notes = useNotesStore();
   const consumableNotes = useConsumableNotesStore();
   const isLoadingNotes = useMidenStore((state) => state.isLoadingNotes);
@@ -1080,30 +1342,22 @@ function useNotes(options) {
     (state) => state.setConsumableNotesIfChanged
   );
   const { lastSyncTime } = useSyncStateStore();
-  const [error, setError] = useState3(null);
-  const refetch = useCallback4(async () => {
+  const [error, setError] = useState4(null);
+  const refetch = useCallback5(async () => {
     if (!client || !isReady) return;
     setLoadingNotes(true);
     setError(null);
     try {
-      const { fetchedNotes, fetchedConsumable } = await runExclusiveSafe(
-        async () => {
-          const filterType = getNoteFilterType(options?.status);
-          const filter = new NoteFilter(filterType);
-          const notesResult = await client.getInputNotes(filter);
-          let consumableResult;
-          if (options?.accountId) {
-            const accountIdObj = parseAccountId(options.accountId);
-            consumableResult = await client.getConsumableNotes(accountIdObj);
-          } else {
-            consumableResult = await client.getConsumableNotes();
-          }
-          return {
-            fetchedNotes: notesResult,
-            fetchedConsumable: consumableResult
-          };
-        }
-      );
+      const filterType = getNoteFilterType(options?.status);
+      const filter = new NoteFilter(filterType);
+      const fetchedNotes = await client.getInputNotes(filter);
+      let fetchedConsumable;
+      if (options?.accountId) {
+        const accountIdObj = parseAccountId(options.accountId);
+        fetchedConsumable = await client.getConsumableNotes(accountIdObj);
+      } else {
+        fetchedConsumable = await client.getConsumableNotes();
+      }
       setNotesIfChanged(fetchedNotes);
       setConsumableNotesIfChanged(fetchedConsumable);
     } catch (err) {
@@ -1114,23 +1368,22 @@ function useNotes(options) {
   }, [
     client,
     isReady,
-    runExclusive,
     options?.status,
     options?.accountId,
     setLoadingNotes,
     setNotesIfChanged,
     setConsumableNotesIfChanged
   ]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (isReady && notes.length === 0) {
       refetch();
     }
   }, [isReady, notes.length, refetch]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (!isReady || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refetch]);
-  const noteAssetIds = useMemo4(() => {
+  const noteAssetIds = useMemo5(() => {
     const ids = /* @__PURE__ */ new Set();
     const collect = (note) => {
       const summary = getNoteSummary(note);
@@ -1142,11 +1395,11 @@ function useNotes(options) {
     return Array.from(ids);
   }, [notes, consumableNotes]);
   const { assetMetadata } = useAssetMetadata(noteAssetIds);
-  const getMetadata = useCallback4(
+  const getMetadata = useCallback5(
     (assetId) => assetMetadata.get(assetId),
     [assetMetadata]
   );
-  const normalizedSender = useMemo4(() => {
+  const normalizedSender = useMemo5(() => {
     if (!options?.sender) return null;
     try {
       return normalizeAccountId(options.sender);
@@ -1154,11 +1407,11 @@ function useNotes(options) {
       return options.sender;
     }
   }, [options?.sender]);
-  const excludeIdsKey = useMemo4(() => {
+  const excludeIdsKey = useMemo5(() => {
     if (!options?.excludeIds || options.excludeIds.length === 0) return "";
     return [...options.excludeIds].sort().join("\0");
   }, [options?.excludeIds]);
-  const filterBySender = useCallback4(
+  const filterBySender = useCallback5(
     (summaries, target) => {
       const cache = /* @__PURE__ */ new Map();
       return summaries.filter((s) => {
@@ -1177,7 +1430,7 @@ function useNotes(options) {
     },
     []
   );
-  const noteSummaries = useMemo4(() => {
+  const noteSummaries = useMemo5(() => {
     let summaries = notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1188,7 +1441,7 @@ function useNotes(options) {
     }
     return summaries;
   }, [notes, getMetadata, normalizedSender, excludeIdsKey, filterBySender]);
-  const consumableNoteSummaries = useMemo4(() => {
+  const consumableNoteSummaries = useMemo5(() => {
     let summaries = consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1217,7 +1470,7 @@ function useNotes(options) {
 }
 
 // src/hooks/useNoteStream.ts
-import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef2, useState as useState4 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo6, useRef as useRef3, useState as useState5 } from "react";
 import { NoteFilter as NoteFilter2 } from "@miden-sdk/miden-sdk";
 
 // src/utils/noteAttachment.ts
@@ -1293,54 +1546,51 @@ function createNoteAttachment(values) {
 
 // src/hooks/useNoteStream.ts
 function useNoteStream(options = {}) {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const allNotes = useNotesStore();
   const noteFirstSeen = useNoteFirstSeenStore();
   const { lastSyncTime } = useSyncStateStore();
   const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
-  const [isLoading, setIsLoading] = useState4(false);
-  const [error, setError] = useState4(null);
-  const handledIdsRef = useRef2(/* @__PURE__ */ new Set());
-  const [handledVersion, setHandledVersion] = useState4(0);
+  const [isLoading, setIsLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const handledIdsRef = useRef3(/* @__PURE__ */ new Set());
+  const [handledVersion, setHandledVersion] = useState5(0);
   const status = options.status ?? "committed";
   const sender = options.sender ?? null;
   const since = options.since;
-  const amountFilterRef = useRef2(options.amountFilter);
+  const amountFilterRef = useRef3(options.amountFilter);
   amountFilterRef.current = options.amountFilter;
-  const excludeIdsKey = useMemo5(() => {
+  const excludeIdsKey = useMemo6(() => {
     if (!options.excludeIds) return "";
     if (options.excludeIds instanceof Set)
       return Array.from(options.excludeIds).sort().join("\0");
     return [...options.excludeIds].sort().join("\0");
   }, [options.excludeIds]);
-  const excludeIdSet = useMemo5(() => {
+  const excludeIdSet = useMemo6(() => {
     if (!excludeIdsKey) return null;
     return new Set(excludeIdsKey.split("\0"));
   }, [excludeIdsKey]);
-  const refetch = useCallback5(async () => {
+  const refetch = useCallback6(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
     try {
       const filterType = getNoteFilterType(status);
       const filter = new NoteFilter2(filterType);
-      const fetched = await runExclusiveSafe(
-        () => client.getInputNotes(filter)
-      );
+      const fetched = await client.getInputNotes(filter);
       setNotesIfChanged(fetched);
     } catch (err) {
       setError(err instanceof Error ? err : new Error(String(err)));
     } finally {
       setIsLoading(false);
     }
-  }, [client, isReady, runExclusiveSafe, status, setNotesIfChanged]);
-  useEffect6(() => {
+  }, [client, isReady, status, setNotesIfChanged]);
+  useEffect7(() => {
     if (isReady) {
       refetch();
     }
   }, [isReady, lastSyncTime, refetch]);
-  const streamedNotes = useMemo5(() => {
+  const streamedNotes = useMemo6(() => {
     void handledVersion;
     const result = [];
     let normalizedSender = null;
@@ -1365,15 +1615,15 @@ function useNoteStream(options = {}) {
     result.sort((a, b) => a.firstSeenAt - b.firstSeenAt);
     return result;
   }, [allNotes, noteFirstSeen, excludeIdSet, sender, since, handledVersion]);
-  const latest = useMemo5(
+  const latest = useMemo6(
     () => streamedNotes.length > 0 ? streamedNotes[streamedNotes.length - 1] : null,
     [streamedNotes]
   );
-  const markHandled = useCallback5((noteId) => {
+  const markHandled = useCallback6((noteId) => {
     handledIdsRef.current = new Set(handledIdsRef.current).add(noteId);
     setHandledVersion((v) => v + 1);
   }, []);
-  const markAllHandled = useCallback5(() => {
+  const markAllHandled = useCallback6(() => {
     const newSet = new Set(handledIdsRef.current);
     for (const note of streamedNotes) {
       newSet.add(note.id);
@@ -1381,7 +1631,7 @@ function useNoteStream(options = {}) {
     handledIdsRef.current = newSet;
     setHandledVersion((v) => v + 1);
   }, [streamedNotes]);
-  const snapshot = useCallback5(() => {
+  const snapshot = useCallback6(() => {
     const ids = /* @__PURE__ */ new Set();
     for (const note of streamedNotes) {
       ids.add(note.id);
@@ -1437,21 +1687,20 @@ function buildStreamedNote(record, noteFirstSeen) {
 }
 
 // src/hooks/useTransactionHistory.ts
-import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo6, useState as useState5 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo7, useState as useState6 } from "react";
 import { TransactionFilter as TransactionFilter2 } from "@miden-sdk/miden-sdk";
 function useTransactionHistory(options = {}) {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const { lastSyncTime } = useSyncStateStore();
-  const [records, setRecords] = useState5([]);
-  const [isLoading, setIsLoading] = useState5(false);
-  const [error, setError] = useState5(null);
-  const rawIds = useMemo6(() => {
+  const [records, setRecords] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const rawIds = useMemo7(() => {
     if (options.id) return [options.id];
     if (options.ids && options.ids.length > 0) return options.ids;
     return null;
   }, [options.id, options.ids]);
-  const idsHex = useMemo6(() => {
+  const idsHex = useMemo7(() => {
     if (!rawIds) return null;
     return rawIds.map(
       (id) => normalizeHex2(typeof id === "string" ? id : id.toHex())
@@ -1459,7 +1708,7 @@ function useTransactionHistory(options = {}) {
   }, [rawIds]);
   const filter = options.filter;
   const refreshOnSync = options.refreshOnSync !== false;
-  const refetch = useCallback6(async () => {
+  const refetch = useCallback7(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
@@ -1469,9 +1718,7 @@ function useTransactionHistory(options = {}) {
         rawIds,
         idsHex
       );
-      const fetched = await runExclusiveSafe(
-        () => client.getTransactions(resolvedFilter)
-      );
+      const fetched = await client.getTransactions(resolvedFilter);
       const filtered = localFilterHexes ? fetched.filter(
         (record2) => localFilterHexes.includes(normalizeHex2(record2.id().toHex()))
       ) : fetched;
@@ -1481,20 +1728,20 @@ function useTransactionHistory(options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [client, isReady, runExclusiveSafe, filter, rawIds, idsHex]);
-  useEffect7(() => {
+  }, [client, isReady, filter, rawIds, idsHex]);
+  useEffect8(() => {
     if (!isReady) return;
     refetch();
   }, [isReady, refetch]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (!isReady || !refreshOnSync || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refreshOnSync, refetch]);
-  const record = useMemo6(() => {
+  const record = useMemo7(() => {
     if (!idsHex || idsHex.length !== 1) return null;
     return records.find((item) => normalizeHex2(item.id().toHex()) === idsHex[0]) ?? null;
   }, [records, idsHex]);
-  const status = useMemo6(() => {
+  const status = useMemo7(() => {
     if (!record) return null;
     const current = record.transactionStatus();
     if (current.isCommitted()) return "committed";
@@ -1534,11 +1781,11 @@ function normalizeHex2(value) {
 }
 
 // src/hooks/useSyncState.ts
-import { useCallback as useCallback7 } from "react";
+import { useCallback as useCallback8 } from "react";
 function useSyncState() {
   const { sync: triggerSync } = useMiden();
   const syncState = useSyncStateStore();
-  const sync = useCallback7(async () => {
+  const sync = useCallback8(async () => {
     await triggerSync();
   }, [triggerSync]);
   return {
@@ -1548,21 +1795,25 @@ function useSyncState() {
 }
 
 // src/hooks/useCreateWallet.ts
-import { useCallback as useCallback8, useState as useState6 } from "react";
+import { useCallback as useCallback9, useState as useState7 } from "react";
 import { AccountStorageMode } from "@miden-sdk/miden-sdk";
+
+// src/utils/runExclusive.ts
+var runExclusiveDirect = async (fn) => fn();
+
+// src/hooks/useCreateWallet.ts
 function useCreateWallet() {
-  const { client, isReady, sync, runExclusive } = useMiden();
+  const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [wallet, setWallet] = useState6(null);
-  const [isCreating, setIsCreating] = useState6(false);
-  const [error, setError] = useState6(null);
-  const createWallet = useCallback8(
+  const [wallet, setWallet] = useState7(null);
+  const [isCreating, setIsCreating] = useState7(false);
+  const [error, setError] = useState7(null);
+  const createWallet = useCallback9(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
-      await sync();
       setIsCreating(true);
       setError(null);
       try {
@@ -1595,7 +1846,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback8(() => {
+  const reset = useCallback9(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1622,16 +1873,16 @@ function getStorageMode(mode) {
 }
 
 // src/hooks/useCreateFaucet.ts
-import { useCallback as useCallback9, useState as useState7 } from "react";
+import { useCallback as useCallback10, useState as useState8 } from "react";
 import { AccountStorageMode as AccountStorageMode2 } from "@miden-sdk/miden-sdk";
 function useCreateFaucet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [faucet, setFaucet] = useState7(null);
-  const [isCreating, setIsCreating] = useState7(false);
-  const [error, setError] = useState7(null);
-  const createFaucet = useCallback9(
+  const [faucet, setFaucet] = useState8(null);
+  const [isCreating, setIsCreating] = useState8(false);
+  const [error, setError] = useState8(null);
+  const createFaucet = useCallback10(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1651,7 +1902,7 @@ function useCreateFaucet() {
             // nonFungible - currently only fungible faucets supported
             options.tokenSymbol,
             decimals,
-            options.maxSupply,
+            BigInt(options.maxSupply),
             authScheme
           );
           const accounts = await client.getAccounts();
@@ -1670,7 +1921,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback9(() => {
+  const reset = useCallback10(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -1697,25 +1948,79 @@ function getStorageMode2(mode) {
 }
 
 // src/hooks/useImportAccount.ts
-import { useCallback as useCallback10, useState as useState8 } from "react";
+import { useCallback as useCallback11, useState as useState9 } from "react";
 import { AccountFile } from "@miden-sdk/miden-sdk";
+
+// src/utils/errors.ts
+var MidenError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "MidenError";
+    this.code = options?.code ?? "UNKNOWN";
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var ERROR_PATTERNS = [
+  {
+    test: (msg) => msg.includes("_assertClass") || msg.includes("expected instance of"),
+    code: "WASM_CLASS_MISMATCH",
+    message: "WASM class identity mismatch. This usually means multiple copies of @miden-sdk/miden-sdk are bundled. Ensure your bundler deduplicates the package. For Vite: add resolve.dedupe and optimizeDeps.exclude for @miden-sdk/miden-sdk."
+  },
+  {
+    test: (msg) => msg.includes("null pointer") || msg.includes("already been freed") || msg.includes("dereferencing a null"),
+    code: "WASM_POINTER_CONSUMED",
+    message: "WASM object was already consumed. Some WASM-bound objects can only be passed once \u2014 if you need to reuse a value, create a fresh instance before each call."
+  },
+  {
+    test: (msg) => msg.includes("not initialized") || msg.includes("Cannot read properties of null"),
+    code: "WASM_NOT_INITIALIZED",
+    message: "Miden client is not initialized. Ensure you are inside a <MidenProvider> and the client is ready before calling SDK methods."
+  },
+  {
+    test: (msg) => msg.includes("state commitment mismatch") || msg.includes("stale state"),
+    code: "WASM_SYNC_REQUIRED",
+    message: "Account state is stale. Call sync() before executing transactions, or ensure no concurrent transactions are running against the same account."
+  }
+];
+function assertSignerConnected(signerConnected) {
+  if (signerConnected === false) {
+    throw new Error(
+      "Signer is disconnected. Reconnect your wallet to perform transactions."
+    );
+  }
+}
+function wrapWasmError(e) {
+  if (e instanceof MidenError) return e;
+  const msg = e instanceof Error ? e.message : String(e);
+  for (const pattern of ERROR_PATTERNS) {
+    if (pattern.test(msg)) {
+      return new MidenError(pattern.message, { cause: e, code: pattern.code });
+    }
+  }
+  if (e instanceof Error) return e;
+  return new Error(msg);
+}
+
+// src/hooks/useImportAccount.ts
 function useImportAccount() {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady, signerConnected } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [account, setAccount] = useState8(null);
-  const [isImporting, setIsImporting] = useState8(false);
-  const [error, setError] = useState8(null);
-  const importAccount = useCallback10(
+  const [account, setAccount] = useState9(null);
+  const [isImporting, setIsImporting] = useState9(false);
+  const [error, setError] = useState9(null);
+  const importAccount = useCallback11(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
+      assertSignerConnected(signerConnected);
       setIsImporting(true);
       setError(null);
       try {
         let accountsAfter = null;
-        const imported = await runExclusiveSafe(async () => {
+        const imported = await (async () => {
           switch (options.type) {
             case "file": {
               const accountsBefore = await client.getAccounts();
@@ -1767,7 +2072,7 @@ function useImportAccount() {
               throw new Error("Account not found after import");
             }
             case "id": {
-              const accountId = resolveAccountId(options.accountId);
+              const accountId = parseAccountId(options.accountId);
               await client.importAccountById(accountId);
               const fetchedAccount = await client.getAccount(accountId);
               if (!fetchedAccount) {
@@ -1785,7 +2090,7 @@ function useImportAccount() {
               );
             }
           }
-        });
+        })();
         ensureAccountBech32(imported);
         const accounts = accountsAfter ?? await client.getAccounts();
         setAccounts(accounts);
@@ -1799,9 +2104,9 @@ function useImportAccount() {
         setIsImporting(false);
       }
     },
-    [client, isReady, runExclusive, setAccounts]
+    [client, isReady, setAccounts, signerConnected]
   );
-  const reset = useCallback10(() => {
+  const reset = useCallback11(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -1814,9 +2119,6 @@ function useImportAccount() {
     reset
   };
 }
-function resolveAccountId(accountId) {
-  return parseAccountId(accountId);
-}
 async function resolveAccountFile(file) {
   if (file instanceof Uint8Array) {
     return AccountFile.deserialize(file);
@@ -1851,72 +2153,25 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-import { useCallback as useCallback11, useRef as useRef3, useState as useState9 } from "react";
+import { useCallback as useCallback12, useRef as useRef4, useState as useState10 } from "react";
 import {
   FungibleAsset,
   Note,
   NoteAssets,
+  NoteAttachment as NoteAttachment2,
   NoteType as NoteType2,
-  OutputNote,
-  OutputNoteArray,
+  NoteArray,
   TransactionRequestBuilder
 } from "@miden-sdk/miden-sdk";
-
-// src/utils/errors.ts
-var MidenError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "MidenError";
-    this.code = options?.code ?? "UNKNOWN";
-    if (options?.cause !== void 0) {
-      this.cause = options.cause;
-    }
-  }
-};
-var ERROR_PATTERNS = [
-  {
-    test: (msg) => msg.includes("_assertClass") || msg.includes("expected instance of"),
-    code: "WASM_CLASS_MISMATCH",
-    message: "WASM class identity mismatch. This usually means multiple copies of @miden-sdk/miden-sdk are bundled. Ensure your bundler deduplicates the package. For Vite: add resolve.dedupe and optimizeDeps.exclude for @miden-sdk/miden-sdk."
-  },
-  {
-    test: (msg) => msg.includes("null pointer") || msg.includes("already been freed") || msg.includes("dereferencing a null"),
-    code: "WASM_POINTER_CONSUMED",
-    message: "WASM object was already consumed. Some WASM-bound objects can only be passed once \u2014 if you need to reuse a value, create a fresh instance before each call."
-  },
-  {
-    test: (msg) => msg.includes("not initialized") || msg.includes("Cannot read properties of null"),
-    code: "WASM_NOT_INITIALIZED",
-    message: "Miden client is not initialized. Ensure you are inside a <MidenProvider> and the client is ready before calling SDK methods."
-  },
-  {
-    test: (msg) => msg.includes("state commitment mismatch") || msg.includes("stale state"),
-    code: "WASM_SYNC_REQUIRED",
-    message: "Account state is stale. Call sync() before executing transactions, or ensure no concurrent transactions are running against the same account."
-  }
-];
-function wrapWasmError(e) {
-  if (e instanceof MidenError) return e;
-  const msg = e instanceof Error ? e.message : String(e);
-  for (const pattern of ERROR_PATTERNS) {
-    if (pattern.test(msg)) {
-      return new MidenError(pattern.message, { cause: e, code: pattern.code });
-    }
-  }
-  if (e instanceof Error) return e;
-  return new Error(msg);
-}
-
-// src/hooks/useSend.ts
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef3(false);
-  const [result, setResult] = useState9(null);
-  const [isLoading, setIsLoading] = useState9(false);
-  const [stage, setStage] = useState9("idle");
-  const [error, setError] = useState9(null);
-  const send = useCallback11(
+  const isBusyRef = useRef4(false);
+  const [result, setResult] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [stage, setStage] = useState10("idle");
+  const [error, setError] = useState10(null);
+  const send = useCallback12(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1958,6 +2213,7 @@ function useSend() {
         if (amount === void 0 || amount === null) {
           throw new Error("Amount is required (provide amount or sendAll)");
         }
+        amount = BigInt(amount);
         const assetId = options.assetId ?? options.faucetId ?? null;
         if (!assetId) {
           throw new Error("Asset ID is required");
@@ -1968,6 +2224,35 @@ function useSend() {
             "recallHeight and timelockHeight are not supported when attachment is provided"
           );
         }
+        if (options.returnNote === true) {
+          const returnResult = await runExclusiveSafe(async () => {
+            const fromId = parseAccountId(options.from);
+            const toId = parseAccountId(options.to);
+            const assetObj = parseAccountId(assetId);
+            const assets = new NoteAssets([
+              new FungibleAsset(assetObj, BigInt(amount))
+            ]);
+            const p2idNote = Note.createP2IDNote(
+              fromId,
+              toId,
+              assets,
+              noteType,
+              new NoteAttachment2()
+            );
+            const txRequest = new TransactionRequestBuilder().withOwnOutputNotes(new NoteArray([p2idNote])).build();
+            const execFromId = parseAccountId(options.from);
+            const txId = prover ? await client.submitNewTransactionWithProver(
+              execFromId,
+              txRequest,
+              prover
+            ) : await client.submitNewTransaction(execFromId, txRequest);
+            return { txId: txId.toString(), note: p2idNote };
+          });
+          setStage("complete");
+          setResult(returnResult);
+          await sync();
+          return returnResult;
+        }
         const txResult = await runExclusiveSafe(async () => {
           const fromAccountId = parseAccountId(options.from);
           const toAccountId = parseAccountId(options.to);
@@ -1985,7 +2270,7 @@ function useSend() {
               noteType,
               attachment
             );
-            txRequest = new TransactionRequestBuilder().withOwnOutputNotes(new OutputNoteArray([OutputNote.full(note)])).build();
+            txRequest = new TransactionRequestBuilder().withOwnOutputNotes(new NoteArray([note])).build();
           } else {
             txRequest = client.newSendTransactionRequest(
               fromAccountId,
@@ -2001,8 +2286,12 @@ function useSend() {
           return await client.executeTransaction(execAccountId, txRequest);
         });
         setStage("proving");
-        const provenTransaction = await runExclusiveSafe(
-          () => client.proveTransaction(txResult, prover ?? void 0)
+        const proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveSafe(
+            () => client.proveTransaction(txResult, resolvedProver)
+          ),
+          proverConfig
         );
         setStage("submitting");
         const submissionHeight = await runExclusiveSafe(
@@ -2032,11 +2321,14 @@ function useSend() {
             () => client.sendPrivateNote(fullNote, recipientAddress)
           );
         }
-        const txSummary = { transactionId: txIdString };
+        const sendResult = {
+          txId: txIdString,
+          note: null
+        };
         setStage("complete");
-        setResult(txSummary);
+        setResult(sendResult);
         await sync();
-        return txSummary;
+        return sendResult;
       } catch (err) {
         const error2 = err instanceof Error ? err : new Error(String(err));
         setError(error2);
@@ -2049,7 +2341,7 @@ function useSend() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback11(() => {
+  const reset = useCallback12(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2076,30 +2368,29 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-import { useCallback as useCallback12, useRef as useRef4, useState as useState10 } from "react";
+import { useCallback as useCallback13, useRef as useRef5, useState as useState11 } from "react";
 import {
   FungibleAsset as FungibleAsset2,
   Note as Note2,
   NoteAssets as NoteAssets2,
-  NoteAttachment as NoteAttachment2,
+  NoteAttachment as NoteAttachment3,
   NoteType as NoteType3,
-  OutputNote as OutputNote2,
-  OutputNoteArray as OutputNoteArray2,
+  NoteArray as NoteArray2,
   TransactionRequestBuilder as TransactionRequestBuilder2
 } from "@miden-sdk/miden-sdk";
 function useMultiSend() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef4(false);
-  const [result, setResult] = useState10(null);
-  const [isLoading, setIsLoading] = useState10(false);
-  const [stage, setStage] = useState10("idle");
-  const [error, setError] = useState10(null);
-  const sendMany = useCallback12(
+  const { client, isReady, sync, prover, signerConnected } = useMiden();
+  const isBusyRef = useRef5(false);
+  const [result, setResult] = useState11(null);
+  const [isLoading, setIsLoading] = useState11(false);
+  const [stage, setStage] = useState11("idle");
+  const [error, setError] = useState11(null);
+  const sendMany = useCallback13(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
+      assertSignerConnected(signerConnected);
       if (options.recipients.length === 0) {
         throw new Error("No recipients provided");
       }
@@ -2124,10 +2415,10 @@ function useMultiSend() {
             const iterAssetId = parseAccountId(options.assetId);
             const receiverId = parseAccountId(to);
             const assets = new NoteAssets2([
-              new FungibleAsset2(iterAssetId, amount)
+              new FungibleAsset2(iterAssetId, BigInt(amount))
             ]);
             const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
-            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new NoteAttachment2();
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new NoteAttachment3();
             const note = Note2.createP2IDNote(
               iterSenderId,
               receiverId,
@@ -2137,44 +2428,43 @@ function useMultiSend() {
             );
             const recipientAddress = parseAddress(to, receiverId);
             return {
-              outputNote: OutputNote2.full(note),
               note,
               recipientAddress,
               noteType: resolvedNoteType
             };
           }
         );
-        const txRequest = new TransactionRequestBuilder2().withOwnOutputNotes(
-          new OutputNoteArray2(outputs.map((o) => o.outputNote))
-        ).build();
+        const txRequest = new TransactionRequestBuilder2().withOwnOutputNotes(new NoteArray2(outputs.map((o) => o.note))).build();
         const txSenderId = parseAccountId(options.from);
-        const txResult = await runExclusiveSafe(
-          () => client.executeTransaction(txSenderId, txRequest)
-        );
+        const txResult = await client.executeTransaction(txSenderId, txRequest);
         setStage("proving");
-        const provenTransaction = await runExclusiveSafe(
-          () => client.proveTransaction(txResult, prover ?? void 0)
+        const proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveDirect(
+            () => client.proveTransaction(txResult, resolvedProver)
+          ),
+          proverConfig
         );
         setStage("submitting");
-        const submissionHeight = await runExclusiveSafe(
-          () => client.submitProvenTransaction(provenTransaction, txResult)
+        const submissionHeight = await client.submitProvenTransaction(
+          provenTransaction,
+          txResult
         );
         const txIdHex = txResult.id().toHex();
         const txIdString = txResult.id().toString();
-        await runExclusiveSafe(
-          () => client.applyTransaction(txResult, submissionHeight)
-        );
+        await client.applyTransaction(txResult, submissionHeight);
         const hasPrivate = outputs.some((o) => o.noteType === NoteType3.Private);
         if (hasPrivate) {
           await waitForTransactionCommit(
             client,
-            runExclusiveSafe,
+            runExclusiveDirect,
             txIdHex
           );
           for (const output of outputs) {
             if (output.noteType === NoteType3.Private) {
-              await runExclusiveSafe(
-                () => client.sendPrivateNote(output.note, output.recipientAddress)
+              await client.sendPrivateNote(
+                output.note,
+                output.recipientAddress
               );
             }
           }
@@ -2194,154 +2484,7 @@ function useMultiSend() {
         isBusyRef.current = false;
       }
     },
-    [client, isReady, prover, runExclusive, sync]
-  );
-  const reset = useCallback12(() => {
-    setResult(null);
-    setIsLoading(false);
-    setStage("idle");
-    setError(null);
-  }, []);
-  return {
-    sendMany,
-    result,
-    isLoading,
-    stage,
-    error,
-    reset
-  };
-}
-
-// src/hooks/useInternalTransfer.ts
-import { useCallback as useCallback13, useState as useState11 } from "react";
-import {
-  FungibleAsset as FungibleAsset3,
-  Note as Note3,
-  NoteAndArgs,
-  NoteAndArgsArray,
-  NoteAssets as NoteAssets3,
-  NoteAttachment as NoteAttachment3,
-  OutputNote as OutputNote3,
-  OutputNoteArray as OutputNoteArray3,
-  TransactionRequestBuilder as TransactionRequestBuilder3
-} from "@miden-sdk/miden-sdk";
-function useInternalTransfer() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState11(null);
-  const [isLoading, setIsLoading] = useState11(false);
-  const [stage, setStage] = useState11("idle");
-  const [error, setError] = useState11(null);
-  const transferOnce = useCallback13(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
-      const senderId = parseAccountId(options.from);
-      const receiverId = parseAccountId(options.to);
-      const assetId = parseAccountId(options.assetId);
-      const assets = new NoteAssets3([
-        new FungibleAsset3(assetId, options.amount)
-      ]);
-      const note = Note3.createP2IDNote(
-        senderId,
-        receiverId,
-        assets,
-        noteType,
-        new NoteAttachment3()
-      );
-      const noteId = note.id().toString();
-      const createRequest = new TransactionRequestBuilder3().withOwnOutputNotes(new OutputNoteArray3([OutputNote3.full(note)])).build();
-      const createTxId = await runExclusiveSafe(
-        () => prover ? client.submitNewTransactionWithProver(
-          senderId,
-          createRequest,
-          prover
-        ) : client.submitNewTransaction(senderId, createRequest)
-      );
-      const consumeRequest = new TransactionRequestBuilder3().withInputNotes(new NoteAndArgsArray([new NoteAndArgs(note, null)])).build();
-      const consumeTxId = await runExclusiveSafe(
-        () => prover ? client.submitNewTransactionWithProver(
-          receiverId,
-          consumeRequest,
-          prover
-        ) : client.submitNewTransaction(receiverId, consumeRequest)
-      );
-      return {
-        createTransactionId: createTxId.toString(),
-        consumeTransactionId: consumeTxId.toString(),
-        noteId
-      };
-    },
-    [client, isReady, prover, runExclusiveSafe]
-  );
-  const transfer = useCallback13(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      setIsLoading(true);
-      setStage("executing");
-      setError(null);
-      try {
-        setStage("proving");
-        const txResult = await transferOnce(options);
-        setStage("complete");
-        setResult(txResult);
-        await sync();
-        return txResult;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error(String(err));
-        setError(error2);
-        setStage("idle");
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, isReady, sync, transferOnce]
-  );
-  const transferChain = useCallback13(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      if (options.recipients.length === 0) {
-        throw new Error("No recipients provided");
-      }
-      setIsLoading(true);
-      setStage("executing");
-      setError(null);
-      try {
-        const results = [];
-        let currentSender = options.from;
-        for (const recipient of options.recipients) {
-          setStage("proving");
-          const txResult = await transferOnce({
-            from: currentSender,
-            to: recipient,
-            assetId: options.assetId,
-            amount: options.amount,
-            noteType: options.noteType
-          });
-          results.push(txResult);
-          currentSender = recipient;
-        }
-        setStage("complete");
-        setResult(results);
-        await sync();
-        return results;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error(String(err));
-        setError(error2);
-        setStage("idle");
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, isReady, sync, transferOnce]
+    [client, isReady, prover, signerConnected, sync]
   );
   const reset = useCallback13(() => {
     setResult(null);
@@ -2350,8 +2493,7 @@ function useInternalTransfer() {
     setError(null);
   }, []);
   return {
-    transfer,
-    transferChain,
+    sendMany,
     result,
     isLoading,
     stage,
@@ -2364,8 +2506,7 @@ function useInternalTransfer() {
 import { useCallback as useCallback14 } from "react";
 import { TransactionFilter as TransactionFilter3 } from "@miden-sdk/miden-sdk";
 function useWaitForCommit() {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const waitForCommit = useCallback14(
     async (txId, options) => {
       if (!client || !isReady) {
@@ -2378,13 +2519,9 @@ function useWaitForCommit() {
       );
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
-        await runExclusiveSafe(
-          () => client.syncState()
-        );
-        const records = await runExclusiveSafe(
-          () => client.getTransactions(
-            typeof txId === "string" ? TransactionFilter3.all() : TransactionFilter3.ids([txId])
-          )
+        await client.syncState();
+        const records = await client.getTransactions(
+          typeof txId === "string" ? TransactionFilter3.all() : TransactionFilter3.ids([txId])
         );
         const record = records.find(
           (item) => normalizeHex3(item.id().toHex()) === targetHex
@@ -2402,7 +2539,7 @@ function useWaitForCommit() {
       }
       throw new Error("Timeout waiting for transaction commit");
     },
-    [client, isReady, runExclusiveSafe]
+    [client, isReady]
   );
   return { waitForCommit };
 }
@@ -2431,11 +2568,11 @@ function useWaitForNotes() {
         await runExclusiveSafe(
           () => client.syncState()
         );
-        const notes = await runExclusiveSafe(
+        const consumable = await runExclusiveSafe(
           () => client.getConsumableNotes(accountId)
         );
-        if (notes.length >= minCount) {
-          return notes;
+        if (consumable.length >= minCount) {
+          return consumable;
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
         waited += intervalMs;
@@ -2474,7 +2611,7 @@ function useMint() {
             targetAccountIdObj,
             faucetIdObj,
             noteType,
-            options.amount
+            BigInt(options.amount)
           );
           const txId = prover ? await client.submitNewTransactionWithProver(
             faucetIdObj,
@@ -2529,8 +2666,8 @@ function useConsume() {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
-      if (options.noteIds.length === 0) {
-        throw new Error("No note IDs provided");
+      if (options.notes.length === 0) {
+        throw new Error("No notes provided");
       }
       setIsLoading(true);
       setStage("executing");
@@ -2539,16 +2676,47 @@ function useConsume() {
         const accountIdObj = parseAccountId(options.accountId);
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
-          const noteIds = options.noteIds.map(
-            (noteId) => NoteId.fromHex(noteId)
-          );
-          const filter = new NoteFilter3(NoteFilterTypes2.List, noteIds);
-          const noteRecords = await client.getInputNotes(filter);
-          const notes = noteRecords.map((record) => record.toNote());
+          const resolved = new Array(options.notes.length);
+          const lookupIndices = [];
+          const lookupIds = [];
+          for (let i = 0; i < options.notes.length; i++) {
+            const item = options.notes[i];
+            if (typeof item === "string") {
+              lookupIndices.push(i);
+              lookupIds.push(NoteId.fromHex(item));
+            } else if (item !== null && typeof item === "object" && typeof item.toNote === "function") {
+              resolved[i] = item.toNote();
+            } else if (item !== null && typeof item === "object" && typeof item.id === "function") {
+              resolved[i] = item;
+            } else {
+              lookupIndices.push(i);
+              lookupIds.push(item);
+            }
+          }
+          if (lookupIds.length > 0) {
+            const filter = new NoteFilter3(NoteFilterTypes2.List, lookupIds);
+            const noteRecords = await client.getInputNotes(filter);
+            if (noteRecords.length !== lookupIds.length) {
+              throw new Error("Some notes could not be found for provided IDs");
+            }
+            const recordById = new Map(
+              noteRecords.map((r) => [r.id().toString(), r])
+            );
+            for (let j = 0; j < lookupIndices.length; j++) {
+              const record = recordById.get(lookupIds[j].toString());
+              if (!record) {
+                throw new Error(
+                  "Some notes could not be found for provided IDs"
+                );
+              }
+              resolved[lookupIndices[j]] = record.toNote();
+            }
+          }
+          const notes = resolved;
           if (notes.length === 0) {
             throw new Error("No notes found for provided IDs");
           }
-          if (notes.length !== options.noteIds.length) {
+          if (notes.length !== options.notes.length) {
             throw new Error("Some notes could not be found for provided IDs");
           }
           const txRequest = client.newConsumeTransactionRequest(notes);
@@ -2620,9 +2788,9 @@ function useSwap() {
           const txRequest = client.newSwapTransactionRequest(
             accountIdObj,
             offeredFaucetIdObj,
-            options.offeredAmount,
+            BigInt(options.offeredAmount),
             requestedFaucetIdObj,
-            options.requestedAmount,
+            BigInt(options.requestedAmount),
             noteType,
             paybackNoteType
           );
@@ -2665,11 +2833,53 @@ function useSwap() {
 }
 
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback19, useRef as useRef5, useState as useState15 } from "react";
+import { useCallback as useCallback19, useRef as useRef6, useState as useState15 } from "react";
+
+// src/utils/transactions.ts
+import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk";
+async function waitForTransactionCommit2(client, runExclusiveSafe, txId, maxWaitMs = 1e4, delayMs = 1e3) {
+  let waited = 0;
+  while (waited < maxWaitMs) {
+    await runExclusiveSafe(() => client.syncState());
+    const [record] = await runExclusiveSafe(
+      () => client.getTransactions(TransactionFilter4.ids([txId]))
+    );
+    if (record) {
+      const status = record.transactionStatus();
+      if (status.isCommitted()) {
+        return;
+      }
+      if (status.isDiscarded()) {
+        throw new Error("Transaction was discarded before commit");
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    waited += delayMs;
+  }
+  throw new Error("Timeout waiting for transaction commit");
+}
+function extractFullNotes(txResult) {
+  try {
+    const executedTx = txResult.executedTransaction?.();
+    const notes = executedTx?.outputNotes?.().notes?.() ?? [];
+    const result = [];
+    for (const note of notes) {
+      if (note.noteType?.() === NoteType4.Private) {
+        const full = note.intoFull?.();
+        if (full) result.push(full);
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+// src/hooks/useTransaction.ts
 function useTransaction() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef5(false);
+  const isBusyRef = useRef6(false);
   const [result, setResult] = useState15(null);
   const [isLoading, setIsLoading] = useState15(false);
   const [stage, setStage] = useState15("idle");
@@ -2694,20 +2904,41 @@ function useTransaction() {
           await sync();
         }
         const txRequest = await resolveRequest(options.request, client);
-        setStage("proving");
-        const txResult = await runExclusiveSafe(async () => {
-          const accountIdObj = resolveAccountId2(options.accountId);
-          const txId = prover ? await client.submitNewTransactionWithProver(
-            accountIdObj,
-            txRequest,
-            prover
-          ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toString() };
+        const txResult = await runExclusiveSafe(() => {
+          const accountIdObj = parseAccountId(options.accountId);
+          return client.executeTransaction(accountIdObj, txRequest);
         });
+        setStage("proving");
+        const proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveSafe(
+            () => client.proveTransaction(txResult, resolvedProver)
+          ),
+          proverConfig
+        );
+        setStage("submitting");
+        const submissionHeight = await runExclusiveSafe(
+          () => client.submitProvenTransaction(provenTransaction, txResult)
+        );
+        await runExclusiveSafe(
+          () => client.applyTransaction(txResult, submissionHeight)
+        );
+        const txId = txResult.id();
+        if (options.privateNoteTarget != null) {
+          await waitForTransactionCommit2(client, runExclusiveSafe, txId);
+          const targetAddress = parseAddress(options.privateNoteTarget);
+          const fullNotes = extractFullNotes(txResult);
+          for (const note of fullNotes) {
+            await runExclusiveSafe(
+              () => client.sendPrivateNote(note, targetAddress)
+            );
+          }
+        }
+        const txSummary = { transactionId: txId.toString() };
         setStage("complete");
-        setResult(txResult);
+        setResult(txSummary);
         await sync();
-        return txResult;
+        return txSummary;
       } catch (err) {
         const error2 = err instanceof Error ? err : new Error(String(err));
         setError(error2);
@@ -2718,7 +2949,7 @@ function useTransaction() {
         isBusyRef.current = false;
       }
     },
-    [client, isReady, prover, runExclusive, sync]
+    [client, isReady, runExclusive, sync]
   );
   const reset = useCallback19(() => {
     setResult(null);
@@ -2735,9 +2966,6 @@ function useTransaction() {
     reset
   };
 }
-function resolveAccountId2(accountId) {
-  return parseAccountId(accountId);
-}
 async function resolveRequest(request, client) {
   if (typeof request === "function") {
     return await request(client);
@@ -2745,27 +2973,117 @@ async function resolveRequest(request, client) {
   return request;
 }
 
+// src/hooks/useExecuteProgram.ts
+import { useCallback as useCallback20, useRef as useRef7, useState as useState16 } from "react";
+import {
+  AdviceInputs,
+  ForeignAccount,
+  ForeignAccountArray,
+  AccountStorageRequirements
+} from "@miden-sdk/miden-sdk";
+function isForeignAccountWrapper(fa) {
+  return fa !== null && typeof fa === "object" && "id" in fa && typeof fa.id !== "function";
+}
+function useExecuteProgram() {
+  const { client, isReady, sync, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const isBusyRef = useRef7(false);
+  const [result, setResult] = useState16(null);
+  const [isLoading, setIsLoading] = useState16(false);
+  const [error, setError] = useState16(null);
+  const execute = useCallback20(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      if (isBusyRef.current) {
+        throw new MidenError(
+          "A program execution is already in progress. Await the previous call before starting another.",
+          { code: "OPERATION_BUSY" }
+        );
+      }
+      isBusyRef.current = true;
+      setIsLoading(true);
+      setError(null);
+      try {
+        if (!options.skipSync) {
+          await sync();
+        }
+        const programResult = await runExclusiveSafe(async () => {
+          const accountIdObj = parseAccountId(options.accountId);
+          const adviceInputs = options.adviceInputs ?? new AdviceInputs();
+          let foreignAccountsArray;
+          if (options.foreignAccounts?.length) {
+            const accounts = options.foreignAccounts.map((fa) => {
+              const wrapper = isForeignAccountWrapper(fa);
+              const id = parseAccountId(wrapper ? fa.id : fa);
+              const storage = wrapper && fa.storage ? fa.storage : new AccountStorageRequirements();
+              return ForeignAccount.public(id, storage);
+            });
+            foreignAccountsArray = new ForeignAccountArray(accounts);
+          } else {
+            foreignAccountsArray = new ForeignAccountArray();
+          }
+          const feltArray = await client.executeProgram(
+            accountIdObj,
+            options.script,
+            adviceInputs,
+            foreignAccountsArray
+          );
+          const stack = [];
+          const len = feltArray.length();
+          for (let i = 0; i < len; i++) {
+            stack.push(feltArray.get(i).asInt());
+          }
+          return { stack };
+        });
+        setResult(programResult);
+        return programResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+        isBusyRef.current = false;
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = useCallback20(() => {
+    setResult(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    execute,
+    result,
+    isLoading,
+    error,
+    reset
+  };
+}
+
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback20, useEffect as useEffect8, useRef as useRef6, useState as useState16 } from "react";
+import { useCallback as useCallback21, useEffect as useEffect9, useRef as useRef8, useState as useState17 } from "react";
 import { AccountStorageMode as AccountStorageMode3 } from "@miden-sdk/miden-sdk";
 function useSessionAccount(options) {
-  const { client, isReady, sync, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = useState16(null);
-  const [step, setStep] = useState16("idle");
-  const [error, setError] = useState16(null);
-  const cancelledRef = useRef6(false);
-  const isBusyRef = useRef6(false);
+  const [sessionAccountId, setSessionAccountId] = useState17(null);
+  const [step, setStep] = useState17("idle");
+  const [error, setError] = useState17(null);
+  const cancelledRef = useRef8(false);
+  const isBusyRef = useRef8(false);
   const storagePrefix = options.storagePrefix ?? "miden-session";
   const pollIntervalMs = options.pollIntervalMs ?? 3e3;
   const maxWaitMs = options.maxWaitMs ?? 6e4;
   const storageMode = options.walletOptions?.storageMode ?? "public";
   const mutable = options.walletOptions?.mutable ?? DEFAULTS.WALLET_MUTABLE;
   const authScheme = options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME;
-  const fundRef = useRef6(options.fund);
+  const fundRef = useRef8(options.fund);
   fundRef.current = options.fund;
-  useEffect8(() => {
+  useEffect9(() => {
     try {
       const stored = localStorage.getItem(`${storagePrefix}:accountId`);
       const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
@@ -2782,7 +3100,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback20(async () => {
+  const initialize = useCallback21(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -2800,17 +3118,14 @@ function useSessionAccount(options) {
       if (!walletId) {
         setStep("creating");
         const resolvedStorageMode = getStorageMode3(storageMode);
-        const wallet = await runExclusiveSafe(async () => {
-          const w = await client.newWallet(
-            resolvedStorageMode,
-            mutable,
-            authScheme
-          );
-          ensureAccountBech32(w);
-          const accounts = await client.getAccounts();
-          setAccounts(accounts);
-          return w;
-        });
+        const wallet = await client.newWallet(
+          resolvedStorageMode,
+          mutable,
+          authScheme
+        );
+        ensureAccountBech32(wallet);
+        const accounts = await client.getAccounts();
+        setAccounts(accounts);
         if (cancelledRef.current) return;
         walletId = wallet.id().toString();
         setSessionAccountId(walletId);
@@ -2822,7 +3137,6 @@ function useSessionAccount(options) {
       setStep("consuming");
       await waitAndConsume(
         client,
-        runExclusiveSafe,
         walletId,
         pollIntervalMs,
         maxWaitMs,
@@ -2846,7 +3160,6 @@ function useSessionAccount(options) {
     client,
     isReady,
     sync,
-    runExclusiveSafe,
     sessionAccountId,
     storageMode,
     mutable,
@@ -2856,7 +3169,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback20(() => {
+  const reset = useCallback21(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -2884,30 +3197,202 @@ function getStorageMode3(mode) {
       return AccountStorageMode3.public();
   }
 }
-async function waitAndConsume(client, runExclusiveSafe, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
+async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
   const deadline = Date.now() + maxWaitMs;
   while (Date.now() < deadline) {
     if (cancelledRef.current) return;
-    await runExclusiveSafe(
-      () => client.syncState()
-    );
+    await client.syncState();
     if (cancelledRef.current) return;
-    const consumed = await runExclusiveSafe(async () => {
-      const accountIdObj = parseAccountId(walletId);
-      const consumable = await client.getConsumableNotes(accountIdObj);
-      if (consumable.length === 0) return false;
+    const accountIdObj = parseAccountId(walletId);
+    const consumable = await client.getConsumableNotes(accountIdObj);
+    if (consumable.length > 0) {
       const notes = consumable.map((c) => c.inputNoteRecord().toNote());
       const txRequest = client.newConsumeTransactionRequest(notes);
       const freshAccountId = parseAccountId(walletId);
       await client.submitNewTransaction(freshAccountId, txRequest);
-      return true;
-    });
-    if (consumed) return;
+      return;
+    }
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
   }
   throw new Error("Timeout waiting for session wallet funding");
 }
 
+// src/hooks/useExportStore.ts
+import { useCallback as useCallback22, useState as useState18 } from "react";
+import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk";
+function useExportStore() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = useState18(false);
+  const [error, setError] = useState18(null);
+  const exportStore = useCallback22(async () => {
+    if (!client || !isReady) {
+      throw new Error("Miden client is not ready");
+    }
+    setIsExporting(true);
+    setError(null);
+    try {
+      const storeName = client.storeIdentifier();
+      const snapshot = await runExclusive(() => sdkExportStore(storeName));
+      return snapshot;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsExporting(false);
+    }
+  }, [client, isReady, runExclusive]);
+  const reset = useCallback22(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportStore,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportStore.ts
+import { useCallback as useCallback23, useState as useState19 } from "react";
+import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk";
+function useImportStore() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = useState19(false);
+  const [error, setError] = useState19(null);
+  const importStore = useCallback23(
+    async (storeDump, storeName, options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        await runExclusive(() => sdkImportStore(storeName, storeDump));
+        if (!options?.skipSync) {
+          await sync();
+        }
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = useCallback23(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importStore,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportNote.ts
+import { useCallback as useCallback24, useState as useState20 } from "react";
+import { NoteFile } from "@miden-sdk/miden-sdk";
+function useImportNote() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = useState20(false);
+  const [error, setError] = useState20(null);
+  const importNote = useCallback24(
+    async (noteBytes) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        const noteFile = NoteFile.deserialize(noteBytes);
+        const noteId = await runExclusive(
+          () => client.importNoteFile(noteFile)
+        );
+        await sync();
+        return noteId.toString();
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = useCallback24(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importNote,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useExportNote.ts
+import { useCallback as useCallback25, useState as useState21 } from "react";
+import { NoteExportFormat } from "@miden-sdk/miden-sdk";
+function useExportNote() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = useState21(false);
+  const [error, setError] = useState21(null);
+  const exportNote = useCallback25(
+    async (noteId) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsExporting(true);
+      setError(null);
+      try {
+        const noteFile = await runExclusive(
+          () => client.exportNoteFile(noteId, NoteExportFormat.Full)
+        );
+        return noteFile.serialize();
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsExporting(false);
+      }
+    },
+    [client, isReady, runExclusive]
+  );
+  const reset = useCallback25(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportNote,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSyncControl.ts
+import { useCallback as useCallback26 } from "react";
+function useSyncControl() {
+  const isPaused = useMidenStore((state) => state.syncPaused);
+  const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
+  const pauseSync = useCallback26(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback26(() => setSyncPaused(false), [setSyncPaused]);
+  return {
+    pauseSync,
+    resumeSync,
+    isPaused
+  };
+}
+
 // src/utils/bytes.ts
 function bytesToBigInt(bytes) {
   let result = 0n;
@@ -3058,10 +3543,13 @@ function createMidenStorage(prefix) {
 // src/index.ts
 installAccountBech32();
 export {
+  AuthScheme,
   DEFAULTS,
   MidenError,
   MidenProvider,
+  MultiSignerProvider,
   SignerContext,
+  SignerSlot,
   accountIdsEqual,
   bigIntToBytes,
   bytesToBigInt,
@@ -3083,18 +3571,24 @@ export {
   useConsume,
   useCreateFaucet,
   useCreateWallet,
+  useExecuteProgram,
+  useExportNote,
+  useExportStore,
   useImportAccount,
-  useInternalTransfer,
+  useImportNote,
+  useImportStore,
   useMiden,
   useMidenClient,
   useMint,
   useMultiSend,
+  useMultiSigner,
   useNoteStream,
   useNotes,
   useSend,
   useSessionAccount,
   useSigner,
   useSwap,
+  useSyncControl,
   useSyncState,
   useTransaction,
   useTransactionHistory,