@miden-sdk/react 0.13.0

package/dist/index.mjs

@@ -0,0 +1,2198 @@
+// src/types/augmentations.ts
+import "@miden-sdk/miden-sdk";
+
+// src/utils/accountBech32.ts
+import {
+  Account,
+  AccountInterface,
+  Address as Address2,
+  NetworkId
+} from "@miden-sdk/miden-sdk";
+
+// src/store/MidenStore.ts
+import { create } from "zustand";
+var initialSyncState = {
+  syncHeight: 0,
+  isSyncing: false,
+  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(),
+  isLoadingAccounts: false,
+  isLoadingNotes: false
+};
+var useMidenStore = create()((set) => ({
+  ...initialState,
+  setClient: (client) => set({
+    client,
+    isReady: true,
+    isInitializing: false,
+    initError: null
+  }),
+  setInitializing: (isInitializing) => set({ isInitializing }),
+  setInitError: (initError) => set({
+    initError,
+    isInitializing: false,
+    isReady: false
+  }),
+  setConfig: (config) => set({ config }),
+  setSyncState: (sync) => set((state) => ({
+    sync: { ...state.sync, ...sync }
+  })),
+  setAccounts: (accounts) => set({ accounts }),
+  setAccountDetails: (accountId, account) => set((state) => {
+    const newMap = new Map(state.accountDetails);
+    newMap.set(accountId, account);
+    return { accountDetails: newMap };
+  }),
+  setNotes: (notes) => set({ notes }),
+  setConsumableNotes: (consumableNotes) => set({ consumableNotes }),
+  setAssetMetadata: (assetId, metadata) => set((state) => {
+    const newMap = new Map(state.assetMetadata);
+    newMap.set(assetId, metadata);
+    return { assetMetadata: newMap };
+  }),
+  setLoadingAccounts: (isLoadingAccounts) => set({ isLoadingAccounts }),
+  setLoadingNotes: (isLoadingNotes) => set({ isLoadingNotes }),
+  reset: () => set(initialState)
+}));
+var useSyncStateStore = () => useMidenStore((state) => state.sync);
+var useAccountsStore = () => useMidenStore((state) => state.accounts);
+var useNotesStore = () => useMidenStore((state) => state.notes);
+var useConsumableNotesStore = () => useMidenStore((state) => state.consumableNotes);
+var useAssetMetadataStore = () => useMidenStore((state) => state.assetMetadata);
+
+// src/utils/accountParsing.ts
+import { AccountId, Address } from "@miden-sdk/miden-sdk";
+var normalizeAccountIdInput = (value) => value.trim().replace(/^miden:/i, "");
+var isBech32Input = (value) => value.startsWith("m") || value.startsWith("M");
+var normalizeHexInput = (value) => value.startsWith("0x") || value.startsWith("0X") ? value : `0x${value}`;
+var parseAccountIdFromString = (value) => {
+  if (isBech32Input(value)) {
+    try {
+      return Address.fromBech32(value).accountId();
+    } catch {
+      return AccountId.fromBech32(value);
+    }
+  }
+  return AccountId.fromHex(normalizeHexInput(value));
+};
+var parseAccountId = (value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const normalized = normalizeAccountIdInput(value);
+  return parseAccountIdFromString(normalized);
+};
+var parseAddress = (value, accountId) => {
+  const normalized = normalizeAccountIdInput(value);
+  if (isBech32Input(normalized)) {
+    try {
+      return Address.fromBech32(normalized);
+    } catch {
+      const resolvedAccountId2 = accountId ?? AccountId.fromBech32(normalized);
+      return Address.fromAccountId(resolvedAccountId2, "BasicWallet");
+    }
+  }
+  const resolvedAccountId = accountId ?? AccountId.fromHex(normalizeHexInput(normalized));
+  return Address.fromAccountId(resolvedAccountId, "BasicWallet");
+};
+
+// src/utils/accountBech32.ts
+var inferNetworkId = () => {
+  const { rpcUrl } = useMidenStore.getState().config;
+  if (!rpcUrl) {
+    return NetworkId.testnet();
+  }
+  const url = rpcUrl.toLowerCase();
+  if (url.includes("devnet") || url.includes("mdev")) {
+    return NetworkId.devnet();
+  }
+  if (url.includes("mainnet")) {
+    return NetworkId.mainnet();
+  }
+  if (url.includes("testnet") || url.includes("mtst")) {
+    return NetworkId.testnet();
+  }
+  return NetworkId.testnet();
+};
+var toBech32FromAccountId = (id) => {
+  try {
+    const address = Address2.fromAccountId(id, "BasicWallet");
+    return address.toBech32(inferNetworkId());
+  } catch {
+  }
+  try {
+    const maybeBech32 = id.toBech32?.(
+      inferNetworkId(),
+      AccountInterface.BasicWallet
+    );
+    if (typeof maybeBech32 === "string") {
+      return maybeBech32;
+    }
+  } catch {
+  }
+  return id.toString();
+};
+var defineBech32 = (target) => {
+  try {
+    Object.defineProperty(target, "bech32id", {
+      value: function bech32id() {
+        try {
+          const id = this.id?.();
+          if (id) {
+            return toBech32FromAccountId(id);
+          }
+        } catch {
+        }
+        const fallback = typeof this.toString === "function" ? this.toString() : "";
+        return fallback ? toBech32AccountId(fallback) : "";
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var installAccountBech32 = () => {
+  const proto = Account.prototype;
+  if (proto.bech32id) {
+    return;
+  }
+  defineBech32(proto);
+};
+var ensureAccountBech32 = (account) => {
+  if (!account) {
+    return;
+  }
+  if (typeof account.bech32id === "function") {
+    return;
+  }
+  const proto = Object.getPrototypeOf(account);
+  if (proto?.bech32id) {
+    return;
+  }
+  if (proto && defineBech32(proto)) {
+    return;
+  }
+  defineBech32(account);
+};
+var toBech32AccountId = (accountId) => {
+  try {
+    const id = parseAccountId(accountId);
+    return toBech32FromAccountId(id);
+  } catch {
+    return accountId;
+  }
+};
+
+// src/context/MidenProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  useCallback,
+  useMemo
+} from "react";
+import { WebClient } from "@miden-sdk/miden-sdk";
+
+// src/types/index.ts
+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,
+  NOTE_TYPE: "private",
+  FAUCET_DECIMALS: 8
+};
+
+// src/utils/asyncLock.ts
+var AsyncLock = class {
+  constructor() {
+    this.pending = Promise.resolve();
+  }
+  runExclusive(fn) {
+    const run = this.pending.then(fn, fn);
+    this.pending = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+};
+
+// src/utils/network.ts
+var RPC_URLS = {
+  testnet: "https://rpc.testnet.miden.io",
+  devnet: "https://rpc.devnet.miden.io",
+  localhost: "http://localhost:57291"
+};
+function resolveRpcUrl(rpcUrl) {
+  if (!rpcUrl) {
+    return void 0;
+  }
+  const normalized = rpcUrl.trim().toLowerCase();
+  if (normalized === "testnet") {
+    return RPC_URLS.testnet;
+  }
+  if (normalized === "devnet") {
+    return RPC_URLS.devnet;
+  }
+  if (normalized === "localhost" || normalized === "local") {
+    return RPC_URLS.localhost;
+  }
+  return rpcUrl;
+}
+
+// src/utils/prover.ts
+import { TransactionProver } from "@miden-sdk/miden-sdk";
+var DEFAULT_PROVER_URLS = {
+  devnet: "https://tx-prover.devnet.miden.io",
+  testnet: "https://tx-prover.testnet.miden.io"
+};
+function resolveTransactionProver(config) {
+  const { prover } = config;
+  if (!prover) {
+    return null;
+  }
+  if (typeof prover === "string") {
+    const normalized = prover.trim().toLowerCase();
+    if (normalized === "local") {
+      return 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 TransactionProver.newRemoteProver(
+        url,
+        normalizeTimeout(config.proverTimeoutMs)
+      );
+    }
+    return TransactionProver.newRemoteProver(
+      prover,
+      normalizeTimeout(config.proverTimeoutMs)
+    );
+  }
+  return createRemoteProver(prover, config.proverTimeoutMs);
+}
+function createRemoteProver(config, fallbackTimeout) {
+  const { url, timeoutMs } = config;
+  if (!url) {
+    throw new Error("Remote prover requires a URL");
+  }
+  return TransactionProver.newRemoteProver(
+    url,
+    normalizeTimeout(timeoutMs ?? fallbackTimeout)
+  );
+}
+function normalizeTimeout(timeoutMs) {
+  if (timeoutMs === void 0) {
+    return void 0;
+  }
+  if (timeoutMs === null) {
+    return null;
+  }
+  return typeof timeoutMs === "bigint" ? timeoutMs : BigInt(timeoutMs);
+}
+
+// src/context/MidenProvider.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var MidenContext = createContext(null);
+function MidenProvider({
+  children,
+  config = {},
+  loadingComponent,
+  errorComponent
+}) {
+  const {
+    client,
+    isReady,
+    isInitializing,
+    initError,
+    setClient,
+    setInitializing,
+    setInitError,
+    setConfig,
+    setSyncState
+  } = useMidenStore();
+  const syncIntervalRef = useRef(null);
+  const isInitializedRef = useRef(false);
+  const clientLockRef = useRef(new AsyncLock());
+  const resolvedConfig = useMemo(
+    () => ({
+      ...config,
+      rpcUrl: resolveRpcUrl(config.rpcUrl)
+    }),
+    [config]
+  );
+  const defaultProver = useMemo(
+    () => resolveTransactionProver(resolvedConfig),
+    [
+      resolvedConfig.prover,
+      resolvedConfig.proverTimeoutMs,
+      resolvedConfig.proverUrls?.devnet,
+      resolvedConfig.proverUrls?.testnet
+    ]
+  );
+  const runExclusive = useCallback(
+    async (fn) => clientLockRef.current.runExclusive(fn),
+    []
+  );
+  const sync = useCallback(async () => {
+    if (!client || !isReady) return;
+    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))
+        });
+      }
+    });
+  }, [client, isReady, runExclusive, setSyncState]);
+  useEffect(() => {
+    if (isInitializedRef.current) return;
+    isInitializedRef.current = true;
+    const initClient = async () => {
+      setInitializing(true);
+      setConfig(resolvedConfig);
+      try {
+        const seed = resolvedConfig.seed;
+        const webClient = await WebClient.createClient(
+          resolvedConfig.rpcUrl,
+          resolvedConfig.noteTransportUrl,
+          seed
+        );
+        setClient(webClient);
+        try {
+          const summary = await runExclusive(() => webClient.syncState());
+          setSyncState({
+            syncHeight: summary.blockNum(),
+            lastSyncTime: Date.now()
+          });
+        } catch {
+        }
+      } catch (error) {
+        setInitError(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    initClient();
+  }, [
+    runExclusive,
+    resolvedConfig,
+    setClient,
+    setConfig,
+    setInitError,
+    setInitializing,
+    setSyncState
+  ]);
+  useEffect(() => {
+    if (!isReady || !client) return;
+    const interval = config.autoSyncInterval ?? DEFAULTS.AUTO_SYNC_INTERVAL;
+    if (interval <= 0) return;
+    syncIntervalRef.current = setInterval(() => {
+      sync();
+    }, interval);
+    return () => {
+      if (syncIntervalRef.current) {
+        clearInterval(syncIntervalRef.current);
+        syncIntervalRef.current = null;
+      }
+    };
+  }, [isReady, client, config.autoSyncInterval, sync]);
+  if (isInitializing && loadingComponent) {
+    return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent });
+  }
+  if (initError && errorComponent) {
+    if (typeof errorComponent === "function") {
+      return /* @__PURE__ */ jsx(Fragment, { children: errorComponent(initError) });
+    }
+    return /* @__PURE__ */ jsx(Fragment, { children: errorComponent });
+  }
+  const contextValue = {
+    client,
+    isReady,
+    isInitializing,
+    error: initError,
+    sync,
+    runExclusive,
+    prover: defaultProver
+  };
+  return /* @__PURE__ */ jsx(MidenContext.Provider, { value: contextValue, children });
+}
+function useMiden() {
+  const context = useContext(MidenContext);
+  if (!context) {
+    throw new Error("useMiden must be used within a MidenProvider");
+  }
+  return context;
+}
+function useMidenClient() {
+  const { client, isReady } = useMiden();
+  if (!client || !isReady) {
+    throw new Error(
+      "Miden client is not ready. Make sure you are inside a MidenProvider and the client has initialized."
+    );
+  }
+  return client;
+}
+
+// src/hooks/useAccounts.ts
+import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
+
+// src/utils/runExclusive.ts
+var runExclusiveDirect = async (fn) => fn();
+
+// src/hooks/useAccounts.ts
+function useAccounts() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const accounts = useAccountsStore();
+  const isLoadingAccounts = useMidenStore((state) => state.isLoadingAccounts);
+  const setLoadingAccounts = useMidenStore((state) => state.setLoadingAccounts);
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const refetch = useCallback2(async () => {
+    if (!client || !isReady) return;
+    setLoadingAccounts(true);
+    try {
+      const fetchedAccounts = await runExclusiveSafe(
+        () => client.getAccounts()
+      );
+      setAccounts(fetchedAccounts);
+    } catch (error) {
+      console.error("Failed to fetch accounts:", error);
+    } finally {
+      setLoadingAccounts(false);
+    }
+  }, [client, isReady, runExclusive, setAccounts, setLoadingAccounts]);
+  useEffect2(() => {
+    if (isReady && accounts.length === 0) {
+      refetch();
+    }
+  }, [isReady, accounts.length, refetch]);
+  const wallets = [];
+  const faucets = [];
+  for (const account of accounts) {
+    const accountId = account.id();
+    if (isFaucetId(accountId)) {
+      faucets.push(account);
+    } else {
+      wallets.push(account);
+    }
+  }
+  return {
+    accounts,
+    wallets,
+    faucets,
+    isLoading: isLoadingAccounts,
+    error: null,
+    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
+import { useCallback as useCallback3, useEffect as useEffect4, useState, useMemo as useMemo3 } from "react";
+
+// src/hooks/useAssetMetadata.ts
+import { useEffect as useEffect3, useMemo as useMemo2 } from "react";
+import {
+  BasicFungibleFaucetComponent,
+  Endpoint,
+  RpcClient
+} from "@miden-sdk/miden-sdk";
+var inflight = /* @__PURE__ */ new Map();
+var rpcClients = /* @__PURE__ */ new Map();
+var getRpcClient = (rpcUrl) => {
+  const key = rpcUrl ?? "__default__";
+  const existing = rpcClients.get(key);
+  if (existing) return existing;
+  try {
+    const endpoint = rpcUrl ? new Endpoint(rpcUrl) : Endpoint.testnet();
+    const client = new RpcClient(endpoint);
+    rpcClients.set(key, client);
+    return client;
+  } catch {
+    return null;
+  }
+};
+var fetchAssetMetadata = async (client, 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 (!account) return null;
+    const faucet = BasicFungibleFaucetComponent.fromAccount(account);
+    const symbol = faucet.symbol().toString();
+    const decimals = faucet.decimals();
+    return { assetId, symbol, decimals };
+  } catch {
+    return null;
+  }
+};
+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);
+  const rpcClient = useMemo2(() => getRpcClient(rpcUrl), [rpcUrl]);
+  const uniqueAssetIds = useMemo2(
+    () => Array.from(new Set(assetIds.filter(Boolean))),
+    [assetIds]
+  );
+  useEffect3(() => {
+    if (!client || !isReady || 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
+        );
+        setAssetMetadata(assetId, metadata ?? { assetId });
+      }).finally(() => {
+        inflight.delete(assetId);
+      });
+      inflight.set(assetId, promise);
+    });
+  }, [
+    client,
+    isReady,
+    uniqueAssetIds,
+    assetMetadata,
+    runExclusiveSafe,
+    setAssetMetadata,
+    rpcClient
+  ]);
+  return { assetMetadata };
+}
+
+// src/hooks/useAccount.ts
+function useAccount(accountId) {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const accountDetails = useMidenStore((state) => state.accountDetails);
+  const setAccountDetails = useMidenStore((state) => state.setAccountDetails);
+  const { lastSyncTime } = useSyncStateStore();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const accountIdStr = useMemo3(() => {
+    if (!accountId) return void 0;
+    if (typeof accountId === "string") return accountId;
+    if (typeof accountId.toString === "function") {
+      return accountId.toString();
+    }
+    return String(accountId);
+  }, [accountId]);
+  const account = accountIdStr ? accountDetails.get(accountIdStr) ?? null : null;
+  const refetch = useCallback3(async () => {
+    if (!client || !isReady || !accountIdStr) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const accountIdObj = parseAccountId(accountIdStr);
+      const fetchedAccount = await runExclusiveSafe(
+        () => client.getAccount(accountIdObj)
+      );
+      if (fetchedAccount) {
+        ensureAccountBech32(fetchedAccount);
+        setAccountDetails(accountIdStr, fetchedAccount);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isReady, runExclusive, accountIdStr, setAccountDetails]);
+  useEffect4(() => {
+    if (isReady && accountIdStr && !account) {
+      refetch();
+    }
+  }, [isReady, accountIdStr, account, refetch]);
+  useEffect4(() => {
+    if (!isReady || !accountIdStr || !lastSyncTime) return;
+    refetch();
+  }, [isReady, accountIdStr, lastSyncTime, refetch]);
+  const rawAssets = useMemo3(() => {
+    if (!account) return [];
+    try {
+      const vault = account.vault();
+      const assetsList = [];
+      const vaultAssets = vault.fungibleAssets();
+      for (const asset of vaultAssets) {
+        assetsList.push({
+          assetId: asset.faucetId().toString(),
+          amount: asset.amount()
+        });
+      }
+      return assetsList;
+    } catch {
+      return [];
+    }
+  }, [account]);
+  const assetIds = useMemo3(
+    () => rawAssets.map((asset) => asset.assetId),
+    [rawAssets]
+  );
+  const { assetMetadata } = useAssetMetadata(assetIds);
+  const assets = useMemo3(
+    () => rawAssets.map((asset) => {
+      const metadata = assetMetadata.get(asset.assetId);
+      return {
+        ...asset,
+        symbol: metadata?.symbol,
+        decimals: metadata?.decimals
+      };
+    }),
+    [rawAssets, assetMetadata]
+  );
+  const getBalance = useCallback3(
+    (assetId) => {
+      const asset = assets.find((a) => a.assetId === assetId);
+      return asset?.amount ?? 0n;
+    },
+    [assets]
+  );
+  return {
+    account,
+    assets,
+    isLoading,
+    error,
+    refetch,
+    getBalance
+  };
+}
+
+// src/hooks/useNotes.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo4, useState as useState2 } from "react";
+import { NoteFilter, NoteFilterTypes } from "@miden-sdk/miden-sdk";
+
+// src/utils/amounts.ts
+var formatAssetAmount = (amount, decimals) => {
+  if (!decimals || decimals <= 0) {
+    return amount.toString();
+  }
+  const factor = 10n ** BigInt(decimals);
+  const whole = amount / factor;
+  const fraction = amount % factor;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionText = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole.toString()}.${fractionText}`;
+};
+var parseAssetAmount = (input, decimals) => {
+  const value = input.trim();
+  if (!value) {
+    throw new Error("Amount is required");
+  }
+  if (!decimals || decimals <= 0) {
+    if (value.includes(".")) {
+      throw new Error("Amount must be a whole number");
+    }
+    return BigInt(value);
+  }
+  const [wholeText, fractionText = ""] = value.split(".");
+  if (value.split(".").length > 2) {
+    throw new Error("Amount has too many decimal points");
+  }
+  const normalizedWhole = wholeText.length ? wholeText : "0";
+  if (fractionText.length > decimals) {
+    throw new Error("Amount has too many decimal places");
+  }
+  const paddedFraction = fractionText.padEnd(decimals, "0");
+  const factor = 10n ** BigInt(decimals);
+  return BigInt(normalizedWhole) * factor + BigInt(paddedFraction || "0");
+};
+
+// src/utils/notes.ts
+var getInputNoteRecord = (note) => {
+  const maybeConsumable = note;
+  if (typeof maybeConsumable.inputNoteRecord === "function") {
+    return maybeConsumable.inputNoteRecord();
+  }
+  return note;
+};
+var getNoteSummary = (note, getAssetMetadata) => {
+  try {
+    const record = getInputNoteRecord(note);
+    const id = record.id().toString();
+    const assets = [];
+    try {
+      const details = record.details();
+      const assetsList = details?.assets?.().fungibleAssets?.() ?? [];
+      for (const asset of assetsList) {
+        const assetId = asset.faucetId().toString();
+        const metadata2 = getAssetMetadata?.(assetId);
+        assets.push({
+          assetId,
+          amount: BigInt(asset.amount()),
+          symbol: metadata2?.symbol,
+          decimals: metadata2?.decimals
+        });
+      }
+    } catch {
+    }
+    const metadata = record.metadata?.();
+    const senderHex = metadata?.sender?.()?.toString?.();
+    const sender = senderHex ? toBech32AccountId(senderHex) : void 0;
+    return { id, assets, sender };
+  } catch {
+    return null;
+  }
+};
+var formatNoteSummary = (summary, formatAsset = (asset) => `${formatAssetAmount(asset.amount, asset.decimals)} ${asset.symbol ?? asset.assetId}`) => {
+  if (!summary.assets.length) {
+    return summary.id;
+  }
+  const assetsText = summary.assets.map(formatAsset).join(" + ");
+  return summary.sender ? `${assetsText} from ${summary.sender}` : assetsText;
+};
+
+// src/hooks/useNotes.ts
+function useNotes(options) {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const notes = useNotesStore();
+  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 { lastSyncTime } = useSyncStateStore();
+  const [error, setError] = useState2(null);
+  const refetch = useCallback4(async () => {
+    if (!client || !isReady) return;
+    setLoadingNotes(true);
+    setError(null);
+    try {
+      const { fetchedNotes, fetchedConsumable } = await runExclusiveSafe(
+        async () => {
+          const filterType = getNoteFilterType(options?.status);
+          const filter = new NoteFilter(filterType);
+          const notesResult = await client.getInputNotes(filter);
+          let consumableResult;
+          if (options?.accountId) {
+            const accountIdObj = parseAccountId(options.accountId);
+            consumableResult = await client.getConsumableNotes(accountIdObj);
+          } else {
+            consumableResult = await client.getConsumableNotes();
+          }
+          return {
+            fetchedNotes: notesResult,
+            fetchedConsumable: consumableResult
+          };
+        }
+      );
+      setNotes(fetchedNotes);
+      setConsumableNotes(fetchedConsumable);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoadingNotes(false);
+    }
+  }, [
+    client,
+    isReady,
+    runExclusive,
+    options?.status,
+    options?.accountId,
+    setLoadingNotes,
+    setNotes,
+    setConsumableNotes
+  ]);
+  useEffect5(() => {
+    if (isReady && notes.length === 0) {
+      refetch();
+    }
+  }, [isReady, notes.length, refetch]);
+  useEffect5(() => {
+    if (!isReady || !lastSyncTime) return;
+    refetch();
+  }, [isReady, lastSyncTime, refetch]);
+  const noteAssetIds = useMemo4(() => {
+    const ids = /* @__PURE__ */ new Set();
+    const collect = (note) => {
+      const summary = getNoteSummary(note);
+      if (!summary) return;
+      summary.assets.forEach((asset) => ids.add(asset.assetId));
+    };
+    notes.forEach(collect);
+    consumableNotes.forEach(collect);
+    return Array.from(ids);
+  }, [notes, consumableNotes]);
+  const { assetMetadata } = useAssetMetadata(noteAssetIds);
+  const getMetadata = useCallback4(
+    (assetId) => assetMetadata.get(assetId),
+    [assetMetadata]
+  );
+  const noteSummaries = useMemo4(
+    () => notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean),
+    [notes, getMetadata]
+  );
+  const consumableNoteSummaries = useMemo4(
+    () => consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean),
+    [consumableNotes, getMetadata]
+  );
+  return {
+    notes,
+    consumableNotes,
+    noteSummaries,
+    consumableNoteSummaries,
+    isLoading: isLoadingNotes,
+    error,
+    refetch
+  };
+}
+function getNoteFilterType(status) {
+  switch (status) {
+    case "consumed":
+      return NoteFilterTypes.Consumed;
+    case "committed":
+      return NoteFilterTypes.Committed;
+    case "expected":
+      return NoteFilterTypes.Expected;
+    case "processing":
+      return NoteFilterTypes.Processing;
+    case "all":
+    default:
+      return NoteFilterTypes.All;
+  }
+}
+
+// src/hooks/useTransactionHistory.ts
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useState as useState3 } from "react";
+import { TransactionFilter } from "@miden-sdk/miden-sdk";
+function useTransactionHistory(options = {}) {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const { lastSyncTime } = useSyncStateStore();
+  const [records, setRecords] = useState3([]);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const rawIds = useMemo5(() => {
+    if (options.id) return [options.id];
+    if (options.ids && options.ids.length > 0) return options.ids;
+    return null;
+  }, [options.id, options.ids]);
+  const idsHex = useMemo5(() => {
+    if (!rawIds) return null;
+    return rawIds.map(
+      (id) => normalizeHex(typeof id === "string" ? id : id.toHex())
+    );
+  }, [rawIds]);
+  const filter = options.filter;
+  const refreshOnSync = options.refreshOnSync !== false;
+  const refetch = useCallback5(async () => {
+    if (!client || !isReady) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const { filter: resolvedFilter, localFilterHexes } = buildFilter(
+        filter,
+        rawIds,
+        idsHex
+      );
+      const fetched = await runExclusiveSafe(
+        () => client.getTransactions(resolvedFilter)
+      );
+      const filtered = localFilterHexes ? fetched.filter(
+        (record2) => localFilterHexes.includes(normalizeHex(record2.id().toHex()))
+      ) : fetched;
+      setRecords(filtered);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isReady, runExclusiveSafe, filter, rawIds, idsHex]);
+  useEffect6(() => {
+    if (!isReady) return;
+    refetch();
+  }, [isReady, refetch]);
+  useEffect6(() => {
+    if (!isReady || !refreshOnSync || !lastSyncTime) return;
+    refetch();
+  }, [isReady, lastSyncTime, refreshOnSync, refetch]);
+  const record = useMemo5(() => {
+    if (!idsHex || idsHex.length !== 1) return null;
+    return records.find((item) => normalizeHex(item.id().toHex()) === idsHex[0]) ?? null;
+  }, [records, idsHex]);
+  const status = useMemo5(() => {
+    if (!record) return null;
+    const current = record.transactionStatus();
+    if (current.isCommitted()) return "committed";
+    if (current.isDiscarded()) return "discarded";
+    if (current.isPending()) return "pending";
+    return null;
+  }, [record]);
+  return {
+    records,
+    record,
+    status,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function buildFilter(filter, ids, idsHex) {
+  if (filter) {
+    return { filter };
+  }
+  if (!ids || ids.length === 0) {
+    return { filter: TransactionFilter.all() };
+  }
+  const allTransactionIds = ids.every((id) => typeof id !== "string");
+  if (allTransactionIds) {
+    return { filter: TransactionFilter.ids(ids) };
+  }
+  return {
+    filter: TransactionFilter.all(),
+    localFilterHexes: idsHex ?? []
+  };
+}
+function normalizeHex(value) {
+  const trimmed = value.trim();
+  const normalized = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed : `0x${trimmed}`;
+  return normalized.toLowerCase();
+}
+
+// src/hooks/useSyncState.ts
+import { useCallback as useCallback6 } from "react";
+function useSyncState() {
+  const { sync: triggerSync } = useMiden();
+  const syncState = useSyncStateStore();
+  const sync = useCallback6(async () => {
+    await triggerSync();
+  }, [triggerSync]);
+  return {
+    ...syncState,
+    sync
+  };
+}
+
+// src/hooks/useCreateWallet.ts
+import { useCallback as useCallback7, useState as useState4 } from "react";
+import { AccountStorageMode } from "@miden-sdk/miden-sdk";
+function useCreateWallet() {
+  const { client, isReady, sync, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [wallet, setWallet] = useState4(null);
+  const [isCreating, setIsCreating] = useState4(false);
+  const [error, setError] = useState4(null);
+  const createWallet = useCallback7(
+    async (options = {}) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      await sync();
+      setIsCreating(true);
+      setError(null);
+      try {
+        const storageMode = getStorageMode(
+          options.storageMode ?? DEFAULTS.STORAGE_MODE
+        );
+        const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
+        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+        const newWallet = await runExclusiveSafe(async () => {
+          const createdWallet = await client.newWallet(
+            storageMode,
+            mutable,
+            authScheme,
+            options.initSeed
+          );
+          ensureAccountBech32(createdWallet);
+          const accounts = await client.getAccounts();
+          setAccounts(accounts);
+          return createdWallet;
+        });
+        setWallet(newWallet);
+        return newWallet;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [client, isReady, runExclusive, setAccounts]
+  );
+  const reset = useCallback7(() => {
+    setWallet(null);
+    setIsCreating(false);
+    setError(null);
+  }, []);
+  return {
+    createWallet,
+    wallet,
+    isCreating,
+    error,
+    reset
+  };
+}
+function getStorageMode(mode) {
+  switch (mode) {
+    case "private":
+      return AccountStorageMode.private();
+    case "public":
+      return AccountStorageMode.public();
+    case "network":
+      return AccountStorageMode.network();
+    default:
+      return AccountStorageMode.private();
+  }
+}
+
+// src/hooks/useCreateFaucet.ts
+import { useCallback as useCallback8, useState as useState5 } from "react";
+import { AccountStorageMode as AccountStorageMode2 } from "@miden-sdk/miden-sdk";
+function useCreateFaucet() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [faucet, setFaucet] = useState5(null);
+  const [isCreating, setIsCreating] = useState5(false);
+  const [error, setError] = useState5(null);
+  const createFaucet = useCallback8(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsCreating(true);
+      setError(null);
+      try {
+        const storageMode = getStorageMode2(
+          options.storageMode ?? DEFAULTS.STORAGE_MODE
+        );
+        const decimals = options.decimals ?? DEFAULTS.FAUCET_DECIMALS;
+        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+        const newFaucet = await runExclusiveSafe(async () => {
+          const createdFaucet = await client.newFaucet(
+            storageMode,
+            false,
+            // nonFungible - currently only fungible faucets supported
+            options.tokenSymbol,
+            decimals,
+            options.maxSupply,
+            authScheme
+          );
+          const accounts = await client.getAccounts();
+          setAccounts(accounts);
+          return createdFaucet;
+        });
+        setFaucet(newFaucet);
+        return newFaucet;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [client, isReady, runExclusive, setAccounts]
+  );
+  const reset = useCallback8(() => {
+    setFaucet(null);
+    setIsCreating(false);
+    setError(null);
+  }, []);
+  return {
+    createFaucet,
+    faucet,
+    isCreating,
+    error,
+    reset
+  };
+}
+function getStorageMode2(mode) {
+  switch (mode) {
+    case "private":
+      return AccountStorageMode2.private();
+    case "public":
+      return AccountStorageMode2.public();
+    case "network":
+      return AccountStorageMode2.network();
+    default:
+      return AccountStorageMode2.private();
+  }
+}
+
+// src/hooks/useImportAccount.ts
+import { useCallback as useCallback9, useState as useState6 } from "react";
+import { AccountFile } from "@miden-sdk/miden-sdk";
+function useImportAccount() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [account, setAccount] = useState6(null);
+  const [isImporting, setIsImporting] = useState6(false);
+  const [error, setError] = useState6(null);
+  const importAccount = useCallback9(
+    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);
+                if (!message.includes("already being tracked")) {
+                  throw err;
+                }
+              }
+              accountsAfter = await client.getAccounts();
+              if (accountFromFile) {
+                return accountFromFile;
+              }
+              const beforeIds = new Set(
+                accountsBefore.map((account2) => account2.id().toString())
+              );
+              const newAccountHeader = accountsAfter.find(
+                (account2) => !beforeIds.has(account2.id().toString())
+              );
+              const accountId = accountIdFromFile ?? newAccountHeader?.id();
+              if (accountId) {
+                const fetchedAccount = await client.getAccount(accountId);
+                if (fetchedAccount) {
+                  return fetchedAccount;
+                }
+              }
+              if (fileBytes) {
+                for (const header of accountsAfter) {
+                  const exported = await client.exportAccountFile(header.id());
+                  const exportedBytes = getAccountFileBytes(exported, exported);
+                  if (exportedBytes && bytesEqual(exportedBytes, fileBytes)) {
+                    const fetchedAccount = await client.getAccount(header.id());
+                    if (fetchedAccount) {
+                      return fetchedAccount;
+                    }
+                  }
+                }
+              }
+              throw new Error("Account not found after import");
+            }
+            case "id": {
+              const accountId = resolveAccountId(options.accountId);
+              await client.importAccountById(accountId);
+              const fetchedAccount = await client.getAccount(accountId);
+              if (!fetchedAccount) {
+                throw new Error("Account not found after import");
+              }
+              return fetchedAccount;
+            }
+            case "seed": {
+              const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
+              const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+              return await client.importPublicAccountFromSeed(
+                options.seed,
+                mutable,
+                authScheme
+              );
+            }
+          }
+        });
+        ensureAccountBech32(imported);
+        const accounts = accountsAfter ?? await client.getAccounts();
+        setAccounts(accounts);
+        setAccount(imported);
+        return imported;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [client, isReady, runExclusive, setAccounts]
+  );
+  const reset = useCallback9(() => {
+    setAccount(null);
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importAccount,
+    account,
+    isImporting,
+    error,
+    reset
+  };
+}
+function resolveAccountId(accountId) {
+  return parseAccountId(accountId);
+}
+async function resolveAccountFile(file) {
+  if (file instanceof Uint8Array) {
+    return AccountFile.deserialize(file);
+  }
+  if (file instanceof ArrayBuffer) {
+    return AccountFile.deserialize(new Uint8Array(file));
+  }
+  return file;
+}
+function getAccountFileBytes(accountFile, original) {
+  if (original instanceof Uint8Array) {
+    return original;
+  }
+  if (original instanceof ArrayBuffer) {
+    return new Uint8Array(original);
+  }
+  if (typeof accountFile.serialize === "function") {
+    return accountFile.serialize();
+  }
+  return null;
+}
+function bytesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/hooks/useSend.ts
+import { useCallback as useCallback10, useState as useState7 } from "react";
+import { NoteType, TransactionFilter as TransactionFilter2 } from "@miden-sdk/miden-sdk";
+function useSend() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState7(null);
+  const [isLoading, setIsLoading] = useState7(false);
+  const [stage, setStage] = useState7("idle");
+  const [error, setError] = useState7(null);
+  const send = useCallback10(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const fromAccountId = parseAccountId(options.from);
+        const toAccountId = parseAccountId(options.to);
+        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
+          );
+          return await client.executeTransaction(fromAccountId, txRequest);
+        });
+        setStage("proving");
+        const provenTransaction = await runExclusiveSafe(
+          () => client.proveTransaction(txResult, prover ?? void 0)
+        );
+        setStage("submitting");
+        const submissionHeight = await runExclusiveSafe(
+          () => client.submitProvenTransaction(provenTransaction, txResult)
+        );
+        await runExclusiveSafe(
+          () => client.applyTransaction(txResult, submissionHeight)
+        );
+        const txId = txResult.id();
+        await waitForTransactionCommit(client, runExclusiveSafe, txId);
+        if (noteType === NoteType.Private) {
+          const fullNote = extractFullNote(txResult);
+          if (!fullNote) {
+            throw new Error("Missing full note for private send");
+          }
+          const recipientAddress = parseAddress(options.to, toAccountId);
+          await runExclusiveSafe(
+            () => client.sendPrivateNote(fullNote, recipientAddress)
+          );
+        }
+        const txSummary = { transactionId: txResult.id().toString() };
+        setStage("complete");
+        setResult(txSummary);
+        await sync();
+        return txSummary;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback10(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    send,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function getNoteType(type) {
+  switch (type) {
+    case "private":
+      return NoteType.Private;
+    case "public":
+      return NoteType.Public;
+    case "encrypted":
+      return NoteType.Encrypted;
+    default:
+      return 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(TransactionFilter2.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?.();
+    const notes = executedTx?.outputNotes?.().notes?.() ?? [];
+    const note = notes[0];
+    return note?.intoFull?.() ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/useMultiSend.ts
+import { useCallback as useCallback11, useState as useState8 } from "react";
+import {
+  FungibleAsset,
+  Note,
+  NoteAssets,
+  NoteAttachment,
+  NoteType as NoteType2,
+  OutputNote,
+  OutputNoteArray,
+  TransactionFilter as TransactionFilter3,
+  TransactionRequestBuilder
+} from "@miden-sdk/miden-sdk";
+function useMultiSend() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(false);
+  const [stage, setStage] = useState8("idle");
+  const [error, setError] = useState8(null);
+  const sendMany = useCallback11(
+    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 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 NoteAssets([new FungibleAsset(assetId, amount)]);
+          const note = Note.createP2IDNote(
+            senderId,
+            receiverId,
+            assets,
+            noteType,
+            new NoteAttachment()
+          );
+          const recipientAddress = parseAddress(to, receiverId);
+          return {
+            outputNote: OutputNote.full(note),
+            note,
+            recipientAddress
+          };
+        });
+        const txRequest = new TransactionRequestBuilder().withOwnOutputNotes(
+          new OutputNoteArray(outputs.map((o) => o.outputNote))
+        ).build();
+        const txResult = await runExclusiveSafe(
+          () => client.executeTransaction(senderId, txRequest)
+        );
+        setStage("proving");
+        const provenTransaction = await runExclusiveSafe(
+          () => client.proveTransaction(txResult, prover ?? void 0)
+        );
+        setStage("submitting");
+        const submissionHeight = await runExclusiveSafe(
+          () => client.submitProvenTransaction(provenTransaction, txResult)
+        );
+        await runExclusiveSafe(
+          () => client.applyTransaction(txResult, submissionHeight)
+        );
+        const txId = txResult.id();
+        if (noteType === NoteType2.Private) {
+          await waitForTransactionCommit2(
+            client,
+            runExclusiveSafe,
+            txId
+          );
+          for (const output of outputs) {
+            await runExclusiveSafe(
+              () => client.sendPrivateNote(output.note, output.recipientAddress)
+            );
+          }
+        }
+        const txSummary = { transactionId: txId.toString() };
+        setStage("complete");
+        setResult(txSummary);
+        await sync();
+        return txSummary;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback11(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    sendMany,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function getNoteType2(type) {
+  switch (type) {
+    case "private":
+      return NoteType2.Private;
+    case "public":
+      return NoteType2.Public;
+    case "encrypted":
+      return NoteType2.Encrypted;
+    default:
+      return NoteType2.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(TransactionFilter3.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
+import { useCallback as useCallback12, useState as useState9 } from "react";
+import {
+  FungibleAsset as FungibleAsset2,
+  Note as Note2,
+  NoteAndArgs,
+  NoteAndArgsArray,
+  NoteAssets as NoteAssets2,
+  NoteAttachment as NoteAttachment2,
+  NoteType as NoteType3,
+  OutputNote as OutputNote2,
+  OutputNoteArray as OutputNoteArray2,
+  TransactionRequestBuilder as TransactionRequestBuilder2
+} from "@miden-sdk/miden-sdk";
+function useInternalTransfer() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(false);
+  const [stage, setStage] = useState9("idle");
+  const [error, setError] = useState9(null);
+  const transferOnce = useCallback12(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      const noteType = getNoteType3(options.noteType ?? DEFAULTS.NOTE_TYPE);
+      const senderId = parseAccountId(options.from);
+      const receiverId = parseAccountId(options.to);
+      const assetId = parseAccountId(options.assetId);
+      const assets = new NoteAssets2([
+        new FungibleAsset2(assetId, options.amount)
+      ]);
+      const note = Note2.createP2IDNote(
+        senderId,
+        receiverId,
+        assets,
+        noteType,
+        new NoteAttachment2()
+      );
+      const noteId = note.id().toString();
+      const createRequest = new TransactionRequestBuilder2().withOwnOutputNotes(new OutputNoteArray2([OutputNote2.full(note)])).build();
+      const createTxId = await runExclusiveSafe(
+        () => prover ? client.submitNewTransactionWithProver(
+          senderId,
+          createRequest,
+          prover
+        ) : client.submitNewTransaction(senderId, createRequest)
+      );
+      const consumeRequest = new TransactionRequestBuilder2().withInputNotes(new NoteAndArgsArray([new NoteAndArgs(note, null)])).build();
+      const consumeTxId = await runExclusiveSafe(
+        () => prover ? client.submitNewTransactionWithProver(
+          receiverId,
+          consumeRequest,
+          prover
+        ) : client.submitNewTransaction(receiverId, consumeRequest)
+      );
+      return {
+        createTransactionId: createTxId.toString(),
+        consumeTransactionId: consumeTxId.toString(),
+        noteId
+      };
+    },
+    [client, isReady, prover, runExclusiveSafe]
+  );
+  const transfer = useCallback12(
+    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 = useCallback12(
+    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]
+  );
+  const reset = useCallback12(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    transfer,
+    transferChain,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function getNoteType3(type) {
+  switch (type) {
+    case "private":
+      return NoteType3.Private;
+    case "public":
+      return NoteType3.Public;
+    case "encrypted":
+      return NoteType3.Encrypted;
+    default:
+      return NoteType3.Private;
+  }
+}
+
+// src/hooks/useWaitForCommit.ts
+import { useCallback as useCallback13 } from "react";
+import { TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk";
+function useWaitForCommit() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const waitForCommit = useCallback13(
+    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(
+        typeof txId === "string" ? txId : txId.toHex()
+      );
+      let waited = 0;
+      while (waited < timeoutMs) {
+        await runExclusiveSafe(
+          () => client.syncState()
+        );
+        const records = await runExclusiveSafe(
+          () => client.getTransactions(
+            typeof txId === "string" ? TransactionFilter4.all() : TransactionFilter4.ids([txId])
+          )
+        );
+        const record = records.find(
+          (item) => normalizeHex2(item.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, intervalMs));
+        waited += intervalMs;
+      }
+      throw new Error("Timeout waiting for transaction commit");
+    },
+    [client, isReady, runExclusiveSafe]
+  );
+  return { waitForCommit };
+}
+function normalizeHex2(value) {
+  const trimmed = value.trim();
+  const normalized = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed : `0x${trimmed}`;
+  return normalized.toLowerCase();
+}
+
+// src/hooks/useWaitForNotes.ts
+import { useCallback as useCallback14 } from "react";
+function useWaitForNotes() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const waitForConsumableNotes = useCallback14(
+    async (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 minCount = Math.max(1, options.minCount ?? 1);
+      const accountId = parseAccountId(options.accountId);
+      let waited = 0;
+      while (waited < timeoutMs) {
+        await runExclusiveSafe(() => client.syncState());
+        const notes = await runExclusiveSafe(
+          () => client.getConsumableNotes(accountId)
+        );
+        if (notes.length >= minCount) {
+          return notes;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        waited += intervalMs;
+      }
+      throw new Error("Timeout waiting for consumable notes");
+    },
+    [client, isReady, runExclusiveSafe]
+  );
+  return { waitForConsumableNotes };
+}
+
+// src/hooks/useMint.ts
+import { useCallback as useCallback15, useState as useState10 } from "react";
+import { NoteType as NoteType4 } from "@miden-sdk/miden-sdk";
+function useMint() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [stage, setStage] = useState10("idle");
+  const [error, setError] = useState10(null);
+  const mint = useCallback15(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const noteType = getNoteType4(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const targetAccountIdObj = parseAccountId(options.targetAccountId);
+        const faucetIdObj = parseAccountId(options.faucetId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const txRequest = client.newMintTransactionRequest(
+            targetAccountIdObj,
+            faucetIdObj,
+            noteType,
+            options.amount
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            faucetIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(faucetIdObj, txRequest);
+          return { transactionId: txId.toString() };
+        });
+        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, prover, runExclusive, sync]
+  );
+  const reset = useCallback15(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    mint,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function getNoteType4(type) {
+  switch (type) {
+    case "private":
+      return NoteType4.Private;
+    case "public":
+      return NoteType4.Public;
+    case "encrypted":
+      return NoteType4.Encrypted;
+    default:
+      return NoteType4.Private;
+  }
+}
+
+// src/hooks/useConsume.ts
+import { useCallback as useCallback16, useState as useState11 } from "react";
+import { NoteFilter as NoteFilter2, NoteFilterTypes as NoteFilterTypes2, NoteId } from "@miden-sdk/miden-sdk";
+function useConsume() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState11(null);
+  const [isLoading, setIsLoading] = useState11(false);
+  const [stage, setStage] = useState11("idle");
+  const [error, setError] = useState11(null);
+  const consume = useCallback16(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      if (options.noteIds.length === 0) {
+        throw new Error("No note IDs provided");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const accountIdObj = parseAccountId(options.accountId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const noteIds = options.noteIds.map(
+            (noteId) => NoteId.fromHex(noteId)
+          );
+          const filter = new NoteFilter2(NoteFilterTypes2.List, noteIds);
+          const noteRecords = await client.getInputNotes(filter);
+          const notes = noteRecords.map((record) => record.toNote());
+          if (notes.length === 0) {
+            throw new Error("No notes found for provided IDs");
+          }
+          if (notes.length !== options.noteIds.length) {
+            throw new Error("Some notes could not be found for provided IDs");
+          }
+          const txRequest = client.newConsumeTransactionRequest(notes);
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toString() };
+        });
+        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, prover, runExclusive, sync]
+  );
+  const reset = useCallback16(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    consume,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSwap.ts
+import { useCallback as useCallback17, useState as useState12 } from "react";
+import { NoteType as NoteType5 } from "@miden-sdk/miden-sdk";
+function useSwap() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState12(null);
+  const [isLoading, setIsLoading] = useState12(false);
+  const [stage, setStage] = useState12("idle");
+  const [error, setError] = useState12(null);
+  const swap = useCallback17(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const noteType = getNoteType5(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const paybackNoteType = getNoteType5(
+          options.paybackNoteType ?? DEFAULTS.NOTE_TYPE
+        );
+        const accountIdObj = parseAccountId(options.accountId);
+        const offeredFaucetIdObj = parseAccountId(options.offeredFaucetId);
+        const requestedFaucetIdObj = parseAccountId(options.requestedFaucetId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const txRequest = client.newSwapTransactionRequest(
+            accountIdObj,
+            offeredFaucetIdObj,
+            options.offeredAmount,
+            requestedFaucetIdObj,
+            options.requestedAmount,
+            noteType,
+            paybackNoteType
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toString() };
+        });
+        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, prover, runExclusive, sync]
+  );
+  const reset = useCallback17(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    swap,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function getNoteType5(type) {
+  switch (type) {
+    case "private":
+      return NoteType5.Private;
+    case "public":
+      return NoteType5.Public;
+    case "encrypted":
+      return NoteType5.Encrypted;
+    default:
+      return NoteType5.Private;
+  }
+}
+
+// src/hooks/useTransaction.ts
+import { useCallback as useCallback18, useState as useState13 } from "react";
+function useTransaction() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const [result, setResult] = useState13(null);
+  const [isLoading, setIsLoading] = useState13(false);
+  const [stage, setStage] = useState13("idle");
+  const [error, setError] = useState13(null);
+  const execute = useCallback18(
+    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 runExclusiveSafe(async () => {
+          const accountIdObj = resolveAccountId2(options.accountId);
+          const txRequest = await resolveRequest(options.request, client);
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toString() };
+        });
+        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, prover, runExclusive, sync]
+  );
+  const reset = useCallback18(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    execute,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+function resolveAccountId2(accountId) {
+  return parseAccountId(accountId);
+}
+async function resolveRequest(request, client) {
+  if (typeof request === "function") {
+    return await request(client);
+  }
+  return request;
+}
+
+// src/index.ts
+installAccountBech32();
+export {
+  DEFAULTS,
+  MidenProvider,
+  formatAssetAmount,
+  formatNoteSummary,
+  getNoteSummary,
+  parseAssetAmount,
+  toBech32AccountId,
+  useAccount,
+  useAccounts,
+  useAssetMetadata,
+  useConsume,
+  useCreateFaucet,
+  useCreateWallet,
+  useImportAccount,
+  useInternalTransfer,
+  useMiden,
+  useMidenClient,
+  useMint,
+  useMultiSend,
+  useNotes,
+  useSend,
+  useSwap,
+  useSyncState,
+  useTransaction,
+  useTransactionHistory,
+  useWaitForCommit,
+  useWaitForNotes
+};