@miden-sdk/react 0.13.2 → 0.14.0-alpha

package/dist/index.js

@@ -30,13 +30,25 @@ 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,
   SignerContext: () => SignerContext,
+  accountIdsEqual: () => accountIdsEqual,
+  bigIntToBytes: () => bigIntToBytes,
+  bytesToBigInt: () => bytesToBigInt,
+  clearMidenStorage: () => clearMidenStorage,
+  concatBytes: () => concatBytes,
+  createMidenStorage: () => createMidenStorage,
+  createNoteAttachment: () => createNoteAttachment,
   formatAssetAmount: () => formatAssetAmount,
   formatNoteSummary: () => formatNoteSummary,
   getNoteSummary: () => getNoteSummary,
+  migrateStorage: () => migrateStorage,
+  normalizeAccountId: () => normalizeAccountId,
   parseAssetAmount: () => parseAssetAmount,
+  readNoteAttachment: () => readNoteAttachment,
   toBech32AccountId: () => toBech32AccountId,
   useAccount: () => useAccount,
   useAccounts: () => useAccounts,
@@ -50,15 +62,19 @@ __export(index_exports, {
   useMidenClient: () => useMidenClient,
   useMint: () => useMint,
   useMultiSend: () => useMultiSend,
+  useNoteStream: () => useNoteStream,
   useNotes: () => useNotes,
   useSend: () => useSend,
+  useSessionAccount: () => useSessionAccount,
   useSigner: () => useSigner,
   useSwap: () => useSwap,
   useSyncState: () => useSyncState,
   useTransaction: () => useTransaction,
   useTransactionHistory: () => useTransactionHistory,
   useWaitForCommit: () => useWaitForCommit,
-  useWaitForNotes: () => useWaitForNotes
+  useWaitForNotes: () => useWaitForNotes,
+  waitForWalletDetection: () => waitForWalletDetection,
+  wrapWasmError: () => wrapWasmError
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -88,6 +104,7 @@ var initialState = {
   notes: [],
   consumableNotes: [],
   assetMetadata: /* @__PURE__ */ new Map(),
+  noteFirstSeen: /* @__PURE__ */ new Map(),
   isLoadingAccounts: false,
   isLoadingNotes: false
 };
@@ -115,8 +132,74 @@ var useMidenStore = (0, import_zustand.create)()((set) => ({
     newMap.set(accountId, account);
     return { accountDetails: newMap };
   }),
-  setNotes: (notes) => set({ notes }),
+  setNotes: (notes) => set((state) => {
+    const now = Date.now();
+    const newFirstSeen = /* @__PURE__ */ new Map();
+    for (const note of notes) {
+      try {
+        const id = note.id().toString();
+        newFirstSeen.set(id, state.noteFirstSeen.get(id) ?? now);
+      } catch {
+      }
+    }
+    return { notes, noteFirstSeen: newFirstSeen };
+  }),
+  setNotesIfChanged: (notes) => set((state) => {
+    const safeId = (n) => {
+      try {
+        return n.id().toString();
+      } catch {
+        return null;
+      }
+    };
+    const prevIds = /* @__PURE__ */ new Set();
+    for (const n of state.notes) {
+      const id = safeId(n);
+      if (id) prevIds.add(id);
+    }
+    const newIds = /* @__PURE__ */ new Set();
+    for (const n of notes) {
+      const id = safeId(n);
+      if (id) newIds.add(id);
+    }
+    if (prevIds.size === newIds.size && [...prevIds].every((id) => newIds.has(id))) {
+      return {};
+    }
+    const now = Date.now();
+    const newFirstSeen = /* @__PURE__ */ new Map();
+    for (const note of notes) {
+      try {
+        const id = note.id().toString();
+        newFirstSeen.set(id, state.noteFirstSeen.get(id) ?? now);
+      } catch {
+      }
+    }
+    return { notes, noteFirstSeen: newFirstSeen };
+  }),
   setConsumableNotes: (consumableNotes) => set({ consumableNotes }),
+  setConsumableNotesIfChanged: (consumableNotes) => set((state) => {
+    const safeId = (n) => {
+      try {
+        return n.inputNoteRecord().id().toString();
+      } catch {
+        return null;
+      }
+    };
+    const prevIds = /* @__PURE__ */ new Set();
+    for (const n of state.consumableNotes) {
+      const id = safeId(n);
+      if (id) prevIds.add(id);
+    }
+    const newIds = /* @__PURE__ */ new Set();
+    for (const n of consumableNotes) {
+      const id = safeId(n);
+      if (id) newIds.add(id);
+    }
+    if (prevIds.size === newIds.size && [...prevIds].every((id) => newIds.has(id))) {
+      return {};
+    }
+    return { consumableNotes };
+  }),
   setAssetMetadata: (assetId, metadata) => set((state) => {
     const newMap = new Map(state.assetMetadata);
     newMap.set(assetId, metadata);
@@ -131,6 +214,7 @@ var useAccountsStore = () => useMidenStore((state) => state.accounts);
 var useNotesStore = () => useMidenStore((state) => state.notes);
 var useConsumableNotesStore = () => useMidenStore((state) => state.consumableNotes);
 var useAssetMetadataStore = () => useMidenStore((state) => state.assetMetadata);
+var useNoteFirstSeenStore = () => useMidenStore((state) => state.noteFirstSeen);
 
 // src/utils/accountParsing.ts
 var import_miden_sdk2 = require("@miden-sdk/miden-sdk");
@@ -154,6 +238,19 @@ var parseAccountId = (value) => {
   const normalized = normalizeAccountIdInput(value);
   return parseAccountIdFromString(normalized);
 };
+function isFaucetId(accountId) {
+  try {
+    let hex = typeof accountId.toHex === "function" ? accountId.toHex() : String(accountId);
+    if (hex.startsWith("0x") || hex.startsWith("0X")) {
+      hex = hex.slice(2);
+    }
+    const firstByte = parseInt(hex.slice(0, 2), 16);
+    const accountType = firstByte >> 4 & 3;
+    return accountType === 2 || accountType === 3;
+  } catch {
+    return false;
+  }
+}
 var parseAddress = (value, accountId) => {
   const normalized = normalizeAccountIdInput(value);
   if (isBech32Input(normalized)) {
@@ -258,16 +355,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
 };
@@ -311,7 +409,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"
@@ -324,19 +422,19 @@ function resolveTransactionProver(config) {
   if (typeof prover === "string") {
     const normalized = prover.trim().toLowerCase();
     if (normalized === "local") {
-      return import_miden_sdk4.TransactionProver.newLocalProver();
+      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(
+    return import_miden_sdk5.TransactionProver.newRemoteProver(
       prover,
       normalizeTimeout(config.proverTimeoutMs)
     );
@@ -348,7 +446,7 @@ function createRemoteProver(config, fallbackTimeout) {
   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)
   );
@@ -371,38 +469,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 } = await import("@miden-sdk/miden-sdk");
+  const { AccountBuilder, AccountComponent, AuthScheme: AuthScheme2, Word: Word2 } = await import("@miden-sdk/miden-sdk");
   await client.syncState();
-  const commitmentWord = Word.deserialize(config.publicKeyCommitment);
+  const commitmentWord = Word2.deserialize(config.publicKeyCommitment);
   const seed = config.accountSeed ?? crypto.getRandomValues(new Uint8Array(32));
-  const accountType = await getAccountType(config.accountType);
-  const builder = new AccountBuilder(seed);
-  const buildResult = builder.withAuthComponent(
+  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().build();
+  ).accountType(accountType).storageMode(config.storageMode).withBasicWalletComponent();
+  if (config.customComponents?.length) {
+    for (const component of config.customComponents) {
+      if (component == null || typeof component.getProcedures !== "function") {
+        throw new Error(
+          "Each entry in customComponents must be an AccountComponent instance created via AccountComponent.compile(), AccountComponent.fromPackage(), or AccountComponent.fromLibrary()."
+        );
+      }
+      builder = builder.withComponent(component);
+    }
+  }
+  const buildResult = builder.build();
   const account = buildResult.account;
   const accountId = account.id();
   if (!isPrivateStorageMode(config.storageMode)) {
@@ -506,9 +607,6 @@ function MidenProvider({
       }
       return;
     }
-    if (!signerContext) {
-      isInitializedRef.current = true;
-    }
     let cancelled = false;
     const initClient = async () => {
       await runExclusive(async () => {
@@ -520,7 +618,7 @@ function MidenProvider({
           let didSignerInit = false;
           if (signerContext && signerContext.isConnected) {
             const storeName = `MidenClientDB_${signerContext.storeName}`;
-            webClient = await import_miden_sdk5.WebClient.createClientWithExternalKeystore(
+            webClient = await import_miden_sdk6.WasmWebClient.createClientWithExternalKeystore(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               resolvedConfig.seed,
@@ -541,7 +639,7 @@ function MidenProvider({
             didSignerInit = true;
           } else {
             const seed = resolvedConfig.seed;
-            webClient = await import_miden_sdk5.WebClient.createClient(
+            webClient = await import_miden_sdk6.WasmWebClient.createClient(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               seed
@@ -568,6 +666,9 @@ function MidenProvider({
             }
           }
           if (!cancelled) {
+            if (!signerContext) {
+              isInitializedRef.current = true;
+            }
             setClient(webClient);
           }
         } catch (error) {
@@ -582,6 +683,7 @@ function MidenProvider({
     initClient();
     return () => {
       cancelled = true;
+      isInitializedRef.current = false;
     };
   }, [
     runExclusive,
@@ -697,23 +799,13 @@ function useAccounts() {
     refetch
   };
 }
-function isFaucetId(accountId) {
-  try {
-    const hex = typeof accountId.toHex === "function" ? accountId.toHex() : String(accountId);
-    const firstByte = parseInt(hex.slice(0, 2), 16);
-    const accountType = firstByte >> 4 & 3;
-    return accountType === 2 || accountType === 3;
-  } catch {
-    return false;
-  }
-}
 
 // src/hooks/useAccount.ts
 var import_react5 = require("react");
 
 // src/hooks/useAssetMetadata.ts
 var import_react4 = require("react");
-var import_miden_sdk6 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
 var inflight = /* @__PURE__ */ new Map();
 var rpcClients = /* @__PURE__ */ new Map();
 var getRpcClient = (rpcUrl) => {
@@ -721,27 +813,22 @@ 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 {
     return null;
   }
 };
-var fetchAssetMetadata = async (client, rpcClient, assetId) => {
+var fetchAssetMetadata = async (rpcClient, assetId) => {
   try {
     const accountId = parseAccountId(assetId);
-    let account = await client.getAccount(accountId);
-    if (!account && rpcClient) {
-      try {
-        const fetched = await rpcClient.getAccountDetails(accountId);
-        account = fetched.account?.();
-      } catch {
-      }
-    }
+    if (!isFaucetId(accountId)) return null;
+    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 };
@@ -750,8 +837,6 @@ var fetchAssetMetadata = async (client, rpcClient, assetId) => {
   }
 };
 function useAssetMetadata(assetIds = []) {
-  const { client, isReady, runExclusive } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const assetMetadata = useAssetMetadataStore();
   const setAssetMetadata = useMidenStore((state) => state.setAssetMetadata);
   const rpcUrl = useMidenStore((state) => state.config.rpcUrl);
@@ -761,32 +846,19 @@ function useAssetMetadata(assetIds = []) {
     [assetIds]
   );
   (0, import_react4.useEffect)(() => {
-    if (!client || !isReady || uniqueAssetIds.length === 0) return;
+    if (!rpcClient || uniqueAssetIds.length === 0) return;
     uniqueAssetIds.forEach((assetId) => {
       const existing = assetMetadata.get(assetId);
       const hasMetadata = existing?.symbol !== void 0 || existing?.decimals !== void 0;
       if (hasMetadata || inflight.has(assetId)) return;
-      const promise = runExclusiveSafe(async () => {
-        const metadata = await fetchAssetMetadata(
-          client,
-          rpcClient,
-          assetId
-        );
+      const promise = fetchAssetMetadata(rpcClient, assetId).then((metadata) => {
         setAssetMetadata(assetId, metadata ?? { assetId });
       }).finally(() => {
         inflight.delete(assetId);
       });
       inflight.set(assetId, promise);
     });
-  }, [
-    client,
-    isReady,
-    uniqueAssetIds,
-    assetMetadata,
-    runExclusiveSafe,
-    setAssetMetadata,
-    rpcClient
-  ]);
+  }, [uniqueAssetIds, assetMetadata, setAssetMetadata, rpcClient]);
   return { assetMetadata };
 }
 
@@ -888,7 +960,7 @@ function useAccount(accountId) {
 
 // src/hooks/useNotes.ts
 var import_react6 = require("react");
-var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
+var import_miden_sdk9 = require("@miden-sdk/miden-sdk");
 
 // src/utils/amounts.ts
 var formatAssetAmount = (amount, decimals) => {
@@ -972,6 +1044,82 @@ var formatNoteSummary = (summary, formatAsset = (asset) => `${formatAssetAmount(
   return summary.sender ? `${assetsText} from ${summary.sender}` : assetsText;
 };
 
+// src/utils/accountId.ts
+function normalizeAccountId(id) {
+  return toBech32AccountId(id);
+}
+function accountIdsEqual(a, b) {
+  let idA;
+  let idB;
+  try {
+    idA = parseAccountId(a);
+    idB = parseAccountId(b);
+    return idA.toString() === idB.toString();
+  } catch {
+    return a === b;
+  } finally {
+    idA?.free?.();
+    idB?.free?.();
+  }
+}
+
+// src/utils/noteFilters.ts
+var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
+function getNoteFilterType(status) {
+  switch (status) {
+    case "consumed":
+      return import_miden_sdk8.NoteFilterTypes.Consumed;
+    case "committed":
+      return import_miden_sdk8.NoteFilterTypes.Committed;
+    case "expected":
+      return import_miden_sdk8.NoteFilterTypes.Expected;
+    case "processing":
+      return import_miden_sdk8.NoteFilterTypes.Processing;
+    case "all":
+    default:
+      return import_miden_sdk8.NoteFilterTypes.All;
+  }
+}
+function getNoteType(type) {
+  switch (type) {
+    case "private":
+      return import_miden_sdk8.NoteType.Private;
+    case "public":
+      return import_miden_sdk8.NoteType.Public;
+    default:
+      return import_miden_sdk8.NoteType.Private;
+  }
+}
+async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWaitMs = 1e4, delayMs = 1e3) {
+  const deadline = Date.now() + maxWaitMs;
+  const targetHex = normalizeHex(txIdHex);
+  while (Date.now() < deadline) {
+    await runExclusiveSafe(() => client.syncState());
+    const records = await runExclusiveSafe(
+      () => client.getTransactions(import_miden_sdk8.TransactionFilter.all())
+    );
+    const record = records.find(
+      (r) => normalizeHex(r.id().toHex()) === targetHex
+    );
+    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));
+  }
+  throw new Error("Timeout waiting for transaction commit");
+}
+function normalizeHex(value) {
+  const trimmed = value.trim();
+  const normalized = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed : `0x${trimmed}`;
+  return normalized.toLowerCase();
+}
+
 // src/hooks/useNotes.ts
 function useNotes(options) {
   const { client, isReady, runExclusive } = useMiden();
@@ -980,8 +1128,10 @@ function useNotes(options) {
   const consumableNotes = useConsumableNotesStore();
   const isLoadingNotes = useMidenStore((state) => state.isLoadingNotes);
   const setLoadingNotes = useMidenStore((state) => state.setLoadingNotes);
-  const setNotes = useMidenStore((state) => state.setNotes);
-  const setConsumableNotes = useMidenStore((state) => state.setConsumableNotes);
+  const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
+  const setConsumableNotesIfChanged = useMidenStore(
+    (state) => state.setConsumableNotesIfChanged
+  );
   const { lastSyncTime } = useSyncStateStore();
   const [error, setError] = (0, import_react6.useState)(null);
   const refetch = (0, import_react6.useCallback)(async () => {
@@ -992,7 +1142,7 @@ function useNotes(options) {
       const { fetchedNotes, fetchedConsumable } = await runExclusiveSafe(
         async () => {
           const filterType = getNoteFilterType(options?.status);
-          const filter = new import_miden_sdk7.NoteFilter(filterType);
+          const filter = new import_miden_sdk9.NoteFilter(filterType);
           const notesResult = await client.getInputNotes(filter);
           let consumableResult;
           if (options?.accountId) {
@@ -1007,8 +1157,8 @@ function useNotes(options) {
           };
         }
       );
-      setNotes(fetchedNotes);
-      setConsumableNotes(fetchedConsumable);
+      setNotesIfChanged(fetchedNotes);
+      setConsumableNotesIfChanged(fetchedConsumable);
     } catch (err) {
       setError(err instanceof Error ? err : new Error(String(err)));
     } finally {
@@ -1021,8 +1171,8 @@ function useNotes(options) {
     options?.status,
     options?.accountId,
     setLoadingNotes,
-    setNotes,
-    setConsumableNotes
+    setNotesIfChanged,
+    setConsumableNotesIfChanged
   ]);
   (0, import_react6.useEffect)(() => {
     if (isReady && notes.length === 0) {
@@ -1049,14 +1199,65 @@ function useNotes(options) {
     (assetId) => assetMetadata.get(assetId),
     [assetMetadata]
   );
-  const noteSummaries = (0, import_react6.useMemo)(
-    () => notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean),
-    [notes, getMetadata]
-  );
-  const consumableNoteSummaries = (0, import_react6.useMemo)(
-    () => consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean),
-    [consumableNotes, getMetadata]
+  const normalizedSender = (0, import_react6.useMemo)(() => {
+    if (!options?.sender) return null;
+    try {
+      return normalizeAccountId(options.sender);
+    } catch {
+      return options.sender;
+    }
+  }, [options?.sender]);
+  const excludeIdsKey = (0, import_react6.useMemo)(() => {
+    if (!options?.excludeIds || options.excludeIds.length === 0) return "";
+    return [...options.excludeIds].sort().join("\0");
+  }, [options?.excludeIds]);
+  const filterBySender = (0, import_react6.useCallback)(
+    (summaries, target) => {
+      const cache = /* @__PURE__ */ new Map();
+      return summaries.filter((s) => {
+        if (!s.sender) return false;
+        let normalized = cache.get(s.sender);
+        if (normalized === void 0) {
+          try {
+            normalized = normalizeAccountId(s.sender);
+          } catch {
+            normalized = s.sender;
+          }
+          cache.set(s.sender, normalized);
+        }
+        return normalized === target;
+      });
+    },
+    []
   );
+  const noteSummaries = (0, import_react6.useMemo)(() => {
+    let summaries = notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
+    if (normalizedSender) {
+      summaries = filterBySender(summaries, normalizedSender);
+    }
+    if (excludeIdsKey) {
+      const excludeSet = new Set(excludeIdsKey.split("\0"));
+      summaries = summaries.filter((s) => !excludeSet.has(s.id));
+    }
+    return summaries;
+  }, [notes, getMetadata, normalizedSender, excludeIdsKey, filterBySender]);
+  const consumableNoteSummaries = (0, import_react6.useMemo)(() => {
+    let summaries = consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
+    if (normalizedSender) {
+      summaries = filterBySender(summaries, normalizedSender);
+    }
+    if (excludeIdsKey) {
+      const excludeSet = new Set(excludeIdsKey.split("\0"));
+      summaries = summaries.filter((s) => !excludeSet.has(s.id));
+    }
+    return summaries;
+  }, [
+    consumableNotes,
+    getMetadata,
+    normalizedSender,
+    excludeIdsKey,
+    filterBySender
+  ]);
   return {
     notes,
     consumableNotes,
@@ -1067,46 +1268,246 @@ function useNotes(options) {
     refetch
   };
 }
-function getNoteFilterType(status) {
-  switch (status) {
-    case "consumed":
-      return import_miden_sdk7.NoteFilterTypes.Consumed;
-    case "committed":
-      return import_miden_sdk7.NoteFilterTypes.Committed;
-    case "expected":
-      return import_miden_sdk7.NoteFilterTypes.Expected;
-    case "processing":
-      return import_miden_sdk7.NoteFilterTypes.Processing;
-    case "all":
-    default:
-      return import_miden_sdk7.NoteFilterTypes.All;
+
+// src/hooks/useNoteStream.ts
+var import_react7 = require("react");
+var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
+
+// src/utils/noteAttachment.ts
+var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
+function readNoteAttachment(note) {
+  try {
+    const metadata = note.metadata?.();
+    if (!metadata) return null;
+    const attachment = metadata.attachment?.();
+    if (!attachment) return null;
+    const kind = attachment.kind?.();
+    if (!kind) return null;
+    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();
+      const values = Array.from(u64s).map(
+        (v) => BigInt(v)
+      );
+      return { values, kind: "word" };
+    }
+    if (kind === import_miden_sdk10.NoteAttachmentKind.Array) {
+      const arr = attachment.asArray?.();
+      if (!arr) return null;
+      const u64s = arr.toU64s();
+      const values = Array.from(u64s).map(
+        (v) => BigInt(v)
+      );
+      return { values, kind: "array" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function createNoteAttachment(values) {
+  const bigints = [];
+  for (let i = 0; i < values.length; i++) {
+    bigints.push(BigInt(values[i]));
+  }
+  if (bigints.length === 0) {
+    return new import_miden_sdk10.NoteAttachment();
+  }
+  const scheme = import_miden_sdk10.NoteAttachmentScheme.none();
+  if (bigints.length <= 4) {
+    while (bigints.length < 4) {
+      bigints.push(0n);
+    }
+    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_sdk10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
+  }
+  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_sdk10.NoteAttachment, scheme, words);
 }
 
-// src/hooks/useTransactionHistory.ts
-var import_react7 = require("react");
-var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
-function useTransactionHistory(options = {}) {
+// src/hooks/useNoteStream.ts
+function useNoteStream(options = {}) {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const allNotes = useNotesStore();
+  const noteFirstSeen = useNoteFirstSeenStore();
   const { lastSyncTime } = useSyncStateStore();
-  const [records, setRecords] = (0, import_react7.useState)([]);
+  const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
   const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
   const [error, setError] = (0, import_react7.useState)(null);
-  const rawIds = (0, import_react7.useMemo)(() => {
+  const handledIdsRef = (0, import_react7.useRef)(/* @__PURE__ */ new Set());
+  const [handledVersion, setHandledVersion] = (0, import_react7.useState)(0);
+  const status = options.status ?? "committed";
+  const sender = options.sender ?? null;
+  const since = options.since;
+  const amountFilterRef = (0, import_react7.useRef)(options.amountFilter);
+  amountFilterRef.current = options.amountFilter;
+  const excludeIdsKey = (0, import_react7.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)(() => {
+    if (!excludeIdsKey) return null;
+    return new Set(excludeIdsKey.split("\0"));
+  }, [excludeIdsKey]);
+  const refetch = (0, import_react7.useCallback)(async () => {
+    if (!client || !isReady) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const filterType = getNoteFilterType(status);
+      const filter = new import_miden_sdk11.NoteFilter(filterType);
+      const fetched = await runExclusiveSafe(
+        () => 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)(() => {
+    if (isReady) {
+      refetch();
+    }
+  }, [isReady, lastSyncTime, refetch]);
+  const streamedNotes = (0, import_react7.useMemo)(() => {
+    void handledVersion;
+    const result = [];
+    let normalizedSender = null;
+    if (sender) {
+      try {
+        normalizedSender = normalizeAccountId(sender);
+      } catch {
+        normalizedSender = sender;
+      }
+    }
+    for (const record of allNotes) {
+      const note = buildStreamedNote(record, noteFirstSeen);
+      if (!note) continue;
+      if (handledIdsRef.current.has(note.id)) continue;
+      if (excludeIdSet && excludeIdSet.has(note.id)) continue;
+      if (normalizedSender && note.sender !== normalizedSender) continue;
+      if (since !== void 0 && note.firstSeenAt < since) continue;
+      if (amountFilterRef.current && !amountFilterRef.current(note.amount))
+        continue;
+      result.push(note);
+    }
+    result.sort((a, b) => a.firstSeenAt - b.firstSeenAt);
+    return result;
+  }, [allNotes, noteFirstSeen, excludeIdSet, sender, since, handledVersion]);
+  const latest = (0, import_react7.useMemo)(
+    () => streamedNotes.length > 0 ? streamedNotes[streamedNotes.length - 1] : null,
+    [streamedNotes]
+  );
+  const markHandled = (0, import_react7.useCallback)((noteId) => {
+    handledIdsRef.current = new Set(handledIdsRef.current).add(noteId);
+    setHandledVersion((v) => v + 1);
+  }, []);
+  const markAllHandled = (0, import_react7.useCallback)(() => {
+    const newSet = new Set(handledIdsRef.current);
+    for (const note of streamedNotes) {
+      newSet.add(note.id);
+    }
+    handledIdsRef.current = newSet;
+    setHandledVersion((v) => v + 1);
+  }, [streamedNotes]);
+  const snapshot = (0, import_react7.useCallback)(() => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const note of streamedNotes) {
+      ids.add(note.id);
+    }
+    return { ids, timestamp: Date.now() };
+  }, [streamedNotes]);
+  return {
+    notes: streamedNotes,
+    latest,
+    markHandled,
+    markAllHandled,
+    snapshot,
+    isLoading,
+    error
+  };
+}
+function buildStreamedNote(record, noteFirstSeen) {
+  try {
+    const id = record.id().toString();
+    const metadata = record.metadata?.();
+    const senderHex = metadata?.sender?.()?.toString?.();
+    const sender = senderHex ? toBech32AccountId(senderHex) : "";
+    const assets = [];
+    let primaryAmount = 0n;
+    try {
+      const details = record.details();
+      const assetsList = details?.assets?.().fungibleAssets?.() ?? [];
+      for (const asset of assetsList) {
+        const assetId = asset.faucetId().toString();
+        const amount = BigInt(asset.amount());
+        assets.push({ assetId, amount });
+        if (primaryAmount === 0n) {
+          primaryAmount = amount;
+        }
+      }
+    } catch {
+    }
+    const attachmentData = readNoteAttachment(record);
+    const attachment = attachmentData ? attachmentData.values : null;
+    const firstSeenAt = noteFirstSeen.get(id) ?? Date.now();
+    return {
+      id,
+      sender,
+      amount: primaryAmount,
+      assets,
+      record,
+      firstSeenAt,
+      attachment
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/useTransactionHistory.ts
+var import_react8 = require("react");
+var import_miden_sdk12 = require("@miden-sdk/miden-sdk");
+function useTransactionHistory(options = {}) {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  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)(() => {
     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_react7.useMemo)(() => {
+  const idsHex = (0, import_react8.useMemo)(() => {
     if (!rawIds) return null;
     return rawIds.map(
-      (id) => normalizeHex(typeof id === "string" ? id : id.toHex())
+      (id) => normalizeHex2(typeof id === "string" ? id : id.toHex())
     );
   }, [rawIds]);
   const filter = options.filter;
   const refreshOnSync = options.refreshOnSync !== false;
-  const refetch = (0, import_react7.useCallback)(async () => {
+  const refetch = (0, import_react8.useCallback)(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
@@ -1120,7 +1521,7 @@ function useTransactionHistory(options = {}) {
         () => client.getTransactions(resolvedFilter)
       );
       const filtered = localFilterHexes ? fetched.filter(
-        (record2) => localFilterHexes.includes(normalizeHex(record2.id().toHex()))
+        (record2) => localFilterHexes.includes(normalizeHex2(record2.id().toHex()))
       ) : fetched;
       setRecords(filtered);
     } catch (err) {
@@ -1129,19 +1530,19 @@ function useTransactionHistory(options = {}) {
       setIsLoading(false);
     }
   }, [client, isReady, runExclusiveSafe, filter, rawIds, idsHex]);
-  (0, import_react7.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (!isReady) return;
     refetch();
   }, [isReady, refetch]);
-  (0, import_react7.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (!isReady || !refreshOnSync || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refreshOnSync, refetch]);
-  const record = (0, import_react7.useMemo)(() => {
+  const record = (0, import_react8.useMemo)(() => {
     if (!idsHex || idsHex.length !== 1) return null;
-    return records.find((item) => normalizeHex(item.id().toHex()) === idsHex[0]) ?? null;
+    return records.find((item) => normalizeHex2(item.id().toHex()) === idsHex[0]) ?? null;
   }, [records, idsHex]);
-  const status = (0, import_react7.useMemo)(() => {
+  const status = (0, import_react8.useMemo)(() => {
     if (!record) return null;
     const current = record.transactionStatus();
     if (current.isCommitted()) return "committed";
@@ -1163,29 +1564,29 @@ function buildFilter(filter, ids, idsHex) {
     return { filter };
   }
   if (!ids || ids.length === 0) {
-    return { filter: import_miden_sdk8.TransactionFilter.all() };
+    return { filter: import_miden_sdk12.TransactionFilter.all() };
   }
   const allTransactionIds = ids.every((id) => typeof id !== "string");
   if (allTransactionIds) {
-    return { filter: import_miden_sdk8.TransactionFilter.ids(ids) };
+    return { filter: import_miden_sdk12.TransactionFilter.ids(ids) };
   }
   return {
-    filter: import_miden_sdk8.TransactionFilter.all(),
+    filter: import_miden_sdk12.TransactionFilter.all(),
     localFilterHexes: idsHex ?? []
   };
 }
-function normalizeHex(value) {
+function normalizeHex2(value) {
   const trimmed = value.trim();
   const normalized = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed : `0x${trimmed}`;
   return normalized.toLowerCase();
 }
 
 // src/hooks/useSyncState.ts
-var import_react8 = require("react");
+var import_react9 = require("react");
 function useSyncState() {
   const { sync: triggerSync } = useMiden();
   const syncState = useSyncStateStore();
-  const sync = (0, import_react8.useCallback)(async () => {
+  const sync = (0, import_react9.useCallback)(async () => {
     await triggerSync();
   }, [triggerSync]);
   return {
@@ -1195,21 +1596,20 @@ function useSyncState() {
 }
 
 // src/hooks/useCreateWallet.ts
-var import_react9 = require("react");
-var import_miden_sdk9 = require("@miden-sdk/miden-sdk");
+var import_react10 = require("react");
+var import_miden_sdk13 = require("@miden-sdk/miden-sdk");
 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_react9.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const createWallet = (0, import_react9.useCallback)(
+  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)(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
-      await sync();
       setIsCreating(true);
       setError(null);
       try {
@@ -1242,7 +1642,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react9.useCallback)(() => {
+  const reset = (0, import_react10.useCallback)(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1258,27 +1658,27 @@ function useCreateWallet() {
 function getStorageMode(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk9.AccountStorageMode.private();
+      return import_miden_sdk13.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk9.AccountStorageMode.public();
+      return import_miden_sdk13.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk9.AccountStorageMode.network();
+      return import_miden_sdk13.AccountStorageMode.network();
     default:
-      return import_miden_sdk9.AccountStorageMode.private();
+      return import_miden_sdk13.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useCreateFaucet.ts
-var import_react10 = require("react");
-var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
+var import_react11 = 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_react10.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react10.useState)(false);
-  const [error, setError] = (0, import_react10.useState)(null);
-  const createFaucet = (0, import_react10.useCallback)(
+  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)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1317,7 +1717,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react10.useCallback)(() => {
+  const reset = (0, import_react11.useCallback)(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -1333,27 +1733,27 @@ function useCreateFaucet() {
 function getStorageMode2(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk10.AccountStorageMode.private();
+      return import_miden_sdk14.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk10.AccountStorageMode.public();
+      return import_miden_sdk14.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk10.AccountStorageMode.network();
+      return import_miden_sdk14.AccountStorageMode.network();
     default:
-      return import_miden_sdk10.AccountStorageMode.private();
+      return import_miden_sdk14.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useImportAccount.ts
-var import_react11 = require("react");
-var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
-function useImportAccount() {
+var import_react12 = require("react");
+var import_miden_sdk15 = 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_react11.useState)(null);
-  const [isImporting, setIsImporting] = (0, import_react11.useState)(false);
-  const [error, setError] = (0, import_react11.useState)(null);
-  const importAccount = (0, import_react11.useCallback)(
+  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");
@@ -1448,7 +1848,7 @@ function useImportAccount() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react11.useCallback)(() => {
+  const reset = (0, import_react12.useCallback)(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -1466,10 +1866,10 @@ function resolveAccountId(accountId) {
 }
 async function resolveAccountFile(file) {
   if (file instanceof Uint8Array) {
-    return import_miden_sdk11.AccountFile.deserialize(file);
+    return import_miden_sdk15.AccountFile.deserialize(file);
   }
   if (file instanceof ArrayBuffer) {
-    return import_miden_sdk11.AccountFile.deserialize(new Uint8Array(file));
+    return import_miden_sdk15.AccountFile.deserialize(new Uint8Array(file));
   }
   return file;
 }
@@ -1498,43 +1898,146 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-var import_react12 = require("react");
-var import_miden_sdk12 = require("@miden-sdk/miden-sdk");
+var import_react13 = require("react");
+var import_miden_sdk16 = 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
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react12.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react12.useState)(false);
-  const [stage, setStage] = (0, import_react12.useState)("idle");
-  const [error, setError] = (0, import_react12.useState)(null);
-  const send = (0, import_react12.useCallback)(
+  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)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
+      if (isBusyRef.current) {
+        throw new MidenError(
+          "A send is already in progress. Await the previous send before starting another.",
+          { code: "SEND_BUSY" }
+        );
+      }
+      isBusyRef.current = true;
       setIsLoading(true);
       setStage("executing");
       setError(null);
       try {
+        if (!options.skipSync) {
+          await sync();
+        }
         const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
-        const fromAccountId = parseAccountId(options.from);
-        const toAccountId = parseAccountId(options.to);
+        let amount = options.amount;
+        if (options.sendAll) {
+          const resolvedAmount = await runExclusiveSafe(async () => {
+            const fromId = parseAccountId(options.from);
+            const account = await client.getAccount(fromId);
+            if (!account) throw new Error("Account not found");
+            const assetIdObj = parseAccountId(options.assetId);
+            const balance = account.vault?.()?.getBalance?.(assetIdObj);
+            if (balance === void 0 || balance === null) {
+              throw new Error("Could not query account balance");
+            }
+            const bal = BigInt(balance);
+            if (bal === 0n) {
+              throw new Error("Account has zero balance for this asset");
+            }
+            return bal;
+          });
+          amount = resolvedAmount;
+        }
+        if (amount === void 0 || amount === null) {
+          throw new Error("Amount is required (provide amount or sendAll)");
+        }
         const assetId = options.assetId ?? options.faucetId ?? null;
         if (!assetId) {
           throw new Error("Asset ID is required");
         }
-        const assetIdObj = parseAccountId(assetId);
-        const txResult = await runExclusiveSafe(async () => {
-          const txRequest = client.newSendTransactionRequest(
-            fromAccountId,
-            toAccountId,
-            assetIdObj,
-            noteType,
-            options.amount,
-            options.recallHeight ?? null,
-            options.timelockHeight ?? null
+        const hasAttachment = options.attachment !== void 0 && options.attachment !== null;
+        if (hasAttachment && (options.recallHeight != null || options.timelockHeight != null)) {
+          throw new Error(
+            "recallHeight and timelockHeight are not supported when attachment is provided"
           );
-          return await client.executeTransaction(fromAccountId, txRequest);
+        }
+        const txResult = await runExclusiveSafe(async () => {
+          const fromAccountId = parseAccountId(options.from);
+          const toAccountId = parseAccountId(options.to);
+          const assetIdObj = parseAccountId(assetId);
+          let txRequest;
+          if (hasAttachment) {
+            const attachment = createNoteAttachment(options.attachment);
+            const assets = new import_miden_sdk16.NoteAssets([
+              new import_miden_sdk16.FungibleAsset(assetIdObj, amount)
+            ]);
+            const note = import_miden_sdk16.Note.createP2IDNote(
+              fromAccountId,
+              toAccountId,
+              assets,
+              noteType,
+              attachment
+            );
+            txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk16.OutputNoteArray([import_miden_sdk16.OutputNote.full(note)])).build();
+          } else {
+            txRequest = client.newSendTransactionRequest(
+              fromAccountId,
+              toAccountId,
+              assetIdObj,
+              noteType,
+              amount,
+              options.recallHeight ?? null,
+              options.timelockHeight ?? null
+            );
+          }
+          const execAccountId = parseAccountId(options.from);
+          return await client.executeTransaction(execAccountId, txRequest);
         });
         setStage("proving");
         const provenTransaction = await runExclusiveSafe(
@@ -1544,22 +2047,31 @@ function useSend() {
         const submissionHeight = await runExclusiveSafe(
           () => client.submitProvenTransaction(provenTransaction, txResult)
         );
+        const txIdHex = txResult.id().toHex();
+        const txIdString = txResult.id().toString();
+        let fullNote = null;
+        if (noteType === import_miden_sdk16.NoteType.Private) {
+          fullNote = extractFullNote(txResult);
+        }
         await runExclusiveSafe(
           () => client.applyTransaction(txResult, submissionHeight)
         );
-        const txId = txResult.id();
-        await waitForTransactionCommit(client, runExclusiveSafe, txId);
-        if (noteType === import_miden_sdk12.NoteType.Private) {
-          const fullNote = extractFullNote(txResult);
+        if (noteType === import_miden_sdk16.NoteType.Private) {
           if (!fullNote) {
             throw new Error("Missing full note for private send");
           }
-          const recipientAddress = parseAddress(options.to, toAccountId);
+          await waitForTransactionCommit(
+            client,
+            runExclusiveSafe,
+            txIdHex
+          );
+          const recipientAccountId = parseAccountId(options.to);
+          const recipientAddress = parseAddress(options.to, recipientAccountId);
           await runExclusiveSafe(
             () => client.sendPrivateNote(fullNote, recipientAddress)
           );
         }
-        const txSummary = { transactionId: txResult.id().toString() };
+        const txSummary = { transactionId: txIdString };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -1571,11 +2083,12 @@ function useSend() {
         throw error2;
       } finally {
         setIsLoading(false);
+        isBusyRef.current = false;
       }
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react12.useCallback)(() => {
+  const reset = (0, import_react13.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -1590,39 +2103,6 @@ function useSend() {
     reset
   };
 }
-function getNoteType(type) {
-  switch (type) {
-    case "private":
-      return import_miden_sdk12.NoteType.Private;
-    case "public":
-      return import_miden_sdk12.NoteType.Public;
-    case "encrypted":
-      return import_miden_sdk12.NoteType.Encrypted;
-    default:
-      return import_miden_sdk12.NoteType.Private;
-  }
-}
-async function waitForTransactionCommit(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_sdk12.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 extractFullNote(txResult) {
   try {
     const executedTx = txResult.executedTransaction?.();
@@ -1635,16 +2115,17 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-var import_react13 = require("react");
-var import_miden_sdk13 = require("@miden-sdk/miden-sdk");
+var import_react14 = 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 [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 sendMany = (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 sendMany = (0, import_react14.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1652,35 +2133,53 @@ function useMultiSend() {
       if (options.recipients.length === 0) {
         throw new Error("No recipients provided");
       }
+      if (isBusyRef.current) {
+        throw new MidenError(
+          "A send is already in progress. Await the previous send before starting another.",
+          { code: "SEND_BUSY" }
+        );
+      }
+      isBusyRef.current = true;
       setIsLoading(true);
       setStage("executing");
       setError(null);
       try {
-        const noteType = getNoteType2(options.noteType ?? DEFAULTS.NOTE_TYPE);
-        const senderId = parseAccountId(options.from);
-        const assetId = parseAccountId(options.assetId);
-        const outputs = options.recipients.map(({ to, amount }) => {
-          const receiverId = parseAccountId(to);
-          const assets = new import_miden_sdk13.NoteAssets([new import_miden_sdk13.FungibleAsset(assetId, amount)]);
-          const note = import_miden_sdk13.Note.createP2IDNote(
-            senderId,
-            receiverId,
-            assets,
-            noteType,
-            new import_miden_sdk13.NoteAttachment()
-          );
-          const recipientAddress = parseAddress(to, receiverId);
-          return {
-            outputNote: import_miden_sdk13.OutputNote.full(note),
-            note,
-            recipientAddress
-          };
-        });
-        const txRequest = new import_miden_sdk13.TransactionRequestBuilder().withOwnOutputNotes(
-          new import_miden_sdk13.OutputNoteArray(outputs.map((o) => o.outputNote))
+        if (!options.skipSync) {
+          await sync();
+        }
+        const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const outputs = options.recipients.map(
+          ({ to, amount, attachment, noteType: recipientNoteType }) => {
+            const iterSenderId = parseAccountId(options.from);
+            const iterAssetId = parseAccountId(options.assetId);
+            const receiverId = parseAccountId(to);
+            const assets = new import_miden_sdk17.NoteAssets([
+              new import_miden_sdk17.FungibleAsset(iterAssetId, amount)
+            ]);
+            const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_miden_sdk17.NoteAttachment();
+            const note = import_miden_sdk17.Note.createP2IDNote(
+              iterSenderId,
+              receiverId,
+              assets,
+              resolvedNoteType,
+              noteAttachment
+            );
+            const recipientAddress = parseAddress(to, receiverId);
+            return {
+              outputNote: import_miden_sdk17.OutputNote.full(note),
+              note,
+              recipientAddress,
+              noteType: resolvedNoteType
+            };
+          }
+        );
+        const txRequest = new import_miden_sdk17.TransactionRequestBuilder().withOwnOutputNotes(
+          new import_miden_sdk17.OutputNoteArray(outputs.map((o) => o.outputNote))
         ).build();
+        const txSenderId = parseAccountId(options.from);
         const txResult = await runExclusiveSafe(
-          () => client.executeTransaction(senderId, txRequest)
+          () => client.executeTransaction(txSenderId, txRequest)
         );
         setStage("proving");
         const provenTransaction = await runExclusiveSafe(
@@ -1690,23 +2189,27 @@ function useMultiSend() {
         const submissionHeight = await runExclusiveSafe(
           () => client.submitProvenTransaction(provenTransaction, txResult)
         );
+        const txIdHex = txResult.id().toHex();
+        const txIdString = txResult.id().toString();
         await runExclusiveSafe(
           () => client.applyTransaction(txResult, submissionHeight)
         );
-        const txId = txResult.id();
-        if (noteType === import_miden_sdk13.NoteType.Private) {
-          await waitForTransactionCommit2(
+        const hasPrivate = outputs.some((o) => o.noteType === import_miden_sdk17.NoteType.Private);
+        if (hasPrivate) {
+          await waitForTransactionCommit(
             client,
             runExclusiveSafe,
-            txId
+            txIdHex
           );
           for (const output of outputs) {
-            await runExclusiveSafe(
-              () => client.sendPrivateNote(output.note, output.recipientAddress)
-            );
+            if (output.noteType === import_miden_sdk17.NoteType.Private) {
+              await runExclusiveSafe(
+                () => client.sendPrivateNote(output.note, output.recipientAddress)
+              );
+            }
           }
         }
-        const txSummary = { transactionId: txId.toString() };
+        const txSummary = { transactionId: txIdString };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -1718,11 +2221,12 @@ function useMultiSend() {
         throw error2;
       } finally {
         setIsLoading(false);
+        isBusyRef.current = false;
       }
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react13.useCallback)(() => {
+  const reset = (0, import_react14.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -1737,71 +2241,38 @@ function useMultiSend() {
     reset
   };
 }
-function getNoteType2(type) {
-  switch (type) {
-    case "private":
-      return import_miden_sdk13.NoteType.Private;
-    case "public":
-      return import_miden_sdk13.NoteType.Public;
-    case "encrypted":
-      return import_miden_sdk13.NoteType.Encrypted;
-    default:
-      return import_miden_sdk13.NoteType.Private;
-  }
-}
-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_sdk13.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");
-}
 
 // src/hooks/useInternalTransfer.ts
-var import_react14 = require("react");
-var import_miden_sdk14 = require("@miden-sdk/miden-sdk");
+var import_react15 = require("react");
+var import_miden_sdk18 = require("@miden-sdk/miden-sdk");
 function useInternalTransfer() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  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 transferOnce = (0, import_react14.useCallback)(
+  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 = getNoteType3(options.noteType ?? DEFAULTS.NOTE_TYPE);
+      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_sdk14.NoteAssets([
-        new import_miden_sdk14.FungibleAsset(assetId, options.amount)
+      const assets = new import_miden_sdk18.NoteAssets([
+        new import_miden_sdk18.FungibleAsset(assetId, options.amount)
       ]);
-      const note = import_miden_sdk14.Note.createP2IDNote(
+      const note = import_miden_sdk18.Note.createP2IDNote(
         senderId,
         receiverId,
         assets,
         noteType,
-        new import_miden_sdk14.NoteAttachment()
+        new import_miden_sdk18.NoteAttachment()
       );
       const noteId = note.id().toString();
-      const createRequest = new import_miden_sdk14.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk14.OutputNoteArray([import_miden_sdk14.OutputNote.full(note)])).build();
+      const createRequest = new import_miden_sdk18.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk18.OutputNoteArray([import_miden_sdk18.OutputNote.full(note)])).build();
       const createTxId = await runExclusiveSafe(
         () => prover ? client.submitNewTransactionWithProver(
           senderId,
@@ -1809,7 +2280,7 @@ function useInternalTransfer() {
           prover
         ) : client.submitNewTransaction(senderId, createRequest)
       );
-      const consumeRequest = new import_miden_sdk14.TransactionRequestBuilder().withInputNotes(new import_miden_sdk14.NoteAndArgsArray([new import_miden_sdk14.NoteAndArgs(note, null)])).build();
+      const consumeRequest = new import_miden_sdk18.TransactionRequestBuilder().withInputNotes(new import_miden_sdk18.NoteAndArgsArray([new import_miden_sdk18.NoteAndArgs(note, null)])).build();
       const consumeTxId = await runExclusiveSafe(
         () => prover ? client.submitNewTransactionWithProver(
           receiverId,
@@ -1825,7 +2296,7 @@ function useInternalTransfer() {
     },
     [client, isReady, prover, runExclusiveSafe]
   );
-  const transfer = (0, import_react14.useCallback)(
+  const transfer = (0, import_react15.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1851,7 +2322,7 @@ function useInternalTransfer() {
     },
     [client, isReady, sync, transferOnce]
   );
-  const transferChain = (0, import_react14.useCallback)(
+  const transferChain = (0, import_react15.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1892,7 +2363,7 @@ function useInternalTransfer() {
     },
     [client, isReady, sync, transferOnce]
   );
-  const reset = (0, import_react14.useCallback)(() => {
+  const reset = (0, import_react15.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -1908,47 +2379,35 @@ function useInternalTransfer() {
     reset
   };
 }
-function getNoteType3(type) {
-  switch (type) {
-    case "private":
-      return import_miden_sdk14.NoteType.Private;
-    case "public":
-      return import_miden_sdk14.NoteType.Public;
-    case "encrypted":
-      return import_miden_sdk14.NoteType.Encrypted;
-    default:
-      return import_miden_sdk14.NoteType.Private;
-  }
-}
 
 // src/hooks/useWaitForCommit.ts
-var import_react15 = require("react");
-var import_miden_sdk15 = require("@miden-sdk/miden-sdk");
+var import_react16 = require("react");
+var import_miden_sdk19 = require("@miden-sdk/miden-sdk");
 function useWaitForCommit() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const waitForCommit = (0, import_react15.useCallback)(
+  const waitForCommit = (0, import_react16.useCallback)(
     async (txId, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
       const timeoutMs = Math.max(0, options?.timeoutMs ?? 1e4);
       const intervalMs = Math.max(1, options?.intervalMs ?? 1e3);
-      const targetHex = normalizeHex2(
+      const targetHex = normalizeHex3(
         typeof txId === "string" ? txId : txId.toHex()
       );
-      let waited = 0;
-      while (waited < timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
         await runExclusiveSafe(
           () => client.syncState()
         );
         const records = await runExclusiveSafe(
           () => client.getTransactions(
-            typeof txId === "string" ? import_miden_sdk15.TransactionFilter.all() : import_miden_sdk15.TransactionFilter.ids([txId])
+            typeof txId === "string" ? import_miden_sdk19.TransactionFilter.all() : import_miden_sdk19.TransactionFilter.ids([txId])
           )
         );
         const record = records.find(
-          (item) => normalizeHex2(item.id().toHex()) === targetHex
+          (item) => normalizeHex3(item.id().toHex()) === targetHex
         );
         if (record) {
           const status = record.transactionStatus();
@@ -1960,7 +2419,6 @@ function useWaitForCommit() {
           }
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
-        waited += intervalMs;
       }
       throw new Error("Timeout waiting for transaction commit");
     },
@@ -1968,18 +2426,18 @@ function useWaitForCommit() {
   );
   return { waitForCommit };
 }
-function normalizeHex2(value) {
+function normalizeHex3(value) {
   const trimmed = value.trim();
   const normalized = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed : `0x${trimmed}`;
   return normalized.toLowerCase();
 }
 
 // src/hooks/useWaitForNotes.ts
-var import_react16 = require("react");
+var import_react17 = require("react");
 function useWaitForNotes() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const waitForConsumableNotes = (0, import_react16.useCallback)(
+  const waitForConsumableNotes = (0, import_react17.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1990,7 +2448,9 @@ function useWaitForNotes() {
       const accountId = parseAccountId(options.accountId);
       let waited = 0;
       while (waited < timeoutMs) {
-        await runExclusiveSafe(() => client.syncState());
+        await runExclusiveSafe(
+          () => client.syncState()
+        );
         const notes = await runExclusiveSafe(
           () => client.getConsumableNotes(accountId)
         );
@@ -2008,16 +2468,15 @@ function useWaitForNotes() {
 }
 
 // src/hooks/useMint.ts
-var import_react17 = require("react");
-var import_miden_sdk16 = require("@miden-sdk/miden-sdk");
+var import_react18 = require("react");
 function useMint() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react17.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react17.useState)(false);
-  const [stage, setStage] = (0, import_react17.useState)("idle");
-  const [error, setError] = (0, import_react17.useState)(null);
-  const mint = (0, import_react17.useCallback)(
+  const [result, setResult] = (0, import_react18.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react18.useState)(false);
+  const [stage, setStage] = (0, import_react18.useState)("idle");
+  const [error, setError] = (0, import_react18.useState)(null);
+  const mint = (0, import_react18.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2026,7 +2485,7 @@ function useMint() {
       setStage("executing");
       setError(null);
       try {
-        const noteType = getNoteType4(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
         const targetAccountIdObj = parseAccountId(options.targetAccountId);
         const faucetIdObj = parseAccountId(options.faucetId);
         setStage("proving");
@@ -2059,7 +2518,7 @@ function useMint() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react17.useCallback)(() => {
+  const reset = (0, import_react18.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2074,30 +2533,18 @@ function useMint() {
     reset
   };
 }
-function getNoteType4(type) {
-  switch (type) {
-    case "private":
-      return import_miden_sdk16.NoteType.Private;
-    case "public":
-      return import_miden_sdk16.NoteType.Public;
-    case "encrypted":
-      return import_miden_sdk16.NoteType.Encrypted;
-    default:
-      return import_miden_sdk16.NoteType.Private;
-  }
-}
 
 // src/hooks/useConsume.ts
-var import_react18 = require("react");
-var import_miden_sdk17 = require("@miden-sdk/miden-sdk");
+var import_react19 = require("react");
+var import_miden_sdk20 = require("@miden-sdk/miden-sdk");
 function useConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react18.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react18.useState)(false);
-  const [stage, setStage] = (0, import_react18.useState)("idle");
-  const [error, setError] = (0, import_react18.useState)(null);
-  const consume = (0, import_react18.useCallback)(
+  const [result, setResult] = (0, import_react19.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react19.useState)(false);
+  const [stage, setStage] = (0, import_react19.useState)("idle");
+  const [error, setError] = (0, import_react19.useState)(null);
+  const consume = (0, import_react19.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2113,9 +2560,9 @@ function useConsume() {
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
           const noteIds = options.noteIds.map(
-            (noteId) => import_miden_sdk17.NoteId.fromHex(noteId)
+            (noteId) => import_miden_sdk20.NoteId.fromHex(noteId)
           );
-          const filter = new import_miden_sdk17.NoteFilter(import_miden_sdk17.NoteFilterTypes.List, noteIds);
+          const filter = new import_miden_sdk20.NoteFilter(import_miden_sdk20.NoteFilterTypes.List, noteIds);
           const noteRecords = await client.getInputNotes(filter);
           const notes = noteRecords.map((record) => record.toNote());
           if (notes.length === 0) {
@@ -2147,7 +2594,7 @@ function useConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react18.useCallback)(() => {
+  const reset = (0, import_react19.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2164,16 +2611,15 @@ function useConsume() {
 }
 
 // src/hooks/useSwap.ts
-var import_react19 = require("react");
-var import_miden_sdk18 = require("@miden-sdk/miden-sdk");
+var import_react20 = require("react");
 function useSwap() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react19.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react19.useState)(false);
-  const [stage, setStage] = (0, import_react19.useState)("idle");
-  const [error, setError] = (0, import_react19.useState)(null);
-  const swap = (0, import_react19.useCallback)(
+  const [result, setResult] = (0, import_react20.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react20.useState)(false);
+  const [stage, setStage] = (0, import_react20.useState)("idle");
+  const [error, setError] = (0, import_react20.useState)(null);
+  const swap = (0, import_react20.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2182,8 +2628,8 @@ function useSwap() {
       setStage("executing");
       setError(null);
       try {
-        const noteType = getNoteType5(options.noteType ?? DEFAULTS.NOTE_TYPE);
-        const paybackNoteType = getNoteType5(
+        const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const paybackNoteType = getNoteType(
           options.paybackNoteType ?? DEFAULTS.NOTE_TYPE
         );
         const accountIdObj = parseAccountId(options.accountId);
@@ -2222,7 +2668,7 @@ function useSwap() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react19.useCallback)(() => {
+  const reset = (0, import_react20.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2237,41 +2683,40 @@ function useSwap() {
     reset
   };
 }
-function getNoteType5(type) {
-  switch (type) {
-    case "private":
-      return import_miden_sdk18.NoteType.Private;
-    case "public":
-      return import_miden_sdk18.NoteType.Public;
-    case "encrypted":
-      return import_miden_sdk18.NoteType.Encrypted;
-    default:
-      return import_miden_sdk18.NoteType.Private;
-  }
-}
 
 // src/hooks/useTransaction.ts
-var import_react20 = require("react");
+var import_react21 = require("react");
 function useTransaction() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react20.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react20.useState)(false);
-  const [stage, setStage] = (0, import_react20.useState)("idle");
-  const [error, setError] = (0, import_react20.useState)(null);
-  const execute = (0, import_react20.useCallback)(
+  const isBusyRef = (0, import_react21.useRef)(false);
+  const [result, setResult] = (0, import_react21.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react21.useState)(false);
+  const [stage, setStage] = (0, import_react21.useState)("idle");
+  const [error, setError] = (0, import_react21.useState)(null);
+  const execute = (0, import_react21.useCallback)(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
       }
+      if (isBusyRef.current) {
+        throw new MidenError(
+          "A transaction is already in progress. Await the previous transaction before starting another.",
+          { code: "SEND_BUSY" }
+        );
+      }
+      isBusyRef.current = true;
       setIsLoading(true);
       setStage("executing");
       setError(null);
       try {
+        if (!options.skipSync) {
+          await sync();
+        }
+        const txRequest = await resolveRequest(options.request, client);
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
           const accountIdObj = resolveAccountId2(options.accountId);
-          const txRequest = await resolveRequest(options.request, client);
           const txId = prover ? await client.submitNewTransactionWithProver(
             accountIdObj,
             txRequest,
@@ -2290,11 +2735,12 @@ function useTransaction() {
         throw error2;
       } finally {
         setIsLoading(false);
+        isBusyRef.current = false;
       }
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react20.useCallback)(() => {
+  const reset = (0, import_react21.useCallback)(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2319,17 +2765,339 @@ async function resolveRequest(request, client) {
   return request;
 }
 
+// src/hooks/useSessionAccount.ts
+var import_react22 = require("react");
+var import_miden_sdk21 = require("@miden-sdk/miden-sdk");
+function useSessionAccount(options) {
+  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 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);
+  fundRef.current = options.fund;
+  (0, import_react22.useEffect)(() => {
+    try {
+      const stored = localStorage.getItem(`${storagePrefix}:accountId`);
+      const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
+      if (stored && stored.length > 0) {
+        const validationId = parseAccountId(stored);
+        validationId?.free?.();
+        setSessionAccountId(stored);
+        if (storedReady === "true") {
+          setStep("ready");
+        }
+      }
+    } catch {
+      localStorage.removeItem(`${storagePrefix}:accountId`);
+      localStorage.removeItem(`${storagePrefix}:ready`);
+    }
+  }, [storagePrefix]);
+  const initialize = (0, import_react22.useCallback)(async () => {
+    if (!client || !isReady) {
+      throw new Error("Miden client is not ready");
+    }
+    if (isBusyRef.current) {
+      throw new MidenError(
+        "Session account initialization is already in progress.",
+        { code: "OPERATION_BUSY" }
+      );
+    }
+    isBusyRef.current = true;
+    cancelledRef.current = false;
+    setError(null);
+    try {
+      let walletId = sessionAccountId;
+      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;
+        });
+        if (cancelledRef.current) return;
+        walletId = wallet.id().toString();
+        setSessionAccountId(walletId);
+        localStorage.setItem(`${storagePrefix}:accountId`, walletId);
+      }
+      setStep("funding");
+      await fundRef.current(walletId);
+      if (cancelledRef.current) return;
+      setStep("consuming");
+      await waitAndConsume(
+        client,
+        runExclusiveSafe,
+        walletId,
+        pollIntervalMs,
+        maxWaitMs,
+        cancelledRef
+      );
+      if (cancelledRef.current) return;
+      setStep("ready");
+      localStorage.setItem(`${storagePrefix}:ready`, "true");
+      await sync();
+    } catch (err) {
+      if (!cancelledRef.current) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStep("idle");
+        throw error2;
+      }
+    } finally {
+      isBusyRef.current = false;
+    }
+  }, [
+    client,
+    isReady,
+    sync,
+    runExclusiveSafe,
+    sessionAccountId,
+    storageMode,
+    mutable,
+    authScheme,
+    storagePrefix,
+    pollIntervalMs,
+    maxWaitMs,
+    setAccounts
+  ]);
+  const reset = (0, import_react22.useCallback)(() => {
+    cancelledRef.current = true;
+    isBusyRef.current = false;
+    setSessionAccountId(null);
+    setStep("idle");
+    setError(null);
+    localStorage.removeItem(`${storagePrefix}:accountId`);
+    localStorage.removeItem(`${storagePrefix}:ready`);
+  }, [storagePrefix]);
+  return {
+    initialize,
+    sessionAccountId,
+    isReady: step === "ready",
+    step,
+    error,
+    reset
+  };
+}
+function getStorageMode3(mode) {
+  switch (mode) {
+    case "private":
+      return import_miden_sdk21.AccountStorageMode.private();
+    case "public":
+      return import_miden_sdk21.AccountStorageMode.public();
+    default:
+      return import_miden_sdk21.AccountStorageMode.public();
+  }
+}
+async function waitAndConsume(client, runExclusiveSafe, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    if (cancelledRef.current) return;
+    await runExclusiveSafe(
+      () => 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 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;
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error("Timeout waiting for session wallet funding");
+}
+
+// src/utils/bytes.ts
+function bytesToBigInt(bytes) {
+  let result = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    result = result << 8n | BigInt(bytes[i]);
+  }
+  return result;
+}
+function bigIntToBytes(value, length) {
+  if (value < 0n) {
+    throw new RangeError("bigIntToBytes: value must be non-negative");
+  }
+  const maxValue = (1n << BigInt(length * 8)) - 1n;
+  if (value > maxValue) {
+    throw new RangeError(
+      `bigIntToBytes: value ${value} does not fit in ${length} byte(s) (max ${maxValue})`
+    );
+  }
+  const bytes = new Uint8Array(length);
+  let remaining = value;
+  for (let i = length - 1; i >= 0; i--) {
+    bytes[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return bytes;
+}
+function concatBytes(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// src/utils/walletDetection.ts
+async function waitForWalletDetection(adapter, timeoutMs = 5e3) {
+  if (adapter.readyState === "Installed") return;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      adapter.off("readyStateChange", onReady);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      adapter.off("readyStateChange", onReady);
+      reject(
+        new Error(
+          `Wallet extension not detected within ${timeoutMs}ms. Is the browser extension installed and enabled?`
+        )
+      );
+    }, timeoutMs);
+    const onReady = (state) => {
+      if (state === "Installed") settle();
+    };
+    adapter.on("readyStateChange", onReady);
+    if (adapter.readyState === "Installed") settle();
+  });
+}
+
+// src/utils/storage.ts
+async function migrateStorage(options) {
+  if (typeof window === "undefined") return false;
+  const versionKey = options.versionKey ?? "miden:storageVersion";
+  const stored = localStorage.getItem(versionKey);
+  if (stored === options.version) return false;
+  if (options.onBeforeClear) {
+    await options.onBeforeClear();
+  }
+  await clearMidenStorage();
+  localStorage.setItem(versionKey, options.version);
+  if (options.reloadOnClear !== false) {
+    window.location.reload();
+  }
+  return true;
+}
+async function clearMidenStorage() {
+  if (typeof indexedDB === "undefined") return;
+  try {
+    const databases = await indexedDB.databases();
+    const midenDbs = databases.filter(
+      (db) => db.name?.toLowerCase().includes("miden")
+    );
+    await Promise.all(
+      midenDbs.map(
+        (db) => new Promise((resolve, reject) => {
+          if (!db.name) {
+            resolve();
+            return;
+          }
+          const req = indexedDB.deleteDatabase(db.name);
+          req.onsuccess = () => resolve();
+          req.onerror = () => reject(req.error);
+          req.onblocked = () => {
+            console.warn(
+              `IndexedDB "${db.name}" delete was blocked \u2014 close other tabs using this database.`
+            );
+            resolve();
+          };
+        })
+      )
+    );
+  } catch {
+  }
+}
+function createMidenStorage(prefix) {
+  const fullKey = (key) => `${prefix}:${key}`;
+  return {
+    get(key) {
+      try {
+        const raw = localStorage.getItem(fullKey(key));
+        if (raw === null) return null;
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    set(key, value) {
+      try {
+        localStorage.setItem(fullKey(key), JSON.stringify(value));
+      } catch (e) {
+        console.warn(`Failed to write localStorage key "${fullKey(key)}":`, e);
+      }
+    },
+    remove(key) {
+      localStorage.removeItem(fullKey(key));
+    },
+    clear() {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const k = localStorage.key(i);
+        if (k?.startsWith(`${prefix}:`)) {
+          keysToRemove.push(k);
+        }
+      }
+      keysToRemove.forEach((k) => localStorage.removeItem(k));
+    }
+  };
+}
+
 // src/index.ts
 installAccountBech32();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthScheme,
   DEFAULTS,
+  MidenError,
   MidenProvider,
   SignerContext,
+  accountIdsEqual,
+  bigIntToBytes,
+  bytesToBigInt,
+  clearMidenStorage,
+  concatBytes,
+  createMidenStorage,
+  createNoteAttachment,
   formatAssetAmount,
   formatNoteSummary,
   getNoteSummary,
+  migrateStorage,
+  normalizeAccountId,
   parseAssetAmount,
+  readNoteAttachment,
   toBech32AccountId,
   useAccount,
   useAccounts,
@@ -2343,13 +3111,17 @@ installAccountBech32();
   useMidenClient,
   useMint,
   useMultiSend,
+  useNoteStream,
   useNotes,
   useSend,
+  useSessionAccount,
   useSigner,
   useSwap,
   useSyncState,
   useTransaction,
   useTransactionHistory,
   useWaitForCommit,
-  useWaitForNotes
+  useWaitForNotes,
+  waitForWalletDetection,
+  wrapWasmError
 });