@miden-sdk/react 0.13.3 → 0.14.0

package/dist/index.js

@@ -30,10 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthScheme: () => import_miden_sdk4.AuthScheme,
   DEFAULTS: () => DEFAULTS,
   MidenError: () => MidenError,
   MidenProvider: () => MidenProvider,
+  MultiSignerProvider: () => MultiSignerProvider,
   SignerContext: () => SignerContext,
+  SignerSlot: () => SignerSlot,
   accountIdsEqual: () => accountIdsEqual,
   bigIntToBytes: () => bigIntToBytes,
   bytesToBigInt: () => bytesToBigInt,
@@ -55,18 +58,24 @@ __export(index_exports, {
   useConsume: () => useConsume,
   useCreateFaucet: () => useCreateFaucet,
   useCreateWallet: () => useCreateWallet,
+  useExecuteProgram: () => useExecuteProgram,
+  useExportNote: () => useExportNote,
+  useExportStore: () => useExportStore,
   useImportAccount: () => useImportAccount,
-  useInternalTransfer: () => useInternalTransfer,
+  useImportNote: () => useImportNote,
+  useImportStore: () => useImportStore,
   useMiden: () => useMiden,
   useMidenClient: () => useMidenClient,
   useMint: () => useMint,
   useMultiSend: () => useMultiSend,
+  useMultiSigner: () => useMultiSigner,
   useNoteStream: () => useNoteStream,
   useNotes: () => useNotes,
   useSend: () => useSend,
   useSessionAccount: () => useSessionAccount,
   useSigner: () => useSigner,
   useSwap: () => useSwap,
+  useSyncControl: () => useSyncControl,
   useSyncState: () => useSyncState,
   useTransaction: () => useTransaction,
   useTransactionHistory: () => useTransactionHistory,
@@ -91,24 +100,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 = (0, import_zustand.create)()((set) => ({
-  ...initialState,
+  ...freshState(),
   setClient: (client) => set({
     client,
     isReady: client !== null,
@@ -122,9 +140,11 @@ var useMidenStore = (0, import_zustand.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);
@@ -206,7 +226,8 @@ var useMidenStore = (0, import_zustand.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);
@@ -231,11 +252,13 @@ var parseAccountIdFromString = (value) => {
   return import_miden_sdk2.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 {
@@ -251,6 +274,10 @@ function isFaucetId(accountId) {
   }
 }
 var parseAddress = (value, accountId) => {
+  if (typeof value !== "string") {
+    const resolvedId = accountId ?? parseAccountId(value);
+    return import_miden_sdk2.Address.fromAccountId(resolvedId, "BasicWallet");
+  }
   const normalized = normalizeAccountIdInput(value);
   if (isBech32Input(normalized)) {
     try {
@@ -354,16 +381,17 @@ var toBech32AccountId = (accountId) => {
 
 // src/context/MidenProvider.tsx
 var import_react2 = require("react");
-var import_miden_sdk5 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk6 = require("@miden-sdk/miden-sdk");
 
 // src/types/index.ts
+var import_miden_sdk4 = require("@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: import_miden_sdk4.AuthScheme.AuthRpoFalcon512,
   NOTE_TYPE: "private",
   FAUCET_DECIMALS: 8
 };
@@ -407,7 +435,7 @@ function resolveRpcUrl(rpcUrl) {
 }
 
 // src/utils/prover.ts
-var import_miden_sdk4 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk5 = require("@miden-sdk/miden-sdk");
 var DEFAULT_PROVER_URLS = {
   devnet: "https://tx-prover.devnet.miden.io",
   testnet: "https://tx-prover.testnet.miden.io"
@@ -417,34 +445,60 @@ function resolveTransactionProver(config) {
   if (!prover) {
     return null;
   }
-  if (typeof prover === "string") {
-    const normalized = prover.trim().toLowerCase();
-    if (normalized === "local") {
-      return import_miden_sdk4.TransactionProver.newLocalProver();
+  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 import_miden_sdk5.TransactionProver.newLocalProver();
     }
     if (normalized === "devnet" || normalized === "testnet") {
       const url = config.proverUrls?.[normalized] ?? DEFAULT_PROVER_URLS[normalized] ?? null;
       if (!url) {
         throw new Error(`Missing ${normalized} prover URL`);
       }
-      return import_miden_sdk4.TransactionProver.newRemoteProver(
+      return import_miden_sdk5.TransactionProver.newRemoteProver(
         url,
         normalizeTimeout(config.proverTimeoutMs)
       );
     }
-    return import_miden_sdk4.TransactionProver.newRemoteProver(
-      prover,
+    return import_miden_sdk5.TransactionProver.newRemoteProver(
+      target,
       normalizeTimeout(config.proverTimeoutMs)
     );
   }
-  return createRemoteProver(prover, config.proverTimeoutMs);
+  return createRemoteProver(target, config.proverTimeoutMs);
 }
 function createRemoteProver(config, fallbackTimeout) {
   const { url, timeoutMs } = config;
   if (!url) {
     throw new Error("Remote prover requires a URL");
   }
-  return import_miden_sdk4.TransactionProver.newRemoteProver(
+  return import_miden_sdk5.TransactionProver.newRemoteProver(
     url,
     normalizeTimeout(timeoutMs ?? fallbackTimeout)
   );
@@ -467,35 +521,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) {
@@ -546,15 +606,19 @@ function MidenProvider({
     isReady,
     isInitializing,
     initError,
+    signerConnected,
     setClient,
     setInitializing,
     setInitError,
     setConfig,
-    setSyncState
+    setSyncState,
+    setSignerConnected
   } = useMidenStore();
   const syncIntervalRef = (0, import_react2.useRef)(null);
   const isInitializedRef = (0, import_react2.useRef)(false);
   const clientLockRef = (0, import_react2.useRef)(new AsyncLock());
+  const currentStoreNameRef = (0, import_react2.useRef)(null);
+  const signCbRef = (0, import_react2.useRef)(null);
   const signerContext = useSigner();
   const [signerAccountId, setSignerAccountId] = (0, import_react2.useState)(null);
   const resolvedConfig = (0, import_react2.useMemo)(
@@ -582,35 +646,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;
+  (0, import_react2.useEffect)(() => {
+    signCbRef.current = signerContext?.signCb ?? null;
+  }, [signerContext?.signCb]);
+  const wrappedSignCb = (0, import_react2.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);
+    },
+    []
+  );
   (0, import_react2.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 () => {
@@ -621,18 +712,17 @@ function MidenProvider({
         try {
           let webClient;
           let didSignerInit = false;
-          if (signerContext && signerContext.isConnected) {
+          if (signerContext && signerIsConnected === true) {
             const storeName = `MidenClientDB_${signerContext.storeName}`;
-            webClient = await import_miden_sdk5.WebClient.createClientWithExternalKeystore(
+            signCbRef.current = signerContext.signCb;
+            webClient = await import_miden_sdk6.WasmWebClient.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(
@@ -642,9 +732,10 @@ function MidenProvider({
             if (cancelled) return;
             setSignerAccountId(accountId);
             didSignerInit = true;
+            currentStoreNameRef.current = signerContext.storeName;
           } else {
             const seed = resolvedConfig.seed;
-            webClient = await import_miden_sdk5.WebClient.createClient(
+            webClient = await import_miden_sdk6.WasmWebClient.createClient(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               seed
@@ -675,6 +766,9 @@ function MidenProvider({
               isInitializedRef.current = true;
             }
             setClient(webClient);
+            if (signerIsConnected === true) {
+              setSignerConnected(true);
+            }
           }
         } catch (error) {
           if (!cancelled) {
@@ -698,14 +792,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.
   ]);
   (0, import_react2.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) {
@@ -714,6 +820,20 @@ function MidenProvider({
       }
     };
   }, [isReady, client, config.autoSyncInterval, sync]);
+  (0, import_react2.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__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: loadingComponent });
   }
@@ -731,7 +851,8 @@ function MidenProvider({
     sync,
     runExclusive,
     prover: defaultProver,
-    signerAccountId
+    signerAccountId,
+    signerConnected
   };
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MidenContext.Provider, { value: contextValue, children });
 }
@@ -752,35 +873,183 @@ function useMidenClient() {
   return client;
 }
 
-// src/hooks/useAccounts.ts
+// src/context/MultiSignerProvider.tsx
 var import_react3 = require("react");
-
-// src/utils/runExclusive.ts
-var runExclusiveDirect = async (fn) => fn();
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var MultiSignerRegistryContext = (0, import_react3.createContext)(null);
+var MultiSignerContext = (0, import_react3.createContext)(null);
+function MultiSignerProvider({ children }) {
+  const signersRef = (0, import_react3.useRef)(/* @__PURE__ */ new Map());
+  const [signersSnapshot, setSignersSnapshot] = (0, import_react3.useState)(
+    []
+  );
+  const [activeSignerName, setActiveSignerName] = (0, import_react3.useState)(null);
+  const activeSignerNameRef = (0, import_react3.useRef)(null);
+  const generationRef = (0, import_react3.useRef)(0);
+  const updateSnapshot = (0, import_react3.useCallback)(() => {
+    setSignersSnapshot(Array.from(signersRef.current.values()));
+  }, []);
+  const register = (0, import_react3.useCallback)(
+    (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 = (0, import_react3.useCallback)(
+    (name) => {
+      signersRef.current.delete(name);
+      setActiveSignerName((current) => current === name ? null : current);
+      updateSnapshot();
+    },
+    [updateSnapshot]
+  );
+  const registry = (0, import_react3.useMemo)(
+    () => ({ register, unregister }),
+    [register, unregister]
+  );
+  const activeSigner = activeSignerName ? signersSnapshot.find((s) => s.name === activeSignerName) ?? null : null;
+  const stableSignCb = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(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 = (0, import_react3.useCallback)(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 = (0, import_react3.useMemo)(() => {
+    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 = (0, import_react3.useCallback)((name) => {
+    activeSignerNameRef.current = name;
+    setActiveSignerName(name);
+  }, []);
+  const connectSigner = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(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 = (0, import_react3.useMemo)(
+    () => ({
+      signers: signersSnapshot,
+      activeSigner,
+      connectSigner,
+      disconnectSigner
+    }),
+    [signersSnapshot, activeSigner, connectSigner, disconnectSigner]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SignerContext.Provider, { value: forwardedValue, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerRegistryContext.Provider, { value: registry, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerContext.Provider, { value: multiSignerValue, children }) }) });
+}
+function SignerSlot() {
+  const signerValue = useSigner();
+  const registry = (0, import_react3.useContext)(MultiSignerRegistryContext);
+  const nameRef = (0, import_react3.useRef)();
+  (0, import_react3.useEffect)(() => {
+    if (!signerValue || !registry) return;
+    nameRef.current = signerValue.name;
+    registry.register(signerValue);
+  }, [signerValue, registry]);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (nameRef.current && registry) {
+        registry.unregister(nameRef.current);
+      }
+    };
+  }, [registry]);
+  return null;
+}
+function useMultiSigner() {
+  return (0, import_react3.useContext)(MultiSignerContext);
+}
 
 // src/hooks/useAccounts.ts
+var import_react4 = require("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 = (0, import_react3.useCallback)(async () => {
+  const refetch = (0, import_react4.useCallback)(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]);
-  (0, import_react3.useEffect)(() => {
+  }, [client, isReady, setAccounts, setLoadingAccounts]);
+  (0, import_react4.useEffect)(() => {
     if (isReady && accounts.length === 0) {
       refetch();
     }
@@ -806,11 +1075,11 @@ function useAccounts() {
 }
 
 // src/hooks/useAccount.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 
 // src/hooks/useAssetMetadata.ts
-var import_react4 = require("react");
-var import_miden_sdk6 = require("@miden-sdk/miden-sdk");
+var import_react5 = require("react");
+var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
 var inflight = /* @__PURE__ */ new Map();
 var rpcClients = /* @__PURE__ */ new Map();
 var getRpcClient = (rpcUrl) => {
@@ -818,8 +1087,8 @@ var getRpcClient = (rpcUrl) => {
   const existing = rpcClients.get(key);
   if (existing) return existing;
   try {
-    const endpoint = rpcUrl ? new import_miden_sdk6.Endpoint(rpcUrl) : import_miden_sdk6.Endpoint.testnet();
-    const client = new import_miden_sdk6.RpcClient(endpoint);
+    const endpoint = rpcUrl ? new import_miden_sdk7.Endpoint(rpcUrl) : import_miden_sdk7.Endpoint.testnet();
+    const client = new import_miden_sdk7.RpcClient(endpoint);
     rpcClients.set(key, client);
     return client;
   } catch {
@@ -833,7 +1102,7 @@ var fetchAssetMetadata = async (rpcClient, assetId) => {
     const fetched = await rpcClient.getAccountDetails(accountId);
     const account = fetched.account?.();
     if (!account) return null;
-    const faucet = import_miden_sdk6.BasicFungibleFaucetComponent.fromAccount(account);
+    const faucet = import_miden_sdk7.BasicFungibleFaucetComponent.fromAccount(account);
     const symbol = faucet.symbol().toString();
     const decimals = faucet.decimals();
     return { assetId, symbol, decimals };
@@ -845,12 +1114,12 @@ function useAssetMetadata(assetIds = []) {
   const assetMetadata = useAssetMetadataStore();
   const setAssetMetadata = useMidenStore((state) => state.setAssetMetadata);
   const rpcUrl = useMidenStore((state) => state.config.rpcUrl);
-  const rpcClient = (0, import_react4.useMemo)(() => getRpcClient(rpcUrl), [rpcUrl]);
-  const uniqueAssetIds = (0, import_react4.useMemo)(
+  const rpcClient = (0, import_react5.useMemo)(() => getRpcClient(rpcUrl), [rpcUrl]);
+  const uniqueAssetIds = (0, import_react5.useMemo)(
     () => Array.from(new Set(assetIds.filter(Boolean))),
     [assetIds]
   );
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (!rpcClient || uniqueAssetIds.length === 0) return;
     uniqueAssetIds.forEach((assetId) => {
       const existing = assetMetadata.get(assetId);
@@ -869,31 +1138,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] = (0, import_react5.useState)(false);
-  const [error, setError] = (0, import_react5.useState)(null);
-  const accountIdStr = (0, import_react5.useMemo)(() => {
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const accountIdStr = (0, import_react6.useMemo)(() => {
     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 = (0, import_react5.useCallback)(async () => {
+  const refetch = (0, import_react6.useCallback)(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);
@@ -903,17 +1166,17 @@ function useAccount(accountId) {
     } finally {
       setIsLoading(false);
     }
-  }, [client, isReady, runExclusive, accountIdStr, setAccountDetails]);
-  (0, import_react5.useEffect)(() => {
+  }, [client, isReady, accountIdStr, setAccountDetails]);
+  (0, import_react6.useEffect)(() => {
     if (isReady && accountIdStr && !account) {
       refetch();
     }
   }, [isReady, accountIdStr, account, refetch]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (!isReady || !accountIdStr || !lastSyncTime) return;
     refetch();
   }, [isReady, accountIdStr, lastSyncTime, refetch]);
-  const rawAssets = (0, import_react5.useMemo)(() => {
+  const rawAssets = (0, import_react6.useMemo)(() => {
     if (!account) return [];
     try {
       const vault = account.vault();
@@ -930,12 +1193,12 @@ function useAccount(accountId) {
       return [];
     }
   }, [account]);
-  const assetIds = (0, import_react5.useMemo)(
+  const assetIds = (0, import_react6.useMemo)(
     () => rawAssets.map((asset) => asset.assetId),
     [rawAssets]
   );
   const { assetMetadata } = useAssetMetadata(assetIds);
-  const assets = (0, import_react5.useMemo)(
+  const assets = (0, import_react6.useMemo)(
     () => rawAssets.map((asset) => {
       const metadata = assetMetadata.get(asset.assetId);
       return {
@@ -946,7 +1209,7 @@ function useAccount(accountId) {
     }),
     [rawAssets, assetMetadata]
   );
-  const getBalance = (0, import_react5.useCallback)(
+  const getBalance = (0, import_react6.useCallback)(
     (assetId) => {
       const asset = assets.find((a) => a.assetId === assetId);
       return asset?.amount ?? 0n;
@@ -964,17 +1227,18 @@ function useAccount(accountId) {
 }
 
 // src/hooks/useNotes.ts
-var import_react6 = require("react");
-var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
+var import_react7 = require("react");
+var import_miden_sdk9 = require("@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,30 +1333,30 @@ function accountIdsEqual(a, b) {
 }
 
 // src/utils/noteFilters.ts
-var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
 function getNoteFilterType(status) {
   switch (status) {
     case "consumed":
-      return import_miden_sdk7.NoteFilterTypes.Consumed;
+      return import_miden_sdk8.NoteFilterTypes.Consumed;
     case "committed":
-      return import_miden_sdk7.NoteFilterTypes.Committed;
+      return import_miden_sdk8.NoteFilterTypes.Committed;
     case "expected":
-      return import_miden_sdk7.NoteFilterTypes.Expected;
+      return import_miden_sdk8.NoteFilterTypes.Expected;
     case "processing":
-      return import_miden_sdk7.NoteFilterTypes.Processing;
+      return import_miden_sdk8.NoteFilterTypes.Processing;
     case "all":
     default:
-      return import_miden_sdk7.NoteFilterTypes.All;
+      return import_miden_sdk8.NoteFilterTypes.All;
   }
 }
 function getNoteType(type) {
   switch (type) {
     case "private":
-      return import_miden_sdk7.NoteType.Private;
+      return import_miden_sdk8.NoteType.Private;
     case "public":
-      return import_miden_sdk7.NoteType.Public;
+      return import_miden_sdk8.NoteType.Public;
     default:
-      return import_miden_sdk7.NoteType.Private;
+      return import_miden_sdk8.NoteType.Private;
   }
 }
 async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWaitMs = 1e4, delayMs = 1e3) {
@@ -1101,7 +1365,7 @@ async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWa
   while (Date.now() < deadline) {
     await runExclusiveSafe(() => client.syncState());
     const records = await runExclusiveSafe(
-      () => client.getTransactions(import_miden_sdk7.TransactionFilter.all())
+      () => client.getTransactions(import_miden_sdk8.TransactionFilter.all())
     );
     const record = records.find(
       (r) => normalizeHex(r.id().toHex()) === targetHex
@@ -1127,8 +1391,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);
@@ -1138,30 +1401,22 @@ function useNotes(options) {
     (state) => state.setConsumableNotesIfChanged
   );
   const { lastSyncTime } = useSyncStateStore();
-  const [error, setError] = (0, import_react6.useState)(null);
-  const refetch = (0, import_react6.useCallback)(async () => {
+  const [error, setError] = (0, import_react7.useState)(null);
+  const refetch = (0, import_react7.useCallback)(async () => {
     if (!client || !isReady) return;
     setLoadingNotes(true);
     setError(null);
     try {
-      const { fetchedNotes, fetchedConsumable } = await runExclusiveSafe(
-        async () => {
-          const filterType = getNoteFilterType(options?.status);
-          const filter = new import_miden_sdk8.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 import_miden_sdk9.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) {
@@ -1172,23 +1427,22 @@ function useNotes(options) {
   }, [
     client,
     isReady,
-    runExclusive,
     options?.status,
     options?.accountId,
     setLoadingNotes,
     setNotesIfChanged,
     setConsumableNotesIfChanged
   ]);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (isReady && notes.length === 0) {
       refetch();
     }
   }, [isReady, notes.length, refetch]);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (!isReady || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refetch]);
-  const noteAssetIds = (0, import_react6.useMemo)(() => {
+  const noteAssetIds = (0, import_react7.useMemo)(() => {
     const ids = /* @__PURE__ */ new Set();
     const collect = (note) => {
       const summary = getNoteSummary(note);
@@ -1200,11 +1454,11 @@ function useNotes(options) {
     return Array.from(ids);
   }, [notes, consumableNotes]);
   const { assetMetadata } = useAssetMetadata(noteAssetIds);
-  const getMetadata = (0, import_react6.useCallback)(
+  const getMetadata = (0, import_react7.useCallback)(
     (assetId) => assetMetadata.get(assetId),
     [assetMetadata]
   );
-  const normalizedSender = (0, import_react6.useMemo)(() => {
+  const normalizedSender = (0, import_react7.useMemo)(() => {
     if (!options?.sender) return null;
     try {
       return normalizeAccountId(options.sender);
@@ -1212,11 +1466,11 @@ function useNotes(options) {
       return options.sender;
     }
   }, [options?.sender]);
-  const excludeIdsKey = (0, import_react6.useMemo)(() => {
+  const excludeIdsKey = (0, import_react7.useMemo)(() => {
     if (!options?.excludeIds || options.excludeIds.length === 0) return "";
     return [...options.excludeIds].sort().join("\0");
   }, [options?.excludeIds]);
-  const filterBySender = (0, import_react6.useCallback)(
+  const filterBySender = (0, import_react7.useCallback)(
     (summaries, target) => {
       const cache = /* @__PURE__ */ new Map();
       return summaries.filter((s) => {
@@ -1235,7 +1489,7 @@ function useNotes(options) {
     },
     []
   );
-  const noteSummaries = (0, import_react6.useMemo)(() => {
+  const noteSummaries = (0, import_react7.useMemo)(() => {
     let summaries = notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1246,7 +1500,7 @@ function useNotes(options) {
     }
     return summaries;
   }, [notes, getMetadata, normalizedSender, excludeIdsKey, filterBySender]);
-  const consumableNoteSummaries = (0, import_react6.useMemo)(() => {
+  const consumableNoteSummaries = (0, import_react7.useMemo)(() => {
     let summaries = consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1275,11 +1529,11 @@ function useNotes(options) {
 }
 
 // src/hooks/useNoteStream.ts
-var import_react7 = require("react");
-var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
+var import_react8 = require("react");
+var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
 
 // src/utils/noteAttachment.ts
-var import_miden_sdk9 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
 function readNoteAttachment(note) {
   try {
     const metadata = note.metadata?.();
@@ -1288,8 +1542,8 @@ function readNoteAttachment(note) {
     if (!attachment) return null;
     const kind = attachment.kind?.();
     if (!kind) return null;
-    if (kind === import_miden_sdk9.NoteAttachmentKind.None) return null;
-    if (kind === import_miden_sdk9.NoteAttachmentKind.Word) {
+    if (kind === import_miden_sdk10.NoteAttachmentKind.None) return null;
+    if (kind === import_miden_sdk10.NoteAttachmentKind.Word) {
       const word = attachment.asWord?.();
       if (!word) return null;
       const u64s = word.toU64s();
@@ -1298,7 +1552,7 @@ function readNoteAttachment(note) {
       );
       return { values, kind: "word" };
     }
-    if (kind === import_miden_sdk9.NoteAttachmentKind.Array) {
+    if (kind === import_miden_sdk10.NoteAttachmentKind.Array) {
       const arr = attachment.asArray?.();
       if (!arr) return null;
       const u64s = arr.toU64s();
@@ -1318,82 +1572,79 @@ function createNoteAttachment(values) {
     bigints.push(BigInt(values[i]));
   }
   if (bigints.length === 0) {
-    return new import_miden_sdk9.NoteAttachment();
+    return new import_miden_sdk10.NoteAttachment();
   }
-  const scheme = import_miden_sdk9.NoteAttachmentScheme.none();
+  const scheme = import_miden_sdk10.NoteAttachmentScheme.none();
   if (bigints.length <= 4) {
     while (bigints.length < 4) {
       bigints.push(0n);
     }
-    const word = new import_miden_sdk9.Word(BigUint64Array.from(bigints));
-    return import_miden_sdk9.NoteAttachment.newWord(scheme, word);
+    const word = new import_miden_sdk10.Word(BigUint64Array.from(bigints));
+    return import_miden_sdk10.NoteAttachment.newWord(scheme, word);
   }
   while (bigints.length % 4 !== 0) {
     bigints.push(0n);
   }
   const words = [];
   for (let i = 0; i < bigints.length; i += 4) {
-    words.push(new import_miden_sdk9.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
+    words.push(new import_miden_sdk10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
   }
-  const newArray = import_miden_sdk9.NoteAttachment["newArray"];
+  const newArray = import_miden_sdk10.NoteAttachment["newArray"];
   if (typeof newArray !== "function") {
     throw new Error(
       "NoteAttachment.newArray is not available. Ensure @miden-sdk/miden-sdk >= 0.13.1."
     );
   }
-  return newArray.call(import_miden_sdk9.NoteAttachment, scheme, words);
+  return newArray.call(import_miden_sdk10.NoteAttachment, scheme, words);
 }
 
 // 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] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)(null);
-  const handledIdsRef = (0, import_react7.useRef)(/* @__PURE__ */ new Set());
-  const [handledVersion, setHandledVersion] = (0, import_react7.useState)(0);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const handledIdsRef = (0, import_react8.useRef)(/* @__PURE__ */ new Set());
+  const [handledVersion, setHandledVersion] = (0, import_react8.useState)(0);
   const status = options.status ?? "committed";
   const sender = options.sender ?? null;
   const since = options.since;
-  const amountFilterRef = (0, import_react7.useRef)(options.amountFilter);
+  const amountFilterRef = (0, import_react8.useRef)(options.amountFilter);
   amountFilterRef.current = options.amountFilter;
-  const excludeIdsKey = (0, import_react7.useMemo)(() => {
+  const excludeIdsKey = (0, import_react8.useMemo)(() => {
     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 = (0, import_react7.useMemo)(() => {
+  const excludeIdSet = (0, import_react8.useMemo)(() => {
     if (!excludeIdsKey) return null;
     return new Set(excludeIdsKey.split("\0"));
   }, [excludeIdsKey]);
-  const refetch = (0, import_react7.useCallback)(async () => {
+  const refetch = (0, import_react8.useCallback)(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
     try {
       const filterType = getNoteFilterType(status);
-      const filter = new import_miden_sdk10.NoteFilter(filterType);
-      const fetched = await runExclusiveSafe(
-        () => client.getInputNotes(filter)
-      );
+      const filter = new import_miden_sdk11.NoteFilter(filterType);
+      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]);
-  (0, import_react7.useEffect)(() => {
+  }, [client, isReady, status, setNotesIfChanged]);
+  (0, import_react8.useEffect)(() => {
     if (isReady) {
       refetch();
     }
   }, [isReady, lastSyncTime, refetch]);
-  const streamedNotes = (0, import_react7.useMemo)(() => {
+  const streamedNotes = (0, import_react8.useMemo)(() => {
     void handledVersion;
     const result = [];
     let normalizedSender = null;
@@ -1418,15 +1669,15 @@ function useNoteStream(options = {}) {
     result.sort((a, b) => a.firstSeenAt - b.firstSeenAt);
     return result;
   }, [allNotes, noteFirstSeen, excludeIdSet, sender, since, handledVersion]);
-  const latest = (0, import_react7.useMemo)(
+  const latest = (0, import_react8.useMemo)(
     () => streamedNotes.length > 0 ? streamedNotes[streamedNotes.length - 1] : null,
     [streamedNotes]
   );
-  const markHandled = (0, import_react7.useCallback)((noteId) => {
+  const markHandled = (0, import_react8.useCallback)((noteId) => {
     handledIdsRef.current = new Set(handledIdsRef.current).add(noteId);
     setHandledVersion((v) => v + 1);
   }, []);
-  const markAllHandled = (0, import_react7.useCallback)(() => {
+  const markAllHandled = (0, import_react8.useCallback)(() => {
     const newSet = new Set(handledIdsRef.current);
     for (const note of streamedNotes) {
       newSet.add(note.id);
@@ -1434,7 +1685,7 @@ function useNoteStream(options = {}) {
     handledIdsRef.current = newSet;
     setHandledVersion((v) => v + 1);
   }, [streamedNotes]);
-  const snapshot = (0, import_react7.useCallback)(() => {
+  const snapshot = (0, import_react8.useCallback)(() => {
     const ids = /* @__PURE__ */ new Set();
     for (const note of streamedNotes) {
       ids.add(note.id);
@@ -1490,21 +1741,20 @@ function buildStreamedNote(record, noteFirstSeen) {
 }
 
 // src/hooks/useTransactionHistory.ts
-var import_react8 = require("react");
-var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
+var import_react9 = require("react");
+var import_miden_sdk12 = require("@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] = (0, import_react8.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const rawIds = (0, import_react8.useMemo)(() => {
+  const [records, setRecords] = (0, import_react9.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const rawIds = (0, import_react9.useMemo)(() => {
     if (options.id) return [options.id];
     if (options.ids && options.ids.length > 0) return options.ids;
     return null;
   }, [options.id, options.ids]);
-  const idsHex = (0, import_react8.useMemo)(() => {
+  const idsHex = (0, import_react9.useMemo)(() => {
     if (!rawIds) return null;
     return rawIds.map(
       (id) => normalizeHex2(typeof id === "string" ? id : id.toHex())
@@ -1512,7 +1762,7 @@ function useTransactionHistory(options = {}) {
   }, [rawIds]);
   const filter = options.filter;
   const refreshOnSync = options.refreshOnSync !== false;
-  const refetch = (0, import_react8.useCallback)(async () => {
+  const refetch = (0, import_react9.useCallback)(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
@@ -1522,9 +1772,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;
@@ -1534,20 +1782,20 @@ function useTransactionHistory(options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [client, isReady, runExclusiveSafe, filter, rawIds, idsHex]);
-  (0, import_react8.useEffect)(() => {
+  }, [client, isReady, filter, rawIds, idsHex]);
+  (0, import_react9.useEffect)(() => {
     if (!isReady) return;
     refetch();
   }, [isReady, refetch]);
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     if (!isReady || !refreshOnSync || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refreshOnSync, refetch]);
-  const record = (0, import_react8.useMemo)(() => {
+  const record = (0, import_react9.useMemo)(() => {
     if (!idsHex || idsHex.length !== 1) return null;
     return records.find((item) => normalizeHex2(item.id().toHex()) === idsHex[0]) ?? null;
   }, [records, idsHex]);
-  const status = (0, import_react8.useMemo)(() => {
+  const status = (0, import_react9.useMemo)(() => {
     if (!record) return null;
     const current = record.transactionStatus();
     if (current.isCommitted()) return "committed";
@@ -1569,14 +1817,14 @@ function buildFilter(filter, ids, idsHex) {
     return { filter };
   }
   if (!ids || ids.length === 0) {
-    return { filter: import_miden_sdk11.TransactionFilter.all() };
+    return { filter: import_miden_sdk12.TransactionFilter.all() };
   }
   const allTransactionIds = ids.every((id) => typeof id !== "string");
   if (allTransactionIds) {
-    return { filter: import_miden_sdk11.TransactionFilter.ids(ids) };
+    return { filter: import_miden_sdk12.TransactionFilter.ids(ids) };
   }
   return {
-    filter: import_miden_sdk11.TransactionFilter.all(),
+    filter: import_miden_sdk12.TransactionFilter.all(),
     localFilterHexes: idsHex ?? []
   };
 }
@@ -1587,11 +1835,11 @@ function normalizeHex2(value) {
 }
 
 // src/hooks/useSyncState.ts
-var import_react9 = require("react");
+var import_react10 = require("react");
 function useSyncState() {
   const { sync: triggerSync } = useMiden();
   const syncState = useSyncStateStore();
-  const sync = (0, import_react9.useCallback)(async () => {
+  const sync = (0, import_react10.useCallback)(async () => {
     await triggerSync();
   }, [triggerSync]);
   return {
@@ -1601,21 +1849,25 @@ function useSyncState() {
 }
 
 // src/hooks/useCreateWallet.ts
-var import_react10 = require("react");
-var import_miden_sdk12 = require("@miden-sdk/miden-sdk");
+var import_react11 = require("react");
+var import_miden_sdk13 = require("@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] = (0, import_react10.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react10.useState)(false);
-  const [error, setError] = (0, import_react10.useState)(null);
-  const createWallet = (0, import_react10.useCallback)(
+  const [wallet, setWallet] = (0, import_react11.useState)(null);
+  const [isCreating, setIsCreating] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const createWallet = (0, import_react11.useCallback)(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
-      await sync();
       setIsCreating(true);
       setError(null);
       try {
@@ -1648,7 +1900,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react10.useCallback)(() => {
+  const reset = (0, import_react11.useCallback)(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1664,27 +1916,27 @@ function useCreateWallet() {
 function getStorageMode(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk12.AccountStorageMode.private();
+      return import_miden_sdk13.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk12.AccountStorageMode.public();
+      return import_miden_sdk13.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk12.AccountStorageMode.network();
+      return import_miden_sdk13.AccountStorageMode.network();
     default:
-      return import_miden_sdk12.AccountStorageMode.private();
+      return import_miden_sdk13.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useCreateFaucet.ts
-var import_react11 = require("react");
-var import_miden_sdk13 = require("@miden-sdk/miden-sdk");
+var import_react12 = require("react");
+var import_miden_sdk14 = require("@miden-sdk/miden-sdk");
 function useCreateFaucet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [faucet, setFaucet] = (0, import_react11.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react11.useState)(false);
-  const [error, setError] = (0, import_react11.useState)(null);
-  const createFaucet = (0, import_react11.useCallback)(
+  const [faucet, setFaucet] = (0, import_react12.useState)(null);
+  const [isCreating, setIsCreating] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const createFaucet = (0, import_react12.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1704,7 +1956,7 @@ function useCreateFaucet() {
             // nonFungible - currently only fungible faucets supported
             options.tokenSymbol,
             decimals,
-            options.maxSupply,
+            BigInt(options.maxSupply),
             authScheme
           );
           const accounts = await client.getAccounts();
@@ -1723,7 +1975,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react11.useCallback)(() => {
+  const reset = (0, import_react12.useCallback)(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -1739,51 +1991,105 @@ function useCreateFaucet() {
 function getStorageMode2(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk13.AccountStorageMode.private();
+      return import_miden_sdk14.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk13.AccountStorageMode.public();
+      return import_miden_sdk14.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk13.AccountStorageMode.network();
+      return import_miden_sdk14.AccountStorageMode.network();
     default:
-      return import_miden_sdk13.AccountStorageMode.private();
+      return import_miden_sdk14.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useImportAccount.ts
-var import_react12 = require("react");
-var import_miden_sdk14 = require("@miden-sdk/miden-sdk");
-function useImportAccount() {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [account, setAccount] = (0, import_react12.useState)(null);
-  const [isImporting, setIsImporting] = (0, import_react12.useState)(false);
-  const [error, setError] = (0, import_react12.useState)(null);
-  const importAccount = (0, import_react12.useCallback)(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      setIsImporting(true);
-      setError(null);
-      try {
-        let accountsAfter = null;
-        const imported = await runExclusiveSafe(async () => {
-          switch (options.type) {
-            case "file": {
-              const accountsBefore = await client.getAccounts();
-              const accountFile = await resolveAccountFile(options.file);
-              const accountFileWithAccount = accountFile;
-              const fileBytes = getAccountFileBytes(
-                accountFileWithAccount,
-                options.file
-              );
-              const accountFromFile = typeof accountFileWithAccount.account === "function" ? accountFileWithAccount.account() : null;
-              const accountIdFromFile = accountFromFile === null && typeof accountFileWithAccount.accountId === "function" ? accountFileWithAccount.accountId() : null;
-              try {
-                await client.importAccountFile(accountFile);
-              } catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
+var import_react13 = require("react");
+var import_miden_sdk15 = require("@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, signerConnected } = useMiden();
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [account, setAccount] = (0, import_react13.useState)(null);
+  const [isImporting, setIsImporting] = (0, import_react13.useState)(false);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const importAccount = (0, import_react13.useCallback)(
+    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 (async () => {
+          switch (options.type) {
+            case "file": {
+              const accountsBefore = await client.getAccounts();
+              const accountFile = await resolveAccountFile(options.file);
+              const accountFileWithAccount = accountFile;
+              const fileBytes = getAccountFileBytes(
+                accountFileWithAccount,
+                options.file
+              );
+              const accountFromFile = typeof accountFileWithAccount.account === "function" ? accountFileWithAccount.account() : null;
+              const accountIdFromFile = accountFromFile === null && typeof accountFileWithAccount.accountId === "function" ? accountFileWithAccount.accountId() : null;
+              try {
+                await client.importAccountFile(accountFile);
+              } catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
                 if (!message.includes("already being tracked")) {
                   throw err;
                 }
@@ -1820,7 +2126,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) {
@@ -1838,7 +2144,7 @@ function useImportAccount() {
               );
             }
           }
-        });
+        })();
         ensureAccountBech32(imported);
         const accounts = accountsAfter ?? await client.getAccounts();
         setAccounts(accounts);
@@ -1852,9 +2158,9 @@ function useImportAccount() {
         setIsImporting(false);
       }
     },
-    [client, isReady, runExclusive, setAccounts]
+    [client, isReady, setAccounts, signerConnected]
   );
-  const reset = (0, import_react12.useCallback)(() => {
+  const reset = (0, import_react13.useCallback)(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -1867,15 +2173,12 @@ function useImportAccount() {
     reset
   };
 }
-function resolveAccountId(accountId) {
-  return parseAccountId(accountId);
-}
 async function resolveAccountFile(file) {
   if (file instanceof Uint8Array) {
-    return import_miden_sdk14.AccountFile.deserialize(file);
+    return import_miden_sdk15.AccountFile.deserialize(file);
   }
   if (file instanceof ArrayBuffer) {
-    return import_miden_sdk14.AccountFile.deserialize(new Uint8Array(file));
+    return import_miden_sdk15.AccountFile.deserialize(new Uint8Array(file));
   }
   return file;
 }
@@ -1904,64 +2207,17 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-var import_react13 = require("react");
-var import_miden_sdk15 = require("@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
+var import_react14 = require("react");
+var import_miden_sdk16 = require("@miden-sdk/miden-sdk");
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = (0, import_react13.useRef)(false);
-  const [result, setResult] = (0, import_react13.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react13.useState)(false);
-  const [stage, setStage] = (0, import_react13.useState)("idle");
-  const [error, setError] = (0, import_react13.useState)(null);
-  const send = (0, import_react13.useCallback)(
+  const isBusyRef = (0, import_react14.useRef)(false);
+  const [result, setResult] = (0, import_react14.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react14.useState)(false);
+  const [stage, setStage] = (0, import_react14.useState)("idle");
+  const [error, setError] = (0, import_react14.useState)(null);
+  const send = (0, import_react14.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2003,6 +2259,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");
@@ -2013,6 +2270,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 import_miden_sdk16.NoteAssets([
+              new import_miden_sdk16.FungibleAsset(assetObj, BigInt(amount))
+            ]);
+            const p2idNote = import_miden_sdk16.Note.createP2IDNote(
+              fromId,
+              toId,
+              assets,
+              noteType,
+              new import_miden_sdk16.NoteAttachment()
+            );
+            const txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk16.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);
@@ -2020,17 +2306,17 @@ function useSend() {
           let txRequest;
           if (hasAttachment) {
             const attachment = createNoteAttachment(options.attachment);
-            const assets = new import_miden_sdk15.NoteAssets([
-              new import_miden_sdk15.FungibleAsset(assetIdObj, amount)
+            const assets = new import_miden_sdk16.NoteAssets([
+              new import_miden_sdk16.FungibleAsset(assetIdObj, amount)
             ]);
-            const note = import_miden_sdk15.Note.createP2IDNote(
+            const note = import_miden_sdk16.Note.createP2IDNote(
               fromAccountId,
               toAccountId,
               assets,
               noteType,
               attachment
             );
-            txRequest = new import_miden_sdk15.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk15.OutputNoteArray([import_miden_sdk15.OutputNote.full(note)])).build();
+            txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk16.NoteArray([note])).build();
           } else {
             txRequest = client.newSendTransactionRequest(
               fromAccountId,
@@ -2046,8 +2332,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(
@@ -2056,13 +2346,13 @@ function useSend() {
         const txIdHex = txResult.id().toHex();
         const txIdString = txResult.id().toString();
         let fullNote = null;
-        if (noteType === import_miden_sdk15.NoteType.Private) {
+        if (noteType === import_miden_sdk16.NoteType.Private) {
           fullNote = extractFullNote(txResult);
         }
         await runExclusiveSafe(
           () => client.applyTransaction(txResult, submissionHeight)
         );
-        if (noteType === import_miden_sdk15.NoteType.Private) {
+        if (noteType === import_miden_sdk16.NoteType.Private) {
           if (!fullNote) {
             throw new Error("Missing full note for private send");
           }
@@ -2077,11 +2367,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);
@@ -2094,7 +2387,7 @@ function useSend() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react13.useCallback)(() => {
+  const reset = (0, import_react14.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2121,21 +2414,21 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-var import_react14 = require("react");
-var import_miden_sdk16 = require("@miden-sdk/miden-sdk");
+var import_react15 = require("react");
+var import_miden_sdk17 = require("@miden-sdk/miden-sdk");
 function useMultiSend() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = (0, import_react14.useRef)(false);
-  const [result, setResult] = (0, import_react14.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react14.useState)(false);
-  const [stage, setStage] = (0, import_react14.useState)("idle");
-  const [error, setError] = (0, import_react14.useState)(null);
-  const sendMany = (0, import_react14.useCallback)(
+  const { client, isReady, sync, prover, signerConnected } = useMiden();
+  const isBusyRef = (0, import_react15.useRef)(false);
+  const [result, setResult] = (0, import_react15.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react15.useState)(false);
+  const [stage, setStage] = (0, import_react15.useState)("idle");
+  const [error, setError] = (0, import_react15.useState)(null);
+  const sendMany = (0, import_react15.useCallback)(
     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");
       }
@@ -2159,12 +2452,12 @@ function useMultiSend() {
             const iterSenderId = parseAccountId(options.from);
             const iterAssetId = parseAccountId(options.assetId);
             const receiverId = parseAccountId(to);
-            const assets = new import_miden_sdk16.NoteAssets([
-              new import_miden_sdk16.FungibleAsset(iterAssetId, amount)
+            const assets = new import_miden_sdk17.NoteAssets([
+              new import_miden_sdk17.FungibleAsset(iterAssetId, BigInt(amount))
             ]);
             const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
-            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_miden_sdk16.NoteAttachment();
-            const note = import_miden_sdk16.Note.createP2IDNote(
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_miden_sdk17.NoteAttachment();
+            const note = import_miden_sdk17.Note.createP2IDNote(
               iterSenderId,
               receiverId,
               assets,
@@ -2173,44 +2466,43 @@ function useMultiSend() {
             );
             const recipientAddress = parseAddress(to, receiverId);
             return {
-              outputNote: import_miden_sdk16.OutputNote.full(note),
               note,
               recipientAddress,
               noteType: resolvedNoteType
             };
           }
         );
-        const txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(
-          new import_miden_sdk16.OutputNoteArray(outputs.map((o) => o.outputNote))
-        ).build();
+        const txRequest = new import_miden_sdk17.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk17.NoteArray(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)
-        );
-        const hasPrivate = outputs.some((o) => o.noteType === import_miden_sdk16.NoteType.Private);
+        await client.applyTransaction(txResult, submissionHeight);
+        const hasPrivate = outputs.some((o) => o.noteType === import_miden_sdk17.NoteType.Private);
         if (hasPrivate) {
           await waitForTransactionCommit(
             client,
-            runExclusiveSafe,
+            runExclusiveDirect,
             txIdHex
           );
           for (const output of outputs) {
-            if (output.noteType === import_miden_sdk16.NoteType.Private) {
-              await runExclusiveSafe(
-                () => client.sendPrivateNote(output.note, output.recipientAddress)
+            if (output.noteType === import_miden_sdk17.NoteType.Private) {
+              await client.sendPrivateNote(
+                output.note,
+                output.recipientAddress
               );
             }
           }
@@ -2230,144 +2522,7 @@ function useMultiSend() {
         isBusyRef.current = false;
       }
     },
-    [client, isReady, prover, runExclusive, sync]
-  );
-  const reset = (0, import_react14.useCallback)(() => {
-    setResult(null);
-    setIsLoading(false);
-    setStage("idle");
-    setError(null);
-  }, []);
-  return {
-    sendMany,
-    result,
-    isLoading,
-    stage,
-    error,
-    reset
-  };
-}
-
-// src/hooks/useInternalTransfer.ts
-var import_react15 = require("react");
-var import_miden_sdk17 = require("@miden-sdk/miden-sdk");
-function useInternalTransfer() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react15.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react15.useState)(false);
-  const [stage, setStage] = (0, import_react15.useState)("idle");
-  const [error, setError] = (0, import_react15.useState)(null);
-  const transferOnce = (0, import_react15.useCallback)(
-    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 import_miden_sdk17.NoteAssets([
-        new import_miden_sdk17.FungibleAsset(assetId, options.amount)
-      ]);
-      const note = import_miden_sdk17.Note.createP2IDNote(
-        senderId,
-        receiverId,
-        assets,
-        noteType,
-        new import_miden_sdk17.NoteAttachment()
-      );
-      const noteId = note.id().toString();
-      const createRequest = new import_miden_sdk17.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk17.OutputNoteArray([import_miden_sdk17.OutputNote.full(note)])).build();
-      const createTxId = await runExclusiveSafe(
-        () => prover ? client.submitNewTransactionWithProver(
-          senderId,
-          createRequest,
-          prover
-        ) : client.submitNewTransaction(senderId, createRequest)
-      );
-      const consumeRequest = new import_miden_sdk17.TransactionRequestBuilder().withInputNotes(new import_miden_sdk17.NoteAndArgsArray([new import_miden_sdk17.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 = (0, import_react15.useCallback)(
-    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 = (0, import_react15.useCallback)(
-    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 = (0, import_react15.useCallback)(() => {
     setResult(null);
@@ -2376,8 +2531,7 @@ function useInternalTransfer() {
     setError(null);
   }, []);
   return {
-    transfer,
-    transferChain,
+    sendMany,
     result,
     isLoading,
     stage,
@@ -2390,8 +2544,7 @@ function useInternalTransfer() {
 var import_react16 = require("react");
 var import_miden_sdk18 = require("@miden-sdk/miden-sdk");
 function useWaitForCommit() {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { client, isReady } = useMiden();
   const waitForCommit = (0, import_react16.useCallback)(
     async (txId, options) => {
       if (!client || !isReady) {
@@ -2404,13 +2557,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" ? import_miden_sdk18.TransactionFilter.all() : import_miden_sdk18.TransactionFilter.ids([txId])
-          )
+        await client.syncState();
+        const records = await client.getTransactions(
+          typeof txId === "string" ? import_miden_sdk18.TransactionFilter.all() : import_miden_sdk18.TransactionFilter.ids([txId])
         );
         const record = records.find(
           (item) => normalizeHex3(item.id().toHex()) === targetHex
@@ -2428,7 +2577,7 @@ function useWaitForCommit() {
       }
       throw new Error("Timeout waiting for transaction commit");
     },
-    [client, isReady, runExclusiveSafe]
+    [client, isReady]
   );
   return { waitForCommit };
 }
@@ -2457,11 +2606,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;
@@ -2500,7 +2649,7 @@ function useMint() {
             targetAccountIdObj,
             faucetIdObj,
             noteType,
-            options.amount
+            BigInt(options.amount)
           );
           const txId = prover ? await client.submitNewTransactionWithProver(
             faucetIdObj,
@@ -2555,8 +2704,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");
@@ -2565,16 +2714,47 @@ function useConsume() {
         const accountIdObj = parseAccountId(options.accountId);
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
-          const noteIds = options.noteIds.map(
-            (noteId) => import_miden_sdk19.NoteId.fromHex(noteId)
-          );
-          const filter = new import_miden_sdk19.NoteFilter(import_miden_sdk19.NoteFilterTypes.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(import_miden_sdk19.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 import_miden_sdk19.NoteFilter(import_miden_sdk19.NoteFilterTypes.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);
@@ -2646,9 +2826,9 @@ function useSwap() {
           const txRequest = client.newSwapTransactionRequest(
             accountIdObj,
             offeredFaucetIdObj,
-            options.offeredAmount,
+            BigInt(options.offeredAmount),
             requestedFaucetIdObj,
-            options.requestedAmount,
+            BigInt(options.requestedAmount),
             noteType,
             paybackNoteType
           );
@@ -2692,8 +2872,50 @@ function useSwap() {
 
 // src/hooks/useTransaction.ts
 var import_react21 = require("react");
+
+// src/utils/transactions.ts
+var import_miden_sdk20 = require("@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(import_miden_sdk20.TransactionFilter.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?.() === import_miden_sdk20.NoteType.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 = (0, import_react21.useRef)(false);
   const [result, setResult] = (0, import_react21.useState)(null);
@@ -2720,20 +2942,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);
@@ -2744,7 +2987,7 @@ function useTransaction() {
         isBusyRef.current = false;
       }
     },
-    [client, isReady, prover, runExclusive, sync]
+    [client, isReady, runExclusive, sync]
   );
   const reset = (0, import_react21.useCallback)(() => {
     setResult(null);
@@ -2761,9 +3004,6 @@ function useTransaction() {
     reset
   };
 }
-function resolveAccountId2(accountId) {
-  return parseAccountId(accountId);
-}
 async function resolveRequest(request, client) {
   if (typeof request === "function") {
     return await request(client);
@@ -2771,27 +3011,112 @@ async function resolveRequest(request, client) {
   return request;
 }
 
-// src/hooks/useSessionAccount.ts
+// src/hooks/useExecuteProgram.ts
 var import_react22 = require("react");
-var import_miden_sdk20 = require("@miden-sdk/miden-sdk");
-function useSessionAccount(options) {
+var import_miden_sdk21 = require("@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 setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = (0, import_react22.useState)(null);
-  const [step, setStep] = (0, import_react22.useState)("idle");
-  const [error, setError] = (0, import_react22.useState)(null);
-  const cancelledRef = (0, import_react22.useRef)(false);
   const isBusyRef = (0, import_react22.useRef)(false);
+  const [result, setResult] = (0, import_react22.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react22.useState)(false);
+  const [error, setError] = (0, import_react22.useState)(null);
+  const execute = (0, import_react22.useCallback)(
+    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 import_miden_sdk21.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 import_miden_sdk21.AccountStorageRequirements();
+              return import_miden_sdk21.ForeignAccount.public(id, storage);
+            });
+            foreignAccountsArray = new import_miden_sdk21.ForeignAccountArray(accounts);
+          } else {
+            foreignAccountsArray = new import_miden_sdk21.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 = (0, import_react22.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    execute,
+    result,
+    isLoading,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSessionAccount.ts
+var import_react23 = require("react");
+var import_miden_sdk22 = require("@miden-sdk/miden-sdk");
+function useSessionAccount(options) {
+  const { client, isReady, sync } = useMiden();
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [sessionAccountId, setSessionAccountId] = (0, import_react23.useState)(null);
+  const [step, setStep] = (0, import_react23.useState)("idle");
+  const [error, setError] = (0, import_react23.useState)(null);
+  const cancelledRef = (0, import_react23.useRef)(false);
+  const isBusyRef = (0, import_react23.useRef)(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 = (0, import_react22.useRef)(options.fund);
+  const fundRef = (0, import_react23.useRef)(options.fund);
   fundRef.current = options.fund;
-  (0, import_react22.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     try {
       const stored = localStorage.getItem(`${storagePrefix}:accountId`);
       const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
@@ -2808,7 +3133,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = (0, import_react22.useCallback)(async () => {
+  const initialize = (0, import_react23.useCallback)(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -2826,17 +3151,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);
@@ -2848,7 +3170,6 @@ function useSessionAccount(options) {
       setStep("consuming");
       await waitAndConsume(
         client,
-        runExclusiveSafe,
         walletId,
         pollIntervalMs,
         maxWaitMs,
@@ -2872,7 +3193,6 @@ function useSessionAccount(options) {
     client,
     isReady,
     sync,
-    runExclusiveSafe,
     sessionAccountId,
     storageMode,
     mutable,
@@ -2882,7 +3202,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = (0, import_react22.useCallback)(() => {
+  const reset = (0, import_react23.useCallback)(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -2903,37 +3223,209 @@ function useSessionAccount(options) {
 function getStorageMode3(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk20.AccountStorageMode.private();
+      return import_miden_sdk22.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk20.AccountStorageMode.public();
+      return import_miden_sdk22.AccountStorageMode.public();
     default:
-      return import_miden_sdk20.AccountStorageMode.public();
+      return import_miden_sdk22.AccountStorageMode.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
+var import_react24 = require("react");
+var import_miden_sdk23 = require("@miden-sdk/miden-sdk");
+function useExportStore() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = (0, import_react24.useState)(false);
+  const [error, setError] = (0, import_react24.useState)(null);
+  const exportStore = (0, import_react24.useCallback)(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(() => (0, import_miden_sdk23.exportStore)(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 = (0, import_react24.useCallback)(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportStore,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportStore.ts
+var import_react25 = require("react");
+var import_miden_sdk24 = require("@miden-sdk/miden-sdk");
+function useImportStore() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = (0, import_react25.useState)(false);
+  const [error, setError] = (0, import_react25.useState)(null);
+  const importStore = (0, import_react25.useCallback)(
+    async (storeDump, storeName, options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        await runExclusive(() => (0, import_miden_sdk24.importStore)(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 = (0, import_react25.useCallback)(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importStore,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportNote.ts
+var import_react26 = require("react");
+var import_miden_sdk25 = require("@miden-sdk/miden-sdk");
+function useImportNote() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = (0, import_react26.useState)(false);
+  const [error, setError] = (0, import_react26.useState)(null);
+  const importNote = (0, import_react26.useCallback)(
+    async (noteBytes) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        const noteFile = import_miden_sdk25.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 = (0, import_react26.useCallback)(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importNote,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useExportNote.ts
+var import_react27 = require("react");
+var import_miden_sdk26 = require("@miden-sdk/miden-sdk");
+function useExportNote() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = (0, import_react27.useState)(false);
+  const [error, setError] = (0, import_react27.useState)(null);
+  const exportNote = (0, import_react27.useCallback)(
+    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, import_miden_sdk26.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 = (0, import_react27.useCallback)(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportNote,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSyncControl.ts
+var import_react28 = require("react");
+function useSyncControl() {
+  const isPaused = useMidenStore((state) => state.syncPaused);
+  const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
+  const pauseSync = (0, import_react28.useCallback)(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = (0, import_react28.useCallback)(() => setSyncPaused(false), [setSyncPaused]);
+  return {
+    pauseSync,
+    resumeSync,
+    isPaused
+  };
+}
+
 // src/utils/bytes.ts
 function bytesToBigInt(bytes) {
   let result = 0n;
@@ -3085,10 +3577,13 @@ function createMidenStorage(prefix) {
 installAccountBech32();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthScheme,
   DEFAULTS,
   MidenError,
   MidenProvider,
+  MultiSignerProvider,
   SignerContext,
+  SignerSlot,
   accountIdsEqual,
   bigIntToBytes,
   bytesToBigInt,
@@ -3110,18 +3605,24 @@ installAccountBech32();
   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,