@miden-sdk/react 0.14.2 → 0.14.4

package/dist/lazy.js

@@ -0,0 +1,3672 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AuthScheme: () => import_lazy4.AuthScheme,
+  DEFAULTS: () => DEFAULTS,
+  MidenError: () => MidenError,
+  MidenProvider: () => MidenProvider,
+  MultiSignerProvider: () => MultiSignerProvider,
+  SignerContext: () => SignerContext,
+  SignerSlot: () => SignerSlot,
+  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,
+  useAssetMetadata: () => useAssetMetadata,
+  useCompile: () => useCompile,
+  useConsume: () => useConsume,
+  useCreateFaucet: () => useCreateFaucet,
+  useCreateWallet: () => useCreateWallet,
+  useExecuteProgram: () => useExecuteProgram,
+  useExportNote: () => useExportNote,
+  useExportStore: () => useExportStore,
+  useImportAccount: () => useImportAccount,
+  useImportNote: () => useImportNote,
+  useImportStore: () => useImportStore,
+  useMiden: () => useMiden,
+  useMidenClient: () => useMidenClient,
+  useMint: () => useMint,
+  useMultiSend: () => useMultiSend,
+  useMultiSigner: () => useMultiSigner,
+  useNoteStream: () => useNoteStream,
+  useNotes: () => useNotes,
+  useSend: () => useSend,
+  useSessionAccount: () => useSessionAccount,
+  useSigner: () => useSigner,
+  useSwap: () => useSwap,
+  useSyncControl: () => useSyncControl,
+  useSyncState: () => useSyncState,
+  useTransaction: () => useTransaction,
+  useTransactionHistory: () => useTransactionHistory,
+  useWaitForCommit: () => useWaitForCommit,
+  useWaitForNotes: () => useWaitForNotes,
+  waitForWalletDetection: () => waitForWalletDetection,
+  wrapWasmError: () => wrapWasmError
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types/augmentations.ts
+var import_lazy = require("@miden-sdk/miden-sdk/lazy");
+
+// src/utils/accountBech32.ts
+var import_lazy3 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/store/MidenStore.ts
+var import_zustand = require("zustand");
+var initialSyncState = {
+  syncHeight: 0,
+  isSyncing: false,
+  lastSyncTime: null,
+  error: null
+};
+function freshCachedState() {
+  return {
+    sync: { ...initialSyncState },
+    syncPaused: false,
+    accounts: [],
+    accountDetails: /* @__PURE__ */ new Map(),
+    notes: [],
+    consumableNotes: [],
+    assetMetadata: /* @__PURE__ */ new Map(),
+    noteFirstSeen: /* @__PURE__ */ new Map(),
+    isLoadingAccounts: false,
+    isLoadingNotes: false
+  };
+}
+function freshState() {
+  return {
+    client: null,
+    isReady: false,
+    isInitializing: false,
+    initError: null,
+    config: {},
+    signerConnected: null,
+    ...freshCachedState()
+  };
+}
+var useMidenStore = (0, import_zustand.create)()((set) => ({
+  ...freshState(),
+  setClient: (client) => set({
+    client,
+    isReady: client !== null,
+    isInitializing: false,
+    initError: null
+  }),
+  setInitializing: (isInitializing) => set({ isInitializing }),
+  setInitError: (initError) => set({
+    initError,
+    isInitializing: false,
+    isReady: false
+  }),
+  setConfig: (config) => set({ config }),
+  setSignerConnected: (signerConnected) => set({ signerConnected }),
+  setSyncState: (sync) => set((state) => ({
+    sync: { ...state.sync, ...sync }
+  })),
+  setSyncPaused: (syncPaused) => set({ syncPaused }),
+  setAccounts: (accounts) => set({ accounts }),
+  setAccountDetails: (accountId, account) => set((state) => {
+    const newMap = new Map(state.accountDetails);
+    newMap.set(accountId, account);
+    return { accountDetails: newMap };
+  }),
+  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);
+    return { assetMetadata: newMap };
+  }),
+  setLoadingAccounts: (isLoadingAccounts) => set({ isLoadingAccounts }),
+  setLoadingNotes: (isLoadingNotes) => set({ isLoadingNotes }),
+  resetInMemoryState: () => set(freshCachedState()),
+  reset: () => set(freshState())
+}));
+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);
+var useNoteFirstSeenStore = () => useMidenStore((state) => state.noteFirstSeen);
+
+// src/utils/accountParsing.ts
+var import_lazy2 = require("@miden-sdk/miden-sdk/lazy");
+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 import_lazy2.Address.fromBech32(value).accountId();
+    } catch {
+      return import_lazy2.AccountId.fromBech32(value);
+    }
+  }
+  return import_lazy2.AccountId.fromHex(normalizeHexInput(value));
+};
+var parseAccountId = (value) => {
+  if (typeof value === "string") {
+    return parseAccountIdFromString(normalizeAccountIdInput(value));
+  }
+  if (typeof value.id === "function") {
+    return value.id();
+  }
+  return value;
+};
+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) => {
+  if (typeof value !== "string") {
+    const resolvedId = accountId ?? parseAccountId(value);
+    return import_lazy2.Address.fromAccountId(resolvedId, "BasicWallet");
+  }
+  const normalized = normalizeAccountIdInput(value);
+  if (isBech32Input(normalized)) {
+    try {
+      return import_lazy2.Address.fromBech32(normalized);
+    } catch {
+      const resolvedAccountId2 = accountId ?? import_lazy2.AccountId.fromBech32(normalized);
+      return import_lazy2.Address.fromAccountId(resolvedAccountId2, "BasicWallet");
+    }
+  }
+  const resolvedAccountId = accountId ?? import_lazy2.AccountId.fromHex(normalizeHexInput(normalized));
+  return import_lazy2.Address.fromAccountId(resolvedAccountId, "BasicWallet");
+};
+
+// src/utils/accountBech32.ts
+var inferNetworkId = () => {
+  const { rpcUrl } = useMidenStore.getState().config;
+  if (!rpcUrl) {
+    return import_lazy3.NetworkId.testnet();
+  }
+  const url = rpcUrl.toLowerCase();
+  if (url.includes("devnet") || url.includes("mdev")) {
+    return import_lazy3.NetworkId.devnet();
+  }
+  if (url.includes("mainnet")) {
+    return import_lazy3.NetworkId.mainnet();
+  }
+  if (url.includes("testnet") || url.includes("mtst")) {
+    return import_lazy3.NetworkId.testnet();
+  }
+  return import_lazy3.NetworkId.testnet();
+};
+var toBech32FromAccountId = (id) => {
+  try {
+    const address = import_lazy3.Address.fromAccountId(id, "BasicWallet");
+    return address.toBech32(inferNetworkId());
+  } catch {
+  }
+  try {
+    const maybeBech32 = id.toBech32?.(
+      inferNetworkId(),
+      import_lazy3.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 = import_lazy3.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
+var import_react2 = require("react");
+var import_lazy6 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/types/index.ts
+var import_lazy4 = require("@miden-sdk/miden-sdk/lazy");
+var DEFAULTS = {
+  RPC_URL: void 0,
+  // Will use SDK's testnet default
+  AUTO_SYNC_INTERVAL: 15e3,
+  STORAGE_MODE: "private",
+  WALLET_MUTABLE: true,
+  AUTH_SCHEME: import_lazy4.AuthScheme.AuthRpoFalcon512,
+  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
+var import_lazy5 = require("@miden-sdk/miden-sdk/lazy");
+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 (isFallbackConfig(prover)) {
+    return resolveProverTarget(prover.primary, config);
+  }
+  return resolveProverTarget(prover, config);
+}
+async function proveWithFallback(proveFn, config) {
+  const primaryProver = resolveTransactionProver(config);
+  try {
+    return await proveFn(primaryProver ?? void 0);
+  } catch (primaryError) {
+    const { prover } = config;
+    if (!prover || !isFallbackConfig(prover) || !prover.fallback) {
+      throw primaryError;
+    }
+    if (prover.disableFallback?.()) {
+      throw primaryError;
+    }
+    const fallbackProver = resolveProverTarget(prover.fallback, config);
+    prover.onFallback?.();
+    return await proveFn(fallbackProver ?? void 0);
+  }
+}
+function isFallbackConfig(prover) {
+  return typeof prover === "object" && "primary" in prover;
+}
+function resolveProverTarget(target, config) {
+  if (typeof target === "string") {
+    const normalized = target.trim().toLowerCase();
+    if (normalized === "local" || normalized === "localhost") {
+      return import_lazy5.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_lazy5.TransactionProver.newRemoteProver(
+        url,
+        normalizeTimeout(config.proverTimeoutMs)
+      );
+    }
+    return import_lazy5.TransactionProver.newRemoteProver(
+      target,
+      normalizeTimeout(config.proverTimeoutMs)
+    );
+  }
+  return createRemoteProver(target, config.proverTimeoutMs);
+}
+function createRemoteProver(config, fallbackTimeout) {
+  const { url, timeoutMs } = config;
+  if (!url) {
+    throw new Error("Remote prover requires a URL");
+  }
+  return import_lazy5.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/SignerContext.ts
+var import_react = require("react");
+var SignerContext = (0, import_react.createContext)(null);
+function useSigner() {
+  return (0, import_react.useContext)(SignerContext);
+}
+
+// src/utils/signerAccount.ts
+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, AuthScheme: AuthScheme2, Word: Word2 } = await import("@miden-sdk/miden-sdk/lazy");
+  await client.syncState();
+  if (config.importAccountId) {
+    const accountId2 = parseAccountId(config.importAccountId);
+    try {
+      await client.importAccountById(accountId2);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("already being tracked")) {
+        throw e;
+      }
+    }
+    await client.syncState();
+    return config.importAccountId;
+  }
+  const commitmentWord = Word2.deserialize(config.publicKeyCommitment);
+  const seed = config.accountSeed ?? crypto.getRandomValues(new Uint8Array(32));
+  const accountType = getAccountType(config.accountType);
+  let builder = new AccountBuilder(seed).withAuthComponent(
+    AccountComponent.createAuthComponentFromCommitment(
+      commitmentWord,
+      AuthScheme2.AuthEcdsaK256Keccak
+    )
+  ).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)) {
+    try {
+      await client.importAccountById(accountId);
+      await client.syncState();
+      return accountId.toString();
+    } catch {
+    }
+  }
+  try {
+    const existing = await client.getAccount(accountId);
+    if (existing) {
+      await client.syncState();
+      return accountId.toString();
+    }
+  } catch {
+  }
+  await client.newAccount(account, false);
+  await client.syncState();
+  return accountId.toString();
+}
+
+// src/context/MidenProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MidenContext = (0, import_react2.createContext)(null);
+function MidenProvider({
+  children,
+  config = {},
+  loadingComponent,
+  errorComponent
+}) {
+  const {
+    client,
+    isReady,
+    isInitializing,
+    initError,
+    signerConnected,
+    setClient,
+    setInitializing,
+    setInitError,
+    setConfig,
+    setSyncState,
+    setSignerConnected
+  } = useMidenStore();
+  const syncIntervalRef = (0, import_react2.useRef)(null);
+  const isInitializedRef = (0, import_react2.useRef)(false);
+  const clientLockRef = (0, import_react2.useRef)(new AsyncLock());
+  const currentStoreNameRef = (0, import_react2.useRef)(null);
+  const signCbRef = (0, import_react2.useRef)(null);
+  const signerContext = useSigner();
+  const [signerAccountId, setSignerAccountId] = (0, import_react2.useState)(null);
+  const resolvedConfig = (0, import_react2.useMemo)(
+    () => ({
+      ...config,
+      rpcUrl: resolveRpcUrl(config.rpcUrl)
+    }),
+    [config]
+  );
+  const [defaultProver, setDefaultProver] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!isReady) {
+      setDefaultProver(null);
+      return;
+    }
+    setDefaultProver(resolveTransactionProver(resolvedConfig));
+  }, [
+    isReady,
+    resolvedConfig.prover,
+    resolvedConfig.proverTimeoutMs,
+    resolvedConfig.proverUrls?.devnet,
+    resolvedConfig.proverUrls?.testnet
+  ]);
+  const runExclusive = (0, import_react2.useCallback)(
+    async (fn) => clientLockRef.current.runExclusive(fn),
+    []
+  );
+  const sync = (0, import_react2.useCallback)(async () => {
+    if (!client || !isReady) return;
+    const store = useMidenStore.getState();
+    if (store.sync.isSyncing) return;
+    setSyncState({ isSyncing: true, error: null });
+    try {
+      const summary = await client.syncState();
+      const syncHeight = summary.blockNum();
+      setSyncState({
+        syncHeight,
+        isSyncing: false,
+        lastSyncTime: Date.now(),
+        error: null
+      });
+      const accounts = await client.getAccounts();
+      useMidenStore.getState().setAccounts(accounts);
+    } catch (error) {
+      setSyncState({
+        isSyncing: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }, [client, isReady, setSyncState]);
+  const signerIsConnected = signerContext?.isConnected ?? null;
+  const signerStoreName = signerContext?.storeName ?? null;
+  const signerAccountType = signerContext?.accountConfig?.accountType ?? null;
+  const signerStorageMode = signerContext?.accountConfig?.storageMode?.toString() ?? null;
+  (0, import_react2.useEffect)(() => {
+    signCbRef.current = signerContext?.signCb ?? null;
+  }, [signerContext?.signCb]);
+  const wrappedSignCb = (0, import_react2.useCallback)(
+    async (pubKey, signingInputs) => {
+      const cb = signCbRef.current;
+      if (!cb) {
+        throw new Error("Signer is disconnected. Cannot sign.");
+      }
+      return cb(pubKey, signingInputs);
+    },
+    []
+  );
+  (0, import_react2.useEffect)(() => {
+    if (signerIsConnected === null && isInitializedRef.current) return;
+    if (signerIsConnected === false) {
+      const store = useMidenStore.getState();
+      if (store.signerConnected !== false) {
+        setSignerConnected(false);
+      }
+      return;
+    }
+    if (signerIsConnected === true && signerStoreName !== null) {
+      const store = useMidenStore.getState();
+      if (currentStoreNameRef.current === signerStoreName && store.client !== null) {
+        store.client.setSignCb(wrappedSignCb);
+        setSignerConnected(true);
+        return;
+      }
+      if (currentStoreNameRef.current !== null && currentStoreNameRef.current !== signerStoreName) {
+        store.resetInMemoryState();
+        setClient(null);
+        setSignerAccountId(null);
+      }
+    }
+    let cancelled = false;
+    const initClient = async () => {
+      await runExclusive(async () => {
+        if (cancelled) return;
+        setInitializing(true);
+        setConfig(resolvedConfig);
+        try {
+          let webClient;
+          let didSignerInit = false;
+          if (signerContext && signerIsConnected === true) {
+            const storeName = `MidenClientDB_${signerContext.storeName}`;
+            signCbRef.current = signerContext.signCb;
+            webClient = await import_lazy6.WasmWebClient.createClientWithExternalKeystore(
+              resolvedConfig.rpcUrl,
+              resolvedConfig.noteTransportUrl,
+              resolvedConfig.seed,
+              storeName,
+              signerContext.getKeyCb,
+              signerContext.insertKeyCb,
+              wrappedSignCb
+            );
+            if (cancelled) return;
+            const accountId = await initializeSignerAccount(
+              webClient,
+              signerContext.accountConfig
+            );
+            if (cancelled) return;
+            setSignerAccountId(accountId);
+            didSignerInit = true;
+            currentStoreNameRef.current = signerContext.storeName;
+          } else {
+            const seed = resolvedConfig.seed;
+            webClient = await import_lazy6.WasmWebClient.createClient(
+              resolvedConfig.rpcUrl,
+              resolvedConfig.noteTransportUrl,
+              seed
+            );
+            if (cancelled) return;
+          }
+          if (!didSignerInit) {
+            try {
+              const summary = await webClient.syncState();
+              if (cancelled) return;
+              setSyncState({
+                syncHeight: summary.blockNum(),
+                lastSyncTime: Date.now()
+              });
+            } catch {
+            }
+          }
+          if (!cancelled) {
+            try {
+              const accounts = await webClient.getAccounts();
+              if (cancelled) return;
+              useMidenStore.getState().setAccounts(accounts);
+            } catch {
+            }
+          }
+          if (!cancelled) {
+            if (!signerContext) {
+              isInitializedRef.current = true;
+            }
+            setClient(webClient);
+            if (signerIsConnected === true) {
+              setSignerConnected(true);
+            }
+          }
+        } catch (error) {
+          if (!cancelled) {
+            setInitError(
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+      });
+    };
+    initClient();
+    return () => {
+      cancelled = true;
+      isInitializedRef.current = false;
+    };
+  }, [
+    runExclusive,
+    resolvedConfig,
+    setClient,
+    setConfig,
+    setInitError,
+    setInitializing,
+    setSyncState,
+    setSignerConnected,
+    signerIsConnected,
+    signerStoreName,
+    signerAccountType,
+    signerStorageMode,
+    wrappedSignCb
+    // Note: signerContext is intentionally NOT a dep — we use stable primitives
+    // (signerIsConnected, signerStoreName, signerAccountType, signerStorageMode)
+    // to avoid re-running when the signer provider creates a new object ref.
+    // signCb changes are handled by the dedicated useEffect + signCbRef above,
+    // not by this effect.
+  ]);
+  (0, import_react2.useEffect)(() => {
+    if (!isReady || !client) return;
+    const interval = config.autoSyncInterval ?? DEFAULTS.AUTO_SYNC_INTERVAL;
+    if (interval <= 0) return;
+    syncIntervalRef.current = setInterval(() => {
+      if (!useMidenStore.getState().syncPaused) {
+        sync();
+      }
+    }, interval);
+    return () => {
+      if (syncIntervalRef.current) {
+        clearInterval(syncIntervalRef.current);
+        syncIntervalRef.current = null;
+      }
+    };
+  }, [isReady, client, config.autoSyncInterval, sync]);
+  (0, import_react2.useEffect)(() => {
+    if (!isReady || !client) return;
+    const unsubscribe = client.onStateChanged?.(async () => {
+      try {
+        const accounts = await client.getAccounts();
+        useMidenStore.getState().setAccounts(accounts);
+        setSyncState({ lastSyncTime: Date.now() });
+      } catch {
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  }, [isReady, client, setSyncState]);
+  if (isInitializing && loadingComponent) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: loadingComponent });
+  }
+  if (initError && errorComponent) {
+    if (typeof errorComponent === "function") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: errorComponent(initError) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: errorComponent });
+  }
+  const contextValue = {
+    client,
+    isReady,
+    isInitializing,
+    error: initError,
+    sync,
+    runExclusive,
+    prover: defaultProver,
+    signerAccountId,
+    signerConnected
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MidenContext.Provider, { value: contextValue, children });
+}
+function useMiden() {
+  const context = (0, import_react2.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/context/MultiSignerProvider.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var MultiSignerRegistryContext = (0, import_react3.createContext)(null);
+var MultiSignerContext = (0, import_react3.createContext)(null);
+function MultiSignerProvider({ children }) {
+  const signersRef = (0, import_react3.useRef)(/* @__PURE__ */ new Map());
+  const [signersSnapshot, setSignersSnapshot] = (0, import_react3.useState)(
+    []
+  );
+  const [activeSignerName, setActiveSignerName] = (0, import_react3.useState)(null);
+  const activeSignerNameRef = (0, import_react3.useRef)(null);
+  const generationRef = (0, import_react3.useRef)(0);
+  const updateSnapshot = (0, import_react3.useCallback)(() => {
+    setSignersSnapshot(Array.from(signersRef.current.values()));
+  }, []);
+  const register = (0, import_react3.useCallback)(
+    (value) => {
+      const prev = signersRef.current.get(value.name);
+      signersRef.current.set(value.name, value);
+      if (!prev || prev.name !== value.name || prev.isConnected !== value.isConnected || prev.storeName !== value.storeName || prev.accountConfig !== value.accountConfig) {
+        updateSnapshot();
+      }
+    },
+    [updateSnapshot]
+  );
+  const unregister = (0, import_react3.useCallback)(
+    (name) => {
+      signersRef.current.delete(name);
+      setActiveSignerName((current) => current === name ? null : current);
+      updateSnapshot();
+    },
+    [updateSnapshot]
+  );
+  const registry = (0, import_react3.useMemo)(
+    () => ({ register, unregister }),
+    [register, unregister]
+  );
+  const activeSigner = activeSignerName ? signersSnapshot.find((s) => s.name === activeSignerName) ?? null : null;
+  const stableSignCb = (0, import_react3.useCallback)(
+    async (pubKey, signingInputs) => {
+      const name = activeSignerName;
+      if (!name) throw new Error("No active signer (signer was disconnected)");
+      const signer = signersRef.current.get(name);
+      if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+      return signer.signCb(pubKey, signingInputs);
+    },
+    [activeSignerName]
+  );
+  const stableConnect = (0, import_react3.useCallback)(async () => {
+    const name = activeSignerName;
+    if (!name) throw new Error("No active signer (signer was disconnected)");
+    const signer = signersRef.current.get(name);
+    if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+    return signer.connect();
+  }, [activeSignerName]);
+  const stableDisconnect = (0, import_react3.useCallback)(async () => {
+    const name = activeSignerName;
+    if (!name) throw new Error("No active signer (signer was disconnected)");
+    const signer = signersRef.current.get(name);
+    if (!signer) throw new Error(`Signer "${name}" not found in registry`);
+    return signer.disconnect();
+  }, [activeSignerName]);
+  const forwardedValue = (0, import_react3.useMemo)(() => {
+    if (!activeSigner) return null;
+    return {
+      name: activeSigner.name,
+      isConnected: activeSigner.isConnected,
+      storeName: activeSigner.storeName,
+      accountConfig: activeSigner.accountConfig,
+      signCb: stableSignCb,
+      connect: stableConnect,
+      disconnect: stableDisconnect
+    };
+  }, [
+    activeSigner?.name,
+    activeSigner?.isConnected,
+    activeSigner?.storeName,
+    activeSigner?.accountConfig,
+    stableSignCb,
+    stableConnect,
+    stableDisconnect
+  ]);
+  const setActiveName = (0, import_react3.useCallback)((name) => {
+    activeSignerNameRef.current = name;
+    setActiveSignerName(name);
+  }, []);
+  const connectSigner = (0, import_react3.useCallback)(
+    async (name) => {
+      const currentName = activeSignerNameRef.current;
+      const currentSigner = currentName ? signersRef.current.get(currentName) : null;
+      if (currentName === name && currentSigner?.isConnected) return;
+      const newSigner = signersRef.current.get(name);
+      if (!newSigner) throw new Error(`Signer "${name}" not found`);
+      const generation = ++generationRef.current;
+      setActiveName(name);
+      if (currentSigner?.isConnected) {
+        currentSigner.disconnect().catch((err) => {
+          console.warn("Failed to disconnect previous signer:", err);
+        });
+      }
+      try {
+        await newSigner.connect();
+        if (generation !== generationRef.current) return;
+      } catch (err) {
+        if (generation !== generationRef.current) return;
+        setActiveName(null);
+        throw err;
+      }
+    },
+    [setActiveName]
+  );
+  const disconnectSigner = (0, import_react3.useCallback)(async () => {
+    ++generationRef.current;
+    const currentName = activeSignerNameRef.current;
+    const signer = currentName ? signersRef.current.get(currentName) : null;
+    setActiveName(null);
+    if (signer?.isConnected) {
+      signer.disconnect().catch((err) => {
+        console.warn("Failed to disconnect signer:", err);
+      });
+    }
+  }, [setActiveName]);
+  const multiSignerValue = (0, import_react3.useMemo)(
+    () => ({
+      signers: signersSnapshot,
+      activeSigner,
+      connectSigner,
+      disconnectSigner
+    }),
+    [signersSnapshot, activeSigner, connectSigner, disconnectSigner]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SignerContext.Provider, { value: forwardedValue, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerRegistryContext.Provider, { value: registry, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerContext.Provider, { value: multiSignerValue, children }) }) });
+}
+function SignerSlot() {
+  const signerValue = useSigner();
+  const registry = (0, import_react3.useContext)(MultiSignerRegistryContext);
+  const nameRef = (0, import_react3.useRef)();
+  (0, import_react3.useEffect)(() => {
+    if (!signerValue || !registry) return;
+    nameRef.current = signerValue.name;
+    registry.register(signerValue);
+  }, [signerValue, registry]);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (nameRef.current && registry) {
+        registry.unregister(nameRef.current);
+      }
+    };
+  }, [registry]);
+  return null;
+}
+function useMultiSigner() {
+  return (0, import_react3.useContext)(MultiSignerContext);
+}
+
+// src/hooks/useAccounts.ts
+var import_react4 = require("react");
+function useAccounts() {
+  const { client, isReady } = useMiden();
+  const accounts = useAccountsStore();
+  const isLoadingAccounts = useMidenStore((state) => state.isLoadingAccounts);
+  const setLoadingAccounts = useMidenStore((state) => state.setLoadingAccounts);
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const refetch = (0, import_react4.useCallback)(async () => {
+    if (!client || !isReady) return;
+    setLoadingAccounts(true);
+    try {
+      const fetchedAccounts = await client.getAccounts();
+      setAccounts(fetchedAccounts);
+    } catch (error) {
+      console.error("Failed to fetch accounts:", error);
+    } finally {
+      setLoadingAccounts(false);
+    }
+  }, [client, isReady, setAccounts, setLoadingAccounts]);
+  (0, import_react4.useEffect)(() => {
+    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
+  };
+}
+
+// src/hooks/useAccount.ts
+var import_react6 = require("react");
+
+// src/hooks/useAssetMetadata.ts
+var import_react5 = require("react");
+var import_lazy7 = require("@miden-sdk/miden-sdk/lazy");
+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 import_lazy7.Endpoint(rpcUrl) : import_lazy7.Endpoint.testnet();
+    const client = new import_lazy7.RpcClient(endpoint);
+    rpcClients.set(key, client);
+    return client;
+  } catch {
+    return null;
+  }
+};
+var fetchAssetMetadata = async (rpcClient, assetId) => {
+  try {
+    const accountId = parseAccountId(assetId);
+    if (!isFaucetId(accountId)) return null;
+    const fetched = await rpcClient.getAccountDetails(accountId);
+    const account = fetched.account?.();
+    if (!account) return null;
+    const faucet = import_lazy7.BasicFungibleFaucetComponent.fromAccount(account);
+    const symbol = faucet.symbol().toString();
+    const decimals = faucet.decimals();
+    return { assetId, symbol, decimals };
+  } catch {
+    return null;
+  }
+};
+function useAssetMetadata(assetIds = []) {
+  const assetMetadata = useAssetMetadataStore();
+  const setAssetMetadata = useMidenStore((state) => state.setAssetMetadata);
+  const rpcUrl = useMidenStore((state) => state.config.rpcUrl);
+  const rpcClient = (0, import_react5.useMemo)(() => getRpcClient(rpcUrl), [rpcUrl]);
+  const uniqueAssetIds = (0, import_react5.useMemo)(
+    () => Array.from(new Set(assetIds.filter(Boolean))),
+    [assetIds]
+  );
+  (0, import_react5.useEffect)(() => {
+    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 = fetchAssetMetadata(rpcClient, assetId).then((metadata) => {
+        setAssetMetadata(assetId, metadata ?? { assetId });
+      }).finally(() => {
+        inflight.delete(assetId);
+      });
+      inflight.set(assetId, promise);
+    });
+  }, [uniqueAssetIds, assetMetadata, setAssetMetadata, rpcClient]);
+  return { assetMetadata };
+}
+
+// src/hooks/useAccount.ts
+function useAccount(accountId) {
+  const { client, isReady } = useMiden();
+  const accountDetails = useMidenStore((state) => state.accountDetails);
+  const setAccountDetails = useMidenStore((state) => state.setAccountDetails);
+  const { lastSyncTime } = useSyncStateStore();
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const accountIdStr = (0, import_react6.useMemo)(() => {
+    if (!accountId) return void 0;
+    if (typeof accountId === "string") return accountId;
+    return parseAccountId(accountId).toString();
+  }, [accountId]);
+  const account = accountIdStr ? accountDetails.get(accountIdStr) ?? null : null;
+  const refetch = (0, import_react6.useCallback)(async () => {
+    if (!client || !isReady || !accountIdStr) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const accountIdObj = parseAccountId(accountIdStr);
+      const fetchedAccount = await 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, accountIdStr, setAccountDetails]);
+  (0, import_react6.useEffect)(() => {
+    if (isReady && accountIdStr && !account) {
+      refetch();
+    }
+  }, [isReady, accountIdStr, account, refetch]);
+  (0, import_react6.useEffect)(() => {
+    if (!isReady || !accountIdStr || !lastSyncTime) return;
+    refetch();
+  }, [isReady, accountIdStr, lastSyncTime, refetch]);
+  const rawAssets = (0, import_react6.useMemo)(() => {
+    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 = (0, import_react6.useMemo)(
+    () => rawAssets.map((asset) => asset.assetId),
+    [rawAssets]
+  );
+  const { assetMetadata } = useAssetMetadata(assetIds);
+  const assets = (0, import_react6.useMemo)(
+    () => rawAssets.map((asset) => {
+      const metadata = assetMetadata.get(asset.assetId);
+      return {
+        ...asset,
+        symbol: metadata?.symbol,
+        decimals: metadata?.decimals
+      };
+    }),
+    [rawAssets, assetMetadata]
+  );
+  const getBalance = (0, import_react6.useCallback)(
+    (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
+var import_react7 = require("react");
+var import_lazy9 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/utils/amounts.ts
+var formatAssetAmount = (amount, decimals) => {
+  const amt = BigInt(amount);
+  if (!decimals || decimals <= 0) {
+    return amt.toString();
+  }
+  const factor = 10n ** BigInt(decimals);
+  const whole = amt / factor;
+  const fraction = amt % 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/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_lazy8 = require("@miden-sdk/miden-sdk/lazy");
+function getNoteFilterType(status) {
+  switch (status) {
+    case "consumed":
+      return import_lazy8.NoteFilterTypes.Consumed;
+    case "committed":
+      return import_lazy8.NoteFilterTypes.Committed;
+    case "expected":
+      return import_lazy8.NoteFilterTypes.Expected;
+    case "processing":
+      return import_lazy8.NoteFilterTypes.Processing;
+    case "all":
+    default:
+      return import_lazy8.NoteFilterTypes.All;
+  }
+}
+function getNoteType(type) {
+  switch (type) {
+    case "private":
+      return import_lazy8.NoteType.Private;
+    case "public":
+      return import_lazy8.NoteType.Public;
+    default:
+      return import_lazy8.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_lazy8.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 } = useMiden();
+  const notes = useNotesStore();
+  const consumableNotes = useConsumableNotesStore();
+  const isLoadingNotes = useMidenStore((state) => state.isLoadingNotes);
+  const setLoadingNotes = useMidenStore((state) => state.setLoadingNotes);
+  const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
+  const setConsumableNotesIfChanged = useMidenStore(
+    (state) => state.setConsumableNotesIfChanged
+  );
+  const { lastSyncTime } = useSyncStateStore();
+  const [error, setError] = (0, import_react7.useState)(null);
+  const refetch = (0, import_react7.useCallback)(async () => {
+    if (!client || !isReady) return;
+    setLoadingNotes(true);
+    setError(null);
+    try {
+      const filterType = getNoteFilterType(options?.status);
+      const filter = new import_lazy9.NoteFilter(filterType);
+      const fetchedNotes = await client.getInputNotes(filter);
+      let fetchedConsumable;
+      if (options?.accountId) {
+        const accountIdObj = parseAccountId(options.accountId);
+        fetchedConsumable = await client.getConsumableNotes(accountIdObj);
+      } else {
+        fetchedConsumable = await client.getConsumableNotes();
+      }
+      setNotesIfChanged(fetchedNotes);
+      setConsumableNotesIfChanged(fetchedConsumable);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoadingNotes(false);
+    }
+  }, [
+    client,
+    isReady,
+    options?.status,
+    options?.accountId,
+    setLoadingNotes,
+    setNotesIfChanged,
+    setConsumableNotesIfChanged
+  ]);
+  (0, import_react7.useEffect)(() => {
+    if (isReady && notes.length === 0) {
+      refetch();
+    }
+  }, [isReady, notes.length, refetch]);
+  (0, import_react7.useEffect)(() => {
+    if (!isReady || !lastSyncTime) return;
+    refetch();
+  }, [isReady, lastSyncTime, refetch]);
+  const noteAssetIds = (0, import_react7.useMemo)(() => {
+    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 = (0, import_react7.useCallback)(
+    (assetId) => assetMetadata.get(assetId),
+    [assetMetadata]
+  );
+  const normalizedSender = (0, import_react7.useMemo)(() => {
+    if (!options?.sender) return null;
+    try {
+      return normalizeAccountId(options.sender);
+    } catch {
+      return options.sender;
+    }
+  }, [options?.sender]);
+  const excludeIdsKey = (0, import_react7.useMemo)(() => {
+    if (!options?.excludeIds || options.excludeIds.length === 0) return "";
+    return [...options.excludeIds].sort().join("\0");
+  }, [options?.excludeIds]);
+  const filterBySender = (0, import_react7.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_react7.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_react7.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,
+    noteSummaries,
+    consumableNoteSummaries,
+    isLoading: isLoadingNotes,
+    error,
+    refetch
+  };
+}
+
+// src/hooks/useNoteStream.ts
+var import_react8 = require("react");
+var import_lazy11 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/utils/noteAttachment.ts
+var import_lazy10 = require("@miden-sdk/miden-sdk/lazy");
+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_lazy10.NoteAttachmentKind.None) return null;
+    if (kind === import_lazy10.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_lazy10.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_lazy10.NoteAttachment();
+  }
+  const scheme = import_lazy10.NoteAttachmentScheme.none();
+  if (bigints.length <= 4) {
+    while (bigints.length < 4) {
+      bigints.push(0n);
+    }
+    const word = new import_lazy10.Word(BigUint64Array.from(bigints));
+    return import_lazy10.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_lazy10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
+  }
+  const newArray = import_lazy10.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_lazy10.NoteAttachment, scheme, words);
+}
+
+// src/hooks/useNoteStream.ts
+function useNoteStream(options = {}) {
+  const { client, isReady } = useMiden();
+  const allNotes = useNotesStore();
+  const noteFirstSeen = useNoteFirstSeenStore();
+  const { lastSyncTime } = useSyncStateStore();
+  const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const handledIdsRef = (0, import_react8.useRef)(/* @__PURE__ */ new Set());
+  const [handledVersion, setHandledVersion] = (0, import_react8.useState)(0);
+  const status = options.status ?? "committed";
+  const sender = options.sender ?? null;
+  const since = options.since;
+  const amountFilterRef = (0, import_react8.useRef)(options.amountFilter);
+  amountFilterRef.current = options.amountFilter;
+  const excludeIdsKey = (0, import_react8.useMemo)(() => {
+    if (!options.excludeIds) return "";
+    if (options.excludeIds instanceof Set)
+      return Array.from(options.excludeIds).sort().join("\0");
+    return [...options.excludeIds].sort().join("\0");
+  }, [options.excludeIds]);
+  const excludeIdSet = (0, import_react8.useMemo)(() => {
+    if (!excludeIdsKey) return null;
+    return new Set(excludeIdsKey.split("\0"));
+  }, [excludeIdsKey]);
+  const refetch = (0, import_react8.useCallback)(async () => {
+    if (!client || !isReady) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const filterType = getNoteFilterType(status);
+      const filter = new import_lazy11.NoteFilter(filterType);
+      const fetched = await client.getInputNotes(filter);
+      setNotesIfChanged(fetched);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isReady, status, setNotesIfChanged]);
+  (0, import_react8.useEffect)(() => {
+    if (isReady) {
+      refetch();
+    }
+  }, [isReady, lastSyncTime, refetch]);
+  const streamedNotes = (0, import_react8.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_react8.useMemo)(
+    () => streamedNotes.length > 0 ? streamedNotes[streamedNotes.length - 1] : null,
+    [streamedNotes]
+  );
+  const markHandled = (0, import_react8.useCallback)((noteId) => {
+    handledIdsRef.current = new Set(handledIdsRef.current).add(noteId);
+    setHandledVersion((v) => v + 1);
+  }, []);
+  const markAllHandled = (0, import_react8.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_react8.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_react9 = require("react");
+var import_lazy12 = require("@miden-sdk/miden-sdk/lazy");
+function useTransactionHistory(options = {}) {
+  const { client, isReady } = useMiden();
+  const { lastSyncTime } = useSyncStateStore();
+  const [records, setRecords] = (0, import_react9.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const rawIds = (0, import_react9.useMemo)(() => {
+    if (options.id) return [options.id];
+    if (options.ids && options.ids.length > 0) return options.ids;
+    return null;
+  }, [options.id, options.ids]);
+  const idsHex = (0, import_react9.useMemo)(() => {
+    if (!rawIds) return null;
+    return rawIds.map(
+      (id) => normalizeHex2(typeof id === "string" ? id : id.toHex())
+    );
+  }, [rawIds]);
+  const filter = options.filter;
+  const refreshOnSync = options.refreshOnSync !== false;
+  const refetch = (0, import_react9.useCallback)(async () => {
+    if (!client || !isReady) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const { filter: resolvedFilter, localFilterHexes } = buildFilter(
+        filter,
+        rawIds,
+        idsHex
+      );
+      const fetched = await client.getTransactions(resolvedFilter);
+      const filtered = localFilterHexes ? fetched.filter(
+        (record2) => localFilterHexes.includes(normalizeHex2(record2.id().toHex()))
+      ) : fetched;
+      setRecords(filtered);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isReady, filter, rawIds, idsHex]);
+  (0, import_react9.useEffect)(() => {
+    if (!isReady) return;
+    refetch();
+  }, [isReady, refetch]);
+  (0, import_react9.useEffect)(() => {
+    if (!isReady || !refreshOnSync || !lastSyncTime) return;
+    refetch();
+  }, [isReady, lastSyncTime, refreshOnSync, refetch]);
+  const record = (0, import_react9.useMemo)(() => {
+    if (!idsHex || idsHex.length !== 1) return null;
+    return records.find((item) => normalizeHex2(item.id().toHex()) === idsHex[0]) ?? null;
+  }, [records, idsHex]);
+  const status = (0, import_react9.useMemo)(() => {
+    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: import_lazy12.TransactionFilter.all() };
+  }
+  const allTransactionIds = ids.every((id) => typeof id !== "string");
+  if (allTransactionIds) {
+    return { filter: import_lazy12.TransactionFilter.ids(ids) };
+  }
+  return {
+    filter: import_lazy12.TransactionFilter.all(),
+    localFilterHexes: idsHex ?? []
+  };
+}
+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_react10 = require("react");
+function useSyncState() {
+  const { sync: triggerSync } = useMiden();
+  const syncState = useSyncStateStore();
+  const sync = (0, import_react10.useCallback)(async () => {
+    await triggerSync();
+  }, [triggerSync]);
+  return {
+    ...syncState,
+    sync
+  };
+}
+
+// src/hooks/useCreateWallet.ts
+var import_react11 = require("react");
+var import_lazy13 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/utils/runExclusive.ts
+var runExclusiveDirect = async (fn) => fn();
+
+// src/hooks/useCreateWallet.ts
+function useCreateWallet() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [wallet, setWallet] = (0, import_react11.useState)(null);
+  const [isCreating, setIsCreating] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const createWallet = (0, import_react11.useCallback)(
+    async (options = {}) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      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 = (0, import_react11.useCallback)(() => {
+    setWallet(null);
+    setIsCreating(false);
+    setError(null);
+  }, []);
+  return {
+    createWallet,
+    wallet,
+    isCreating,
+    error,
+    reset
+  };
+}
+function getStorageMode(mode) {
+  switch (mode) {
+    case "private":
+      return import_lazy13.AccountStorageMode.private();
+    case "public":
+      return import_lazy13.AccountStorageMode.public();
+    case "network":
+      return import_lazy13.AccountStorageMode.network();
+    default:
+      return import_lazy13.AccountStorageMode.private();
+  }
+}
+
+// src/hooks/useCreateFaucet.ts
+var import_react12 = require("react");
+var import_lazy14 = require("@miden-sdk/miden-sdk/lazy");
+function useCreateFaucet() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [faucet, setFaucet] = (0, import_react12.useState)(null);
+  const [isCreating, setIsCreating] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const createFaucet = (0, import_react12.useCallback)(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      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,
+            BigInt(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 = (0, import_react12.useCallback)(() => {
+    setFaucet(null);
+    setIsCreating(false);
+    setError(null);
+  }, []);
+  return {
+    createFaucet,
+    faucet,
+    isCreating,
+    error,
+    reset
+  };
+}
+function getStorageMode2(mode) {
+  switch (mode) {
+    case "private":
+      return import_lazy14.AccountStorageMode.private();
+    case "public":
+      return import_lazy14.AccountStorageMode.public();
+    case "network":
+      return import_lazy14.AccountStorageMode.network();
+    default:
+      return import_lazy14.AccountStorageMode.private();
+  }
+}
+
+// src/hooks/useImportAccount.ts
+var import_react13 = require("react");
+var import_lazy15 = require("@miden-sdk/miden-sdk/lazy");
+
+// src/utils/errors.ts
+var MidenError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "MidenError";
+    this.code = options?.code ?? "UNKNOWN";
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var ERROR_PATTERNS = [
+  {
+    test: (msg) => msg.includes("_assertClass") || msg.includes("expected instance of"),
+    code: "WASM_CLASS_MISMATCH",
+    message: "WASM class identity mismatch. This usually means multiple copies of @miden-sdk/miden-sdk are bundled. Ensure your bundler deduplicates the package. For Vite: add resolve.dedupe and optimizeDeps.exclude for @miden-sdk/miden-sdk."
+  },
+  {
+    test: (msg) => msg.includes("null pointer") || msg.includes("already been freed") || msg.includes("dereferencing a null"),
+    code: "WASM_POINTER_CONSUMED",
+    message: "WASM object was already consumed. Some WASM-bound objects can only be passed once \u2014 if you need to reuse a value, create a fresh instance before each call."
+  },
+  {
+    test: (msg) => msg.includes("not initialized") || msg.includes("Cannot read properties of null"),
+    code: "WASM_NOT_INITIALIZED",
+    message: "Miden client is not initialized. Ensure you are inside a <MidenProvider> and the client is ready before calling SDK methods."
+  },
+  {
+    test: (msg) => msg.includes("state commitment mismatch") || msg.includes("stale state"),
+    code: "WASM_SYNC_REQUIRED",
+    message: "Account state is stale. Call sync() before executing transactions, or ensure no concurrent transactions are running against the same account."
+  }
+];
+function assertSignerConnected(signerConnected) {
+  if (signerConnected === false) {
+    throw new Error(
+      "Signer is disconnected. Reconnect your wallet to perform transactions."
+    );
+  }
+}
+function wrapWasmError(e) {
+  if (e instanceof MidenError) return e;
+  const msg = e instanceof Error ? e.message : String(e);
+  for (const pattern of ERROR_PATTERNS) {
+    if (pattern.test(msg)) {
+      return new MidenError(pattern.message, { cause: e, code: pattern.code });
+    }
+  }
+  if (e instanceof Error) return e;
+  return new Error(msg);
+}
+
+// src/hooks/useImportAccount.ts
+function useImportAccount() {
+  const { client, isReady, signerConnected } = useMiden();
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [account, setAccount] = (0, import_react13.useState)(null);
+  const [isImporting, setIsImporting] = (0, import_react13.useState)(false);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const importAccount = (0, import_react13.useCallback)(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      assertSignerConnected(signerConnected);
+      setIsImporting(true);
+      setError(null);
+      try {
+        let accountsAfter = null;
+        const imported = await (async () => {
+          switch (options.type) {
+            case "file": {
+              const accountsBefore = await client.getAccounts();
+              const accountFile = await resolveAccountFile(options.file);
+              const accountFileWithAccount = accountFile;
+              const fileBytes = getAccountFileBytes(
+                accountFileWithAccount,
+                options.file
+              );
+              const accountFromFile = typeof accountFileWithAccount.account === "function" ? accountFileWithAccount.account() : null;
+              const accountIdFromFile = accountFromFile === null && typeof accountFileWithAccount.accountId === "function" ? accountFileWithAccount.accountId() : null;
+              try {
+                await client.importAccountFile(accountFile);
+              } catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes("already being tracked")) {
+                  throw err;
+                }
+              }
+              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 = parseAccountId(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, setAccounts, signerConnected]
+  );
+  const reset = (0, import_react13.useCallback)(() => {
+    setAccount(null);
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importAccount,
+    account,
+    isImporting,
+    error,
+    reset
+  };
+}
+async function resolveAccountFile(file) {
+  if (file instanceof Uint8Array) {
+    return import_lazy15.AccountFile.deserialize(file);
+  }
+  if (file instanceof ArrayBuffer) {
+    return import_lazy15.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
+var import_react14 = require("react");
+var import_lazy16 = require("@miden-sdk/miden-sdk/lazy");
+function useSend() {
+  const { client, isReady, sync, runExclusive, prover } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const isBusyRef = (0, import_react14.useRef)(false);
+  const [result, setResult] = (0, import_react14.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react14.useState)(false);
+  const [stage, setStage] = (0, import_react14.useState)("idle");
+  const [error, setError] = (0, import_react14.useState)(null);
+  const send = (0, import_react14.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);
+        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)");
+        }
+        amount = BigInt(amount);
+        const assetId = options.assetId ?? options.faucetId ?? null;
+        if (!assetId) {
+          throw new Error("Asset ID is required");
+        }
+        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"
+          );
+        }
+        if (options.returnNote === true) {
+          const returnResult = await runExclusiveSafe(async () => {
+            const fromId = parseAccountId(options.from);
+            const toId = parseAccountId(options.to);
+            const assetObj = parseAccountId(assetId);
+            const assets = new import_lazy16.NoteAssets([
+              new import_lazy16.FungibleAsset(assetObj, BigInt(amount))
+            ]);
+            const p2idNote = import_lazy16.Note.createP2IDNote(
+              fromId,
+              toId,
+              assets,
+              noteType,
+              new import_lazy16.NoteAttachment()
+            );
+            const ownOutputs = new import_lazy16.NoteArray();
+            ownOutputs.push(p2idNote);
+            const txRequest = new import_lazy16.TransactionRequestBuilder().withOwnOutputNotes(ownOutputs).build();
+            const execFromId = parseAccountId(options.from);
+            const txId = prover ? await client.submitNewTransactionWithProver(
+              execFromId,
+              txRequest,
+              prover
+            ) : await client.submitNewTransaction(execFromId, txRequest);
+            return { txId: txId.toString(), note: p2idNote };
+          });
+          setStage("complete");
+          setResult(returnResult);
+          await sync();
+          return returnResult;
+        }
+        const txResult = await runExclusiveSafe(async () => {
+          const fromAccountId = parseAccountId(options.from);
+          const toAccountId = parseAccountId(options.to);
+          const assetIdObj = parseAccountId(assetId);
+          let txRequest;
+          if (hasAttachment) {
+            const attachment = createNoteAttachment(options.attachment);
+            const assets = new import_lazy16.NoteAssets([
+              new import_lazy16.FungibleAsset(assetIdObj, amount)
+            ]);
+            const note = import_lazy16.Note.createP2IDNote(
+              fromAccountId,
+              toAccountId,
+              assets,
+              noteType,
+              attachment
+            );
+            txRequest = new import_lazy16.TransactionRequestBuilder().withOwnOutputNotes(new import_lazy16.NoteArray([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 proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveSafe(
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+          ),
+          proverConfig
+        );
+        setStage("submitting");
+        const submissionHeight = await runExclusiveSafe(
+          () => client.submitProvenTransaction(provenTransaction, txResult)
+        );
+        const txIdHex = txResult.id().toHex();
+        const txIdString = txResult.id().toString();
+        let fullNote = null;
+        if (noteType === import_lazy16.NoteType.Private) {
+          fullNote = extractFullNote(txResult);
+        }
+        await runExclusiveSafe(
+          () => client.applyTransaction(txResult, submissionHeight)
+        );
+        if (noteType === import_lazy16.NoteType.Private) {
+          if (!fullNote) {
+            throw new Error("Missing full note for private send");
+          }
+          await waitForTransactionCommit(
+            client,
+            runExclusiveSafe,
+            txIdHex
+          );
+          const recipientAccountId = parseAccountId(options.to);
+          const recipientAddress = parseAddress(options.to, recipientAccountId);
+          await runExclusiveSafe(
+            () => client.sendPrivateNote(fullNote, recipientAddress)
+          );
+        }
+        const sendResult = {
+          txId: txIdString,
+          note: null
+        };
+        setStage("complete");
+        setResult(sendResult);
+        await sync();
+        return sendResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+        isBusyRef.current = false;
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = (0, import_react14.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    send,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+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
+var import_react15 = require("react");
+var import_lazy17 = require("@miden-sdk/miden-sdk/lazy");
+function useMultiSend() {
+  const { client, isReady, sync, prover, signerConnected } = useMiden();
+  const isBusyRef = (0, import_react15.useRef)(false);
+  const [result, setResult] = (0, import_react15.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react15.useState)(false);
+  const [stage, setStage] = (0, import_react15.useState)("idle");
+  const [error, setError] = (0, import_react15.useState)(null);
+  const sendMany = (0, import_react15.useCallback)(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      assertSignerConnected(signerConnected);
+      if (options.recipients.length === 0) {
+        throw new Error("No recipients provided");
+      }
+      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 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_lazy17.NoteAssets([
+              new import_lazy17.FungibleAsset(iterAssetId, BigInt(amount))
+            ]);
+            const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_lazy17.NoteAttachment();
+            const note = import_lazy17.Note.createP2IDNote(
+              iterSenderId,
+              receiverId,
+              assets,
+              resolvedNoteType,
+              noteAttachment
+            );
+            const recipientAddress = parseAddress(to, receiverId);
+            return {
+              note,
+              recipientAddress,
+              noteType: resolvedNoteType
+            };
+          }
+        );
+        const txRequest = new import_lazy17.TransactionRequestBuilder().withOwnOutputNotes(new import_lazy17.NoteArray(outputs.map((o) => o.note))).build();
+        const txSenderId = parseAccountId(options.from);
+        const txResult = await client.executeTransaction(txSenderId, txRequest);
+        setStage("proving");
+        const proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveDirect(
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+          ),
+          proverConfig
+        );
+        setStage("submitting");
+        const submissionHeight = await client.submitProvenTransaction(
+          provenTransaction,
+          txResult
+        );
+        const txIdHex = txResult.id().toHex();
+        const txIdString = txResult.id().toString();
+        await client.applyTransaction(txResult, submissionHeight);
+        const hasPrivate = outputs.some((o) => o.noteType === import_lazy17.NoteType.Private);
+        if (hasPrivate) {
+          await waitForTransactionCommit(
+            client,
+            runExclusiveDirect,
+            txIdHex
+          );
+          for (const output of outputs) {
+            if (output.noteType === import_lazy17.NoteType.Private) {
+              await client.sendPrivateNote(
+                output.note,
+                output.recipientAddress
+              );
+            }
+          }
+        }
+        const txSummary = { transactionId: txIdString };
+        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);
+        isBusyRef.current = false;
+      }
+    },
+    [client, isReady, prover, signerConnected, sync]
+  );
+  const reset = (0, import_react15.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    sendMany,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useWaitForCommit.ts
+var import_react16 = require("react");
+var import_lazy18 = require("@miden-sdk/miden-sdk/lazy");
+function useWaitForCommit() {
+  const { client, isReady } = useMiden();
+  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 = normalizeHex3(
+        typeof txId === "string" ? txId : txId.toHex()
+      );
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        await client.syncState();
+        const records = await client.getTransactions(
+          typeof txId === "string" ? import_lazy18.TransactionFilter.all() : import_lazy18.TransactionFilter.ids([txId])
+        );
+        const record = records.find(
+          (item) => normalizeHex3(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));
+      }
+      throw new Error("Timeout waiting for transaction commit");
+    },
+    [client, isReady]
+  );
+  return { waitForCommit };
+}
+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_react17 = require("react");
+function useWaitForNotes() {
+  const { client, isReady, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const waitForConsumableNotes = (0, import_react17.useCallback)(
+    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 consumable = await runExclusiveSafe(
+          () => client.getConsumableNotes(accountId)
+        );
+        if (consumable.length >= minCount) {
+          return consumable;
+        }
+        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
+var import_react18 = require("react");
+function useMint() {
+  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 mint = (0, import_react18.useCallback)(
+    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 targetAccountIdObj = parseAccountId(options.targetAccountId);
+        const faucetIdObj = parseAccountId(options.faucetId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const txRequest = client.newMintTransactionRequest(
+            targetAccountIdObj,
+            faucetIdObj,
+            noteType,
+            BigInt(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 = (0, import_react18.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    mint,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useConsume.ts
+var import_react19 = require("react");
+var import_lazy19 = require("@miden-sdk/miden-sdk/lazy");
+function useConsume() {
+  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 consume = (0, import_react19.useCallback)(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      if (options.notes.length === 0) {
+        throw new Error("No notes provided");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const accountIdObj = parseAccountId(options.accountId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const resolved = new Array(options.notes.length);
+          const lookupIndices = [];
+          const lookupIds = [];
+          for (let i = 0; i < options.notes.length; i++) {
+            const item = options.notes[i];
+            if (typeof item === "string") {
+              lookupIndices.push(i);
+              lookupIds.push(import_lazy19.NoteId.fromHex(item));
+            } else if (item !== null && typeof item === "object" && typeof item.toNote === "function") {
+              resolved[i] = item.toNote();
+            } else if (item !== null && typeof item === "object" && typeof item.id === "function") {
+              resolved[i] = item;
+            } else {
+              lookupIndices.push(i);
+              lookupIds.push(item);
+            }
+          }
+          if (lookupIds.length > 0) {
+            const filter = new import_lazy19.NoteFilter(import_lazy19.NoteFilterTypes.List, lookupIds);
+            const noteRecords = await client.getInputNotes(filter);
+            if (noteRecords.length !== lookupIds.length) {
+              throw new Error("Some notes could not be found for provided IDs");
+            }
+            const recordById = new Map(
+              noteRecords.map((r) => [r.id().toString(), r])
+            );
+            for (let j = 0; j < lookupIndices.length; j++) {
+              const record = recordById.get(lookupIds[j].toString());
+              if (!record) {
+                throw new Error(
+                  "Some notes could not be found for provided IDs"
+                );
+              }
+              resolved[lookupIndices[j]] = record.toNote();
+            }
+          }
+          const notes = resolved;
+          if (notes.length === 0) {
+            throw new Error("No notes found for provided IDs");
+          }
+          if (notes.length !== options.notes.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 = (0, import_react19.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    consume,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSwap.ts
+var import_react20 = require("react");
+function useSwap() {
+  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 swap = (0, import_react20.useCallback)(
+    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 paybackNoteType = getNoteType(
+          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,
+            BigInt(options.offeredAmount),
+            requestedFaucetIdObj,
+            BigInt(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 = (0, import_react20.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    swap,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useTransaction.ts
+var import_react21 = require("react");
+
+// src/utils/transactions.ts
+var import_lazy20 = require("@miden-sdk/miden-sdk/lazy");
+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_lazy20.TransactionFilter.ids([txId]))
+    );
+    if (record) {
+      const status = record.transactionStatus();
+      if (status.isCommitted()) {
+        return;
+      }
+      if (status.isDiscarded()) {
+        throw new Error("Transaction was discarded before commit");
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    waited += delayMs;
+  }
+  throw new Error("Timeout waiting for transaction commit");
+}
+function extractFullNotes(txResult) {
+  try {
+    const executedTx = txResult.executedTransaction?.();
+    const notes = executedTx?.outputNotes?.().notes?.() ?? [];
+    const result = [];
+    for (const note of notes) {
+      if (note.noteType?.() === import_lazy20.NoteType.Private) {
+        const full = note.intoFull?.();
+        if (full) result.push(full);
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+// src/hooks/useTransaction.ts
+function useTransaction() {
+  const { client, isReady, sync, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  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);
+        const txResult = await runExclusiveSafe(() => {
+          const accountIdObj = parseAccountId(options.accountId);
+          return client.executeTransaction(accountIdObj, txRequest);
+        });
+        setStage("proving");
+        const proverConfig = useMidenStore.getState().config;
+        const provenTransaction = await proveWithFallback(
+          (resolvedProver) => runExclusiveSafe(
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+          ),
+          proverConfig
+        );
+        setStage("submitting");
+        const submissionHeight = await runExclusiveSafe(
+          () => client.submitProvenTransaction(provenTransaction, txResult)
+        );
+        await runExclusiveSafe(
+          () => client.applyTransaction(txResult, submissionHeight)
+        );
+        const txId = txResult.id();
+        if (options.privateNoteTarget != null) {
+          await waitForTransactionCommit2(client, runExclusiveSafe, txId);
+          const targetAddress = parseAddress(options.privateNoteTarget);
+          const fullNotes = extractFullNotes(txResult);
+          for (const note of fullNotes) {
+            await runExclusiveSafe(
+              () => client.sendPrivateNote(note, targetAddress)
+            );
+          }
+        }
+        const txSummary = { transactionId: txId.toString() };
+        setStage("complete");
+        setResult(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);
+        isBusyRef.current = false;
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = (0, import_react21.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    execute,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+async function resolveRequest(request, client) {
+  if (typeof request === "function") {
+    return await request(client);
+  }
+  return request;
+}
+
+// src/hooks/useExecuteProgram.ts
+var import_react22 = require("react");
+var import_lazy21 = require("@miden-sdk/miden-sdk/lazy");
+function isForeignAccountWrapper(fa) {
+  return fa !== null && typeof fa === "object" && "id" in fa && typeof fa.id !== "function";
+}
+function useExecuteProgram() {
+  const { client, isReady, sync, runExclusive } = useMiden();
+  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
+  const isBusyRef = (0, import_react22.useRef)(false);
+  const [result, setResult] = (0, import_react22.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react22.useState)(false);
+  const [error, setError] = (0, import_react22.useState)(null);
+  const execute = (0, import_react22.useCallback)(
+    async (options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      if (isBusyRef.current) {
+        throw new MidenError(
+          "A program execution is already in progress. Await the previous call before starting another.",
+          { code: "OPERATION_BUSY" }
+        );
+      }
+      isBusyRef.current = true;
+      setIsLoading(true);
+      setError(null);
+      try {
+        if (!options.skipSync) {
+          await sync();
+        }
+        const programResult = await runExclusiveSafe(async () => {
+          const accountIdObj = parseAccountId(options.accountId);
+          const adviceInputs = options.adviceInputs ?? new import_lazy21.AdviceInputs();
+          let foreignAccountsArray;
+          if (options.foreignAccounts?.length) {
+            const accounts = options.foreignAccounts.map((fa) => {
+              const wrapper = isForeignAccountWrapper(fa);
+              const id = parseAccountId(wrapper ? fa.id : fa);
+              const storage = wrapper && fa.storage ? fa.storage : new import_lazy21.AccountStorageRequirements();
+              return import_lazy21.ForeignAccount.public(id, storage);
+            });
+            foreignAccountsArray = new import_lazy21.ForeignAccountArray(accounts);
+          } else {
+            foreignAccountsArray = new import_lazy21.ForeignAccountArray();
+          }
+          const feltArray = await client.executeProgram(
+            accountIdObj,
+            options.script,
+            adviceInputs,
+            foreignAccountsArray
+          );
+          const stack = [];
+          const len = feltArray.length();
+          for (let i = 0; i < len; i++) {
+            stack.push(feltArray.get(i).asInt());
+          }
+          return { stack };
+        });
+        setResult(programResult);
+        return programResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+        isBusyRef.current = false;
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = (0, import_react22.useCallback)(() => {
+    setResult(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    execute,
+    result,
+    isLoading,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useCompile.ts
+var import_react23 = require("react");
+var import_lazy22 = require("@miden-sdk/miden-sdk/lazy");
+function useCompile() {
+  const { client, isReady } = useMiden();
+  const resource = (0, import_react23.useMemo)(
+    () => client && isReady ? new import_lazy22.CompilerResource(client, import_lazy22.getWasmOrThrow) : null,
+    [client, isReady]
+  );
+  const requireResource = (0, import_react23.useCallback)(() => {
+    if (!resource) {
+      throw new Error("Miden client is not ready");
+    }
+    return resource;
+  }, [resource]);
+  const component = (0, import_react23.useCallback)(
+    async (options) => requireResource().component(options),
+    [requireResource]
+  );
+  const txScript = (0, import_react23.useCallback)(
+    async (options) => requireResource().txScript(options),
+    [requireResource]
+  );
+  const noteScript = (0, import_react23.useCallback)(
+    async (options) => requireResource().noteScript(options),
+    [requireResource]
+  );
+  return { component, txScript, noteScript, isReady };
+}
+
+// src/hooks/useSessionAccount.ts
+var import_react24 = require("react");
+var import_lazy23 = require("@miden-sdk/miden-sdk/lazy");
+function useSessionAccount(options) {
+  const { client, isReady, sync } = useMiden();
+  const setAccounts = useMidenStore((state) => state.setAccounts);
+  const [sessionAccountId, setSessionAccountId] = (0, import_react24.useState)(null);
+  const [step, setStep] = (0, import_react24.useState)("idle");
+  const [error, setError] = (0, import_react24.useState)(null);
+  const cancelledRef = (0, import_react24.useRef)(false);
+  const isBusyRef = (0, import_react24.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_react24.useRef)(options.fund);
+  fundRef.current = options.fund;
+  (0, import_react24.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_react24.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 client.newWallet(
+          resolvedStorageMode,
+          mutable,
+          authScheme
+        );
+        ensureAccountBech32(wallet);
+        const accounts = await client.getAccounts();
+        setAccounts(accounts);
+        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,
+        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,
+    sessionAccountId,
+    storageMode,
+    mutable,
+    authScheme,
+    storagePrefix,
+    pollIntervalMs,
+    maxWaitMs,
+    setAccounts
+  ]);
+  const reset = (0, import_react24.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_lazy23.AccountStorageMode.private();
+    case "public":
+      return import_lazy23.AccountStorageMode.public();
+    default:
+      return import_lazy23.AccountStorageMode.public();
+  }
+}
+async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    if (cancelledRef.current) return;
+    await client.syncState();
+    if (cancelledRef.current) return;
+    const accountIdObj = parseAccountId(walletId);
+    const consumable = await client.getConsumableNotes(accountIdObj);
+    if (consumable.length > 0) {
+      const notes = consumable.map((c) => c.inputNoteRecord().toNote());
+      const txRequest = client.newConsumeTransactionRequest(notes);
+      const freshAccountId = parseAccountId(walletId);
+      await client.submitNewTransaction(freshAccountId, txRequest);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error("Timeout waiting for session wallet funding");
+}
+
+// src/hooks/useExportStore.ts
+var import_react25 = require("react");
+var import_lazy24 = require("@miden-sdk/miden-sdk/lazy");
+function useExportStore() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = (0, import_react25.useState)(false);
+  const [error, setError] = (0, import_react25.useState)(null);
+  const exportStore = (0, import_react25.useCallback)(async () => {
+    if (!client || !isReady) {
+      throw new Error("Miden client is not ready");
+    }
+    setIsExporting(true);
+    setError(null);
+    try {
+      const storeName = client.storeIdentifier();
+      const snapshot = await runExclusive(() => (0, import_lazy24.exportStore)(storeName));
+      return snapshot;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsExporting(false);
+    }
+  }, [client, isReady, runExclusive]);
+  const reset = (0, import_react25.useCallback)(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportStore,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportStore.ts
+var import_react26 = require("react");
+var import_lazy25 = require("@miden-sdk/miden-sdk/lazy");
+function useImportStore() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = (0, import_react26.useState)(false);
+  const [error, setError] = (0, import_react26.useState)(null);
+  const importStore = (0, import_react26.useCallback)(
+    async (storeDump, storeName, options) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        await runExclusive(() => (0, import_lazy25.importStore)(storeName, storeDump));
+        if (!options?.skipSync) {
+          await sync();
+        }
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = (0, import_react26.useCallback)(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importStore,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useImportNote.ts
+var import_react27 = require("react");
+var import_lazy26 = require("@miden-sdk/miden-sdk/lazy");
+function useImportNote() {
+  const { client, isReady, runExclusive, sync } = useMiden();
+  const [isImporting, setIsImporting] = (0, import_react27.useState)(false);
+  const [error, setError] = (0, import_react27.useState)(null);
+  const importNote = (0, import_react27.useCallback)(
+    async (noteBytes) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsImporting(true);
+      setError(null);
+      try {
+        const noteFile = import_lazy26.NoteFile.deserialize(noteBytes);
+        const noteId = await runExclusive(
+          () => client.importNoteFile(noteFile)
+        );
+        await sync();
+        return noteId.toString();
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsImporting(false);
+      }
+    },
+    [client, isReady, runExclusive, sync]
+  );
+  const reset = (0, import_react27.useCallback)(() => {
+    setIsImporting(false);
+    setError(null);
+  }, []);
+  return {
+    importNote,
+    isImporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useExportNote.ts
+var import_react28 = require("react");
+var import_lazy27 = require("@miden-sdk/miden-sdk/lazy");
+function useExportNote() {
+  const { client, isReady, runExclusive } = useMiden();
+  const [isExporting, setIsExporting] = (0, import_react28.useState)(false);
+  const [error, setError] = (0, import_react28.useState)(null);
+  const exportNote = (0, import_react28.useCallback)(
+    async (noteId) => {
+      if (!client || !isReady) {
+        throw new Error("Miden client is not ready");
+      }
+      setIsExporting(true);
+      setError(null);
+      try {
+        const noteFile = await runExclusive(
+          () => client.exportNoteFile(noteId, import_lazy27.NoteExportFormat.Full)
+        );
+        return noteFile.serialize();
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsExporting(false);
+      }
+    },
+    [client, isReady, runExclusive]
+  );
+  const reset = (0, import_react28.useCallback)(() => {
+    setIsExporting(false);
+    setError(null);
+  }, []);
+  return {
+    exportNote,
+    isExporting,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSyncControl.ts
+var import_react29 = require("react");
+function useSyncControl() {
+  const isPaused = useMidenStore((state) => state.syncPaused);
+  const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
+  const pauseSync = (0, import_react29.useCallback)(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = (0, import_react29.useCallback)(() => setSyncPaused(false), [setSyncPaused]);
+  return {
+    pauseSync,
+    resumeSync,
+    isPaused
+  };
+}
+
+// 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,
+  MultiSignerProvider,
+  SignerContext,
+  SignerSlot,
+  accountIdsEqual,
+  bigIntToBytes,
+  bytesToBigInt,
+  clearMidenStorage,
+  concatBytes,
+  createMidenStorage,
+  createNoteAttachment,
+  formatAssetAmount,
+  formatNoteSummary,
+  getNoteSummary,
+  migrateStorage,
+  normalizeAccountId,
+  parseAssetAmount,
+  readNoteAttachment,
+  toBech32AccountId,
+  useAccount,
+  useAccounts,
+  useAssetMetadata,
+  useCompile,
+  useConsume,
+  useCreateFaucet,
+  useCreateWallet,
+  useExecuteProgram,
+  useExportNote,
+  useExportStore,
+  useImportAccount,
+  useImportNote,
+  useImportStore,
+  useMiden,
+  useMidenClient,
+  useMint,
+  useMultiSend,
+  useMultiSigner,
+  useNoteStream,
+  useNotes,
+  useSend,
+  useSessionAccount,
+  useSigner,
+  useSwap,
+  useSyncControl,
+  useSyncState,
+  useTransaction,
+  useTransactionHistory,
+  useWaitForCommit,
+  useWaitForNotes,
+  waitForWalletDetection,
+  wrapWasmError
+});