@miden-sdk/react 0.14.3 → 0.14.5

package/dist/index.js

@@ -28,9 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthScheme: () => import_miden_sdk4.AuthScheme,
+var src_exports = {};
+__export(src_exports, {
+  AuthScheme: () => import_lazy4.AuthScheme,
   DEFAULTS: () => DEFAULTS,
   MidenError: () => MidenError,
   MidenProvider: () => MidenProvider,
@@ -85,13 +85,13 @@ __export(index_exports, {
   waitForWalletDetection: () => waitForWalletDetection,
   wrapWasmError: () => wrapWasmError
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/types/augmentations.ts
-var import_miden_sdk = require("@miden-sdk/miden-sdk");
+var import_lazy = require("@miden-sdk/miden-sdk");
 
 // src/utils/accountBech32.ts
-var import_miden_sdk3 = require("@miden-sdk/miden-sdk");
+var import_lazy3 = require("@miden-sdk/miden-sdk");
 
 // src/store/MidenStore.ts
 var import_zustand = require("zustand");
@@ -238,19 +238,19 @@ var useAssetMetadataStore = () => useMidenStore((state) => state.assetMetadata);
 var useNoteFirstSeenStore = () => useMidenStore((state) => state.noteFirstSeen);
 
 // src/utils/accountParsing.ts
-var import_miden_sdk2 = require("@miden-sdk/miden-sdk");
+var import_lazy2 = require("@miden-sdk/miden-sdk");
 var normalizeAccountIdInput = (value) => value.trim().replace(/^miden:/i, "");
 var isBech32Input = (value) => value.startsWith("m") || value.startsWith("M");
 var normalizeHexInput = (value) => value.startsWith("0x") || value.startsWith("0X") ? value : `0x${value}`;
 var parseAccountIdFromString = (value) => {
   if (isBech32Input(value)) {
     try {
-      return import_miden_sdk2.Address.fromBech32(value).accountId();
+      return import_lazy2.Address.fromBech32(value).accountId();
     } catch {
-      return import_miden_sdk2.AccountId.fromBech32(value);
+      return import_lazy2.AccountId.fromBech32(value);
     }
   }
-  return import_miden_sdk2.AccountId.fromHex(normalizeHexInput(value));
+  return import_lazy2.AccountId.fromHex(normalizeHexInput(value));
 };
 var parseAccountId = (value) => {
   if (typeof value === "string") {
@@ -277,49 +277,49 @@ function isFaucetId(accountId) {
 var parseAddress = (value, accountId) => {
   if (typeof value !== "string") {
     const resolvedId = accountId ?? parseAccountId(value);
-    return import_miden_sdk2.Address.fromAccountId(resolvedId, "BasicWallet");
+    return import_lazy2.Address.fromAccountId(resolvedId, "BasicWallet");
   }
   const normalized = normalizeAccountIdInput(value);
   if (isBech32Input(normalized)) {
     try {
-      return import_miden_sdk2.Address.fromBech32(normalized);
+      return import_lazy2.Address.fromBech32(normalized);
     } catch {
-      const resolvedAccountId2 = accountId ?? import_miden_sdk2.AccountId.fromBech32(normalized);
-      return import_miden_sdk2.Address.fromAccountId(resolvedAccountId2, "BasicWallet");
+      const resolvedAccountId2 = accountId ?? import_lazy2.AccountId.fromBech32(normalized);
+      return import_lazy2.Address.fromAccountId(resolvedAccountId2, "BasicWallet");
     }
   }
-  const resolvedAccountId = accountId ?? import_miden_sdk2.AccountId.fromHex(normalizeHexInput(normalized));
-  return import_miden_sdk2.Address.fromAccountId(resolvedAccountId, "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_miden_sdk3.NetworkId.testnet();
+    return import_lazy3.NetworkId.testnet();
   }
   const url = rpcUrl.toLowerCase();
   if (url.includes("devnet") || url.includes("mdev")) {
-    return import_miden_sdk3.NetworkId.devnet();
+    return import_lazy3.NetworkId.devnet();
   }
   if (url.includes("mainnet")) {
-    return import_miden_sdk3.NetworkId.mainnet();
+    return import_lazy3.NetworkId.mainnet();
   }
   if (url.includes("testnet") || url.includes("mtst")) {
-    return import_miden_sdk3.NetworkId.testnet();
+    return import_lazy3.NetworkId.testnet();
   }
-  return import_miden_sdk3.NetworkId.testnet();
+  return import_lazy3.NetworkId.testnet();
 };
 var toBech32FromAccountId = (id) => {
   try {
-    const address = import_miden_sdk3.Address.fromAccountId(id, "BasicWallet");
+    const address = import_lazy3.Address.fromAccountId(id, "BasicWallet");
     return address.toBech32(inferNetworkId());
   } catch {
   }
   try {
     const maybeBech32 = id.toBech32?.(
       inferNetworkId(),
-      import_miden_sdk3.AccountInterface.BasicWallet
+      import_lazy3.AccountInterface.BasicWallet
     );
     if (typeof maybeBech32 === "string") {
       return maybeBech32;
@@ -349,7 +349,7 @@ var defineBech32 = (target) => {
   }
 };
 var installAccountBech32 = () => {
-  const proto = import_miden_sdk3.Account.prototype;
+  const proto = import_lazy3.Account.prototype;
   if (proto.bech32id) {
     return;
   }
@@ -382,17 +382,17 @@ var toBech32AccountId = (accountId) => {
 
 // src/context/MidenProvider.tsx
 var import_react2 = require("react");
-var import_miden_sdk6 = require("@miden-sdk/miden-sdk");
+var import_lazy6 = require("@miden-sdk/miden-sdk");
 
 // src/types/index.ts
-var import_miden_sdk4 = require("@miden-sdk/miden-sdk");
+var import_lazy4 = require("@miden-sdk/miden-sdk");
 var DEFAULTS = {
   RPC_URL: void 0,
   // Will use SDK's testnet default
   AUTO_SYNC_INTERVAL: 15e3,
   STORAGE_MODE: "private",
   WALLET_MUTABLE: true,
-  AUTH_SCHEME: import_miden_sdk4.AuthScheme.AuthRpoFalcon512,
+  AUTH_SCHEME: import_lazy4.AuthScheme.Falcon,
   NOTE_TYPE: "private",
   FAUCET_DECIMALS: 8
 };
@@ -436,7 +436,7 @@ function resolveRpcUrl(rpcUrl) {
 }
 
 // src/utils/prover.ts
-var import_miden_sdk5 = require("@miden-sdk/miden-sdk");
+var import_lazy5 = require("@miden-sdk/miden-sdk");
 var DEFAULT_PROVER_URLS = {
   devnet: "https://tx-prover.devnet.miden.io",
   testnet: "https://tx-prover.testnet.miden.io"
@@ -475,19 +475,19 @@ function resolveProverTarget(target, config) {
   if (typeof target === "string") {
     const normalized = target.trim().toLowerCase();
     if (normalized === "local" || normalized === "localhost") {
-      return import_miden_sdk5.TransactionProver.newLocalProver();
+      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_miden_sdk5.TransactionProver.newRemoteProver(
+      return import_lazy5.TransactionProver.newRemoteProver(
         url,
         normalizeTimeout(config.proverTimeoutMs)
       );
     }
-    return import_miden_sdk5.TransactionProver.newRemoteProver(
+    return import_lazy5.TransactionProver.newRemoteProver(
       target,
       normalizeTimeout(config.proverTimeoutMs)
     );
@@ -499,7 +499,7 @@ function createRemoteProver(config, fallbackTimeout) {
   if (!url) {
     throw new Error("Remote prover requires a URL");
   }
-  return import_miden_sdk5.TransactionProver.newRemoteProver(
+  return import_lazy5.TransactionProver.newRemoteProver(
     url,
     normalizeTimeout(timeoutMs ?? fallbackTimeout)
   );
@@ -535,7 +535,13 @@ 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");
+  const {
+    AccountBuilder,
+    AccountComponent,
+    AuthScheme: AuthScheme2,
+    Word: Word2,
+    resolveAuthScheme: resolveAuthScheme5
+  } = await import("@miden-sdk/miden-sdk");
   await client.syncState();
   if (config.importAccountId) {
     const accountId2 = parseAccountId(config.importAccountId);
@@ -556,7 +562,7 @@ async function initializeSignerAccount(client, config) {
   let builder = new AccountBuilder(seed).withAuthComponent(
     AccountComponent.createAuthComponentFromCommitment(
       commitmentWord,
-      AuthScheme2.AuthEcdsaK256Keccak
+      resolveAuthScheme5(AuthScheme2.ECDSA)
     )
   ).accountType(accountType).storageMode(config.storageMode).withBasicWalletComponent();
   if (config.customComponents?.length) {
@@ -629,15 +635,20 @@ function MidenProvider({
     }),
     [config]
   );
-  const defaultProver = (0, import_react2.useMemo)(
-    () => resolveTransactionProver(resolvedConfig),
-    [
-      resolvedConfig.prover,
-      resolvedConfig.proverTimeoutMs,
-      resolvedConfig.proverUrls?.devnet,
-      resolvedConfig.proverUrls?.testnet
-    ]
-  );
+  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),
     []
@@ -716,7 +727,7 @@ function MidenProvider({
           if (signerContext && signerIsConnected === true) {
             const storeName = `MidenClientDB_${signerContext.storeName}`;
             signCbRef.current = signerContext.signCb;
-            webClient = await import_miden_sdk6.WasmWebClient.createClientWithExternalKeystore(
+            webClient = await import_lazy6.WasmWebClient.createClientWithExternalKeystore(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               resolvedConfig.seed,
@@ -736,7 +747,7 @@ function MidenProvider({
             currentStoreNameRef.current = signerContext.storeName;
           } else {
             const seed = resolvedConfig.seed;
-            webClient = await import_miden_sdk6.WasmWebClient.createClient(
+            webClient = await import_lazy6.WasmWebClient.createClient(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               seed
@@ -1080,7 +1091,7 @@ var import_react6 = require("react");
 
 // src/hooks/useAssetMetadata.ts
 var import_react5 = require("react");
-var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
+var import_lazy7 = require("@miden-sdk/miden-sdk");
 var inflight = /* @__PURE__ */ new Map();
 var rpcClients = /* @__PURE__ */ new Map();
 var getRpcClient = (rpcUrl) => {
@@ -1088,8 +1099,8 @@ var getRpcClient = (rpcUrl) => {
   const existing = rpcClients.get(key);
   if (existing) return existing;
   try {
-    const endpoint = rpcUrl ? new import_miden_sdk7.Endpoint(rpcUrl) : import_miden_sdk7.Endpoint.testnet();
-    const client = new import_miden_sdk7.RpcClient(endpoint);
+    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 {
@@ -1103,7 +1114,7 @@ var fetchAssetMetadata = async (rpcClient, assetId) => {
     const fetched = await rpcClient.getAccountDetails(accountId);
     const account = fetched.account?.();
     if (!account) return null;
-    const faucet = import_miden_sdk7.BasicFungibleFaucetComponent.fromAccount(account);
+    const faucet = import_lazy7.BasicFungibleFaucetComponent.fromAccount(account);
     const symbol = faucet.symbol().toString();
     const decimals = faucet.decimals();
     return { assetId, symbol, decimals };
@@ -1229,7 +1240,7 @@ function useAccount(accountId) {
 
 // src/hooks/useNotes.ts
 var import_react7 = require("react");
-var import_miden_sdk9 = require("@miden-sdk/miden-sdk");
+var import_lazy9 = require("@miden-sdk/miden-sdk");
 
 // src/utils/amounts.ts
 var formatAssetAmount = (amount, decimals) => {
@@ -1334,30 +1345,30 @@ function accountIdsEqual(a, b) {
 }
 
 // src/utils/noteFilters.ts
-var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
+var import_lazy8 = require("@miden-sdk/miden-sdk");
 function getNoteFilterType(status) {
   switch (status) {
     case "consumed":
-      return import_miden_sdk8.NoteFilterTypes.Consumed;
+      return import_lazy8.NoteFilterTypes.Consumed;
     case "committed":
-      return import_miden_sdk8.NoteFilterTypes.Committed;
+      return import_lazy8.NoteFilterTypes.Committed;
     case "expected":
-      return import_miden_sdk8.NoteFilterTypes.Expected;
+      return import_lazy8.NoteFilterTypes.Expected;
     case "processing":
-      return import_miden_sdk8.NoteFilterTypes.Processing;
+      return import_lazy8.NoteFilterTypes.Processing;
     case "all":
     default:
-      return import_miden_sdk8.NoteFilterTypes.All;
+      return import_lazy8.NoteFilterTypes.All;
   }
 }
 function getNoteType(type) {
   switch (type) {
     case "private":
-      return import_miden_sdk8.NoteType.Private;
+      return import_lazy8.NoteType.Private;
     case "public":
-      return import_miden_sdk8.NoteType.Public;
+      return import_lazy8.NoteType.Public;
     default:
-      return import_miden_sdk8.NoteType.Private;
+      return import_lazy8.NoteType.Private;
   }
 }
 async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWaitMs = 1e4, delayMs = 1e3) {
@@ -1366,7 +1377,7 @@ async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWa
   while (Date.now() < deadline) {
     await runExclusiveSafe(() => client.syncState());
     const records = await runExclusiveSafe(
-      () => client.getTransactions(import_miden_sdk8.TransactionFilter.all())
+      () => client.getTransactions(import_lazy8.TransactionFilter.all())
     );
     const record = records.find(
       (r) => normalizeHex(r.id().toHex()) === targetHex
@@ -1409,7 +1420,7 @@ function useNotes(options) {
     setError(null);
     try {
       const filterType = getNoteFilterType(options?.status);
-      const filter = new import_miden_sdk9.NoteFilter(filterType);
+      const filter = new import_lazy9.NoteFilter(filterType);
       const fetchedNotes = await client.getInputNotes(filter);
       let fetchedConsumable;
       if (options?.accountId) {
@@ -1531,10 +1542,10 @@ function useNotes(options) {
 
 // src/hooks/useNoteStream.ts
 var import_react8 = require("react");
-var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
+var import_lazy11 = require("@miden-sdk/miden-sdk");
 
 // src/utils/noteAttachment.ts
-var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
+var import_lazy10 = require("@miden-sdk/miden-sdk");
 function readNoteAttachment(note) {
   try {
     const metadata = note.metadata?.();
@@ -1543,8 +1554,8 @@ function readNoteAttachment(note) {
     if (!attachment) return null;
     const kind = attachment.kind?.();
     if (!kind) return null;
-    if (kind === import_miden_sdk10.NoteAttachmentKind.None) return null;
-    if (kind === import_miden_sdk10.NoteAttachmentKind.Word) {
+    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();
@@ -1553,7 +1564,7 @@ function readNoteAttachment(note) {
       );
       return { values, kind: "word" };
     }
-    if (kind === import_miden_sdk10.NoteAttachmentKind.Array) {
+    if (kind === import_lazy10.NoteAttachmentKind.Array) {
       const arr = attachment.asArray?.();
       if (!arr) return null;
       const u64s = arr.toU64s();
@@ -1573,30 +1584,30 @@ function createNoteAttachment(values) {
     bigints.push(BigInt(values[i]));
   }
   if (bigints.length === 0) {
-    return new import_miden_sdk10.NoteAttachment();
+    return new import_lazy10.NoteAttachment();
   }
-  const scheme = import_miden_sdk10.NoteAttachmentScheme.none();
+  const scheme = import_lazy10.NoteAttachmentScheme.none();
   if (bigints.length <= 4) {
     while (bigints.length < 4) {
       bigints.push(0n);
     }
-    const word = new import_miden_sdk10.Word(BigUint64Array.from(bigints));
-    return import_miden_sdk10.NoteAttachment.newWord(scheme, word);
+    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_miden_sdk10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
+    words.push(new import_lazy10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
   }
-  const newArray = import_miden_sdk10.NoteAttachment["newArray"];
+  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_miden_sdk10.NoteAttachment, scheme, words);
+  return newArray.call(import_lazy10.NoteAttachment, scheme, words);
 }
 
 // src/hooks/useNoteStream.ts
@@ -1631,7 +1642,7 @@ function useNoteStream(options = {}) {
     setError(null);
     try {
       const filterType = getNoteFilterType(status);
-      const filter = new import_miden_sdk11.NoteFilter(filterType);
+      const filter = new import_lazy11.NoteFilter(filterType);
       const fetched = await client.getInputNotes(filter);
       setNotesIfChanged(fetched);
     } catch (err) {
@@ -1743,7 +1754,7 @@ function buildStreamedNote(record, noteFirstSeen) {
 
 // src/hooks/useTransactionHistory.ts
 var import_react9 = require("react");
-var import_miden_sdk12 = require("@miden-sdk/miden-sdk");
+var import_lazy12 = require("@miden-sdk/miden-sdk");
 function useTransactionHistory(options = {}) {
   const { client, isReady } = useMiden();
   const { lastSyncTime } = useSyncStateStore();
@@ -1818,14 +1829,14 @@ function buildFilter(filter, ids, idsHex) {
     return { filter };
   }
   if (!ids || ids.length === 0) {
-    return { filter: import_miden_sdk12.TransactionFilter.all() };
+    return { filter: import_lazy12.TransactionFilter.all() };
   }
   const allTransactionIds = ids.every((id) => typeof id !== "string");
   if (allTransactionIds) {
-    return { filter: import_miden_sdk12.TransactionFilter.ids(ids) };
+    return { filter: import_lazy12.TransactionFilter.ids(ids) };
   }
   return {
-    filter: import_miden_sdk12.TransactionFilter.all(),
+    filter: import_lazy12.TransactionFilter.all(),
     localFilterHexes: idsHex ?? []
   };
 }
@@ -1851,7 +1862,7 @@ function useSyncState() {
 
 // src/hooks/useCreateWallet.ts
 var import_react11 = require("react");
-var import_miden_sdk13 = require("@miden-sdk/miden-sdk");
+var import_lazy13 = require("@miden-sdk/miden-sdk");
 
 // src/utils/runExclusive.ts
 var runExclusiveDirect = async (fn) => fn();
@@ -1876,7 +1887,9 @@ function useCreateWallet() {
           options.storageMode ?? DEFAULTS.STORAGE_MODE
         );
         const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
-        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+        const authScheme = (0, import_lazy13.resolveAuthScheme)(
+          options.authScheme ?? DEFAULTS.AUTH_SCHEME
+        );
         const newWallet = await runExclusiveSafe(async () => {
           const createdWallet = await client.newWallet(
             storageMode,
@@ -1917,19 +1930,19 @@ function useCreateWallet() {
 function getStorageMode(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk13.AccountStorageMode.private();
+      return import_lazy13.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk13.AccountStorageMode.public();
+      return import_lazy13.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk13.AccountStorageMode.network();
+      return import_lazy13.AccountStorageMode.network();
     default:
-      return import_miden_sdk13.AccountStorageMode.private();
+      return import_lazy13.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useCreateFaucet.ts
 var import_react12 = require("react");
-var import_miden_sdk14 = require("@miden-sdk/miden-sdk");
+var import_lazy14 = require("@miden-sdk/miden-sdk");
 function useCreateFaucet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
@@ -1949,7 +1962,9 @@ function useCreateFaucet() {
           options.storageMode ?? DEFAULTS.STORAGE_MODE
         );
         const decimals = options.decimals ?? DEFAULTS.FAUCET_DECIMALS;
-        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+        const authScheme = (0, import_lazy14.resolveAuthScheme)(
+          options.authScheme ?? DEFAULTS.AUTH_SCHEME
+        );
         const newFaucet = await runExclusiveSafe(async () => {
           const createdFaucet = await client.newFaucet(
             storageMode,
@@ -1992,19 +2007,19 @@ function useCreateFaucet() {
 function getStorageMode2(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk14.AccountStorageMode.private();
+      return import_lazy14.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk14.AccountStorageMode.public();
+      return import_lazy14.AccountStorageMode.public();
     case "network":
-      return import_miden_sdk14.AccountStorageMode.network();
+      return import_lazy14.AccountStorageMode.network();
     default:
-      return import_miden_sdk14.AccountStorageMode.private();
+      return import_lazy14.AccountStorageMode.private();
   }
 }
 
 // src/hooks/useImportAccount.ts
 var import_react13 = require("react");
-var import_miden_sdk15 = require("@miden-sdk/miden-sdk");
+var import_lazy15 = require("@miden-sdk/miden-sdk");
 
 // src/utils/errors.ts
 var MidenError = class extends Error {
@@ -2137,7 +2152,9 @@ function useImportAccount() {
             }
             case "seed": {
               const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
-              const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
+              const authScheme = (0, import_lazy15.resolveAuthScheme)(
+                options.authScheme ?? DEFAULTS.AUTH_SCHEME
+              );
               return await client.importPublicAccountFromSeed(
                 options.seed,
                 mutable,
@@ -2176,10 +2193,10 @@ function useImportAccount() {
 }
 async function resolveAccountFile(file) {
   if (file instanceof Uint8Array) {
-    return import_miden_sdk15.AccountFile.deserialize(file);
+    return import_lazy15.AccountFile.deserialize(file);
   }
   if (file instanceof ArrayBuffer) {
-    return import_miden_sdk15.AccountFile.deserialize(new Uint8Array(file));
+    return import_lazy15.AccountFile.deserialize(new Uint8Array(file));
   }
   return file;
 }
@@ -2209,7 +2226,7 @@ function bytesEqual(left, right) {
 
 // src/hooks/useSend.ts
 var import_react14 = require("react");
-var import_miden_sdk16 = require("@miden-sdk/miden-sdk");
+var import_lazy16 = require("@miden-sdk/miden-sdk");
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
@@ -2276,19 +2293,19 @@ function useSend() {
             const fromId = parseAccountId(options.from);
             const toId = parseAccountId(options.to);
             const assetObj = parseAccountId(assetId);
-            const assets = new import_miden_sdk16.NoteAssets([
-              new import_miden_sdk16.FungibleAsset(assetObj, BigInt(amount))
+            const assets = new import_lazy16.NoteAssets([
+              new import_lazy16.FungibleAsset(assetObj, BigInt(amount))
             ]);
-            const p2idNote = import_miden_sdk16.Note.createP2IDNote(
+            const p2idNote = import_lazy16.Note.createP2IDNote(
               fromId,
               toId,
               assets,
               noteType,
-              new import_miden_sdk16.NoteAttachment()
+              new import_lazy16.NoteAttachment()
             );
-            const ownOutputs = new import_miden_sdk16.NoteArray();
+            const ownOutputs = new import_lazy16.NoteArray();
             ownOutputs.push(p2idNote);
-            const txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(ownOutputs).build();
+            const txRequest = new import_lazy16.TransactionRequestBuilder().withOwnOutputNotes(ownOutputs).build();
             const execFromId = parseAccountId(options.from);
             const txId = prover ? await client.submitNewTransactionWithProver(
               execFromId,
@@ -2309,17 +2326,17 @@ function useSend() {
           let txRequest;
           if (hasAttachment) {
             const attachment = createNoteAttachment(options.attachment);
-            const assets = new import_miden_sdk16.NoteAssets([
-              new import_miden_sdk16.FungibleAsset(assetIdObj, amount)
+            const assets = new import_lazy16.NoteAssets([
+              new import_lazy16.FungibleAsset(assetIdObj, amount)
             ]);
-            const note = import_miden_sdk16.Note.createP2IDNote(
+            const note = import_lazy16.Note.createP2IDNote(
               fromAccountId,
               toAccountId,
               assets,
               noteType,
               attachment
             );
-            txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk16.NoteArray([note])).build();
+            txRequest = new import_lazy16.TransactionRequestBuilder().withOwnOutputNotes(new import_lazy16.NoteArray([note])).build();
           } else {
             txRequest = client.newSendTransactionRequest(
               fromAccountId,
@@ -2338,7 +2355,7 @@ function useSend() {
         const proverConfig = useMidenStore.getState().config;
         const provenTransaction = await proveWithFallback(
           (resolvedProver) => runExclusiveSafe(
-            () => client.proveTransaction(txResult, resolvedProver)
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
           ),
           proverConfig
         );
@@ -2349,13 +2366,13 @@ function useSend() {
         const txIdHex = txResult.id().toHex();
         const txIdString = txResult.id().toString();
         let fullNote = null;
-        if (noteType === import_miden_sdk16.NoteType.Private) {
+        if (noteType === import_lazy16.NoteType.Private) {
           fullNote = extractFullNote(txResult);
         }
         await runExclusiveSafe(
           () => client.applyTransaction(txResult, submissionHeight)
         );
-        if (noteType === import_miden_sdk16.NoteType.Private) {
+        if (noteType === import_lazy16.NoteType.Private) {
           if (!fullNote) {
             throw new Error("Missing full note for private send");
           }
@@ -2418,7 +2435,7 @@ function extractFullNote(txResult) {
 
 // src/hooks/useMultiSend.ts
 var import_react15 = require("react");
-var import_miden_sdk17 = require("@miden-sdk/miden-sdk");
+var import_lazy17 = require("@miden-sdk/miden-sdk");
 function useMultiSend() {
   const { client, isReady, sync, prover, signerConnected } = useMiden();
   const isBusyRef = (0, import_react15.useRef)(false);
@@ -2455,12 +2472,12 @@ function useMultiSend() {
             const iterSenderId = parseAccountId(options.from);
             const iterAssetId = parseAccountId(options.assetId);
             const receiverId = parseAccountId(to);
-            const assets = new import_miden_sdk17.NoteAssets([
-              new import_miden_sdk17.FungibleAsset(iterAssetId, BigInt(amount))
+            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_miden_sdk17.NoteAttachment();
-            const note = import_miden_sdk17.Note.createP2IDNote(
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_lazy17.NoteAttachment();
+            const note = import_lazy17.Note.createP2IDNote(
               iterSenderId,
               receiverId,
               assets,
@@ -2475,14 +2492,14 @@ function useMultiSend() {
             };
           }
         );
-        const txRequest = new import_miden_sdk17.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk17.NoteArray(outputs.map((o) => o.note))).build();
+        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(
-            () => client.proveTransaction(txResult, resolvedProver)
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
           ),
           proverConfig
         );
@@ -2494,7 +2511,7 @@ function useMultiSend() {
         const txIdHex = txResult.id().toHex();
         const txIdString = txResult.id().toString();
         await client.applyTransaction(txResult, submissionHeight);
-        const hasPrivate = outputs.some((o) => o.noteType === import_miden_sdk17.NoteType.Private);
+        const hasPrivate = outputs.some((o) => o.noteType === import_lazy17.NoteType.Private);
         if (hasPrivate) {
           await waitForTransactionCommit(
             client,
@@ -2502,7 +2519,7 @@ function useMultiSend() {
             txIdHex
           );
           for (const output of outputs) {
-            if (output.noteType === import_miden_sdk17.NoteType.Private) {
+            if (output.noteType === import_lazy17.NoteType.Private) {
               await client.sendPrivateNote(
                 output.note,
                 output.recipientAddress
@@ -2545,7 +2562,7 @@ function useMultiSend() {
 
 // src/hooks/useWaitForCommit.ts
 var import_react16 = require("react");
-var import_miden_sdk18 = require("@miden-sdk/miden-sdk");
+var import_lazy18 = require("@miden-sdk/miden-sdk");
 function useWaitForCommit() {
   const { client, isReady } = useMiden();
   const waitForCommit = (0, import_react16.useCallback)(
@@ -2562,7 +2579,7 @@ function useWaitForCommit() {
       while (Date.now() < deadline) {
         await client.syncState();
         const records = await client.getTransactions(
-          typeof txId === "string" ? import_miden_sdk18.TransactionFilter.all() : import_miden_sdk18.TransactionFilter.ids([txId])
+          typeof txId === "string" ? import_lazy18.TransactionFilter.all() : import_lazy18.TransactionFilter.ids([txId])
         );
         const record = records.find(
           (item) => normalizeHex3(item.id().toHex()) === targetHex
@@ -2694,7 +2711,7 @@ function useMint() {
 
 // src/hooks/useConsume.ts
 var import_react19 = require("react");
-var import_miden_sdk19 = require("@miden-sdk/miden-sdk");
+var import_lazy19 = require("@miden-sdk/miden-sdk");
 function useConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
@@ -2724,7 +2741,7 @@ function useConsume() {
             const item = options.notes[i];
             if (typeof item === "string") {
               lookupIndices.push(i);
-              lookupIds.push(import_miden_sdk19.NoteId.fromHex(item));
+              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") {
@@ -2735,7 +2752,7 @@ function useConsume() {
             }
           }
           if (lookupIds.length > 0) {
-            const filter = new import_miden_sdk19.NoteFilter(import_miden_sdk19.NoteFilterTypes.List, lookupIds);
+            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");
@@ -2877,13 +2894,13 @@ function useSwap() {
 var import_react21 = require("react");
 
 // src/utils/transactions.ts
-var import_miden_sdk20 = require("@miden-sdk/miden-sdk");
+var import_lazy20 = require("@miden-sdk/miden-sdk");
 async function waitForTransactionCommit2(client, runExclusiveSafe, txId, maxWaitMs = 1e4, delayMs = 1e3) {
   let waited = 0;
   while (waited < maxWaitMs) {
     await runExclusiveSafe(() => client.syncState());
     const [record] = await runExclusiveSafe(
-      () => client.getTransactions(import_miden_sdk20.TransactionFilter.ids([txId]))
+      () => client.getTransactions(import_lazy20.TransactionFilter.ids([txId]))
     );
     if (record) {
       const status = record.transactionStatus();
@@ -2905,7 +2922,7 @@ function extractFullNotes(txResult) {
     const notes = executedTx?.outputNotes?.().notes?.() ?? [];
     const result = [];
     for (const note of notes) {
-      if (note.noteType?.() === import_miden_sdk20.NoteType.Private) {
+      if (note.noteType?.() === import_lazy20.NoteType.Private) {
         const full = note.intoFull?.();
         if (full) result.push(full);
       }
@@ -2953,7 +2970,7 @@ function useTransaction() {
         const proverConfig = useMidenStore.getState().config;
         const provenTransaction = await proveWithFallback(
           (resolvedProver) => runExclusiveSafe(
-            () => client.proveTransaction(txResult, resolvedProver)
+            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
           ),
           proverConfig
         );
@@ -3016,7 +3033,7 @@ async function resolveRequest(request, client) {
 
 // src/hooks/useExecuteProgram.ts
 var import_react22 = require("react");
-var import_miden_sdk21 = require("@miden-sdk/miden-sdk");
+var import_lazy21 = require("@miden-sdk/miden-sdk");
 function isForeignAccountWrapper(fa) {
   return fa !== null && typeof fa === "object" && "id" in fa && typeof fa.id !== "function";
 }
@@ -3047,18 +3064,18 @@ function useExecuteProgram() {
         }
         const programResult = await runExclusiveSafe(async () => {
           const accountIdObj = parseAccountId(options.accountId);
-          const adviceInputs = options.adviceInputs ?? new import_miden_sdk21.AdviceInputs();
+          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_miden_sdk21.AccountStorageRequirements();
-              return import_miden_sdk21.ForeignAccount.public(id, storage);
+              const storage = wrapper && fa.storage ? fa.storage : new import_lazy21.AccountStorageRequirements();
+              return import_lazy21.ForeignAccount.public(id, storage);
             });
-            foreignAccountsArray = new import_miden_sdk21.ForeignAccountArray(accounts);
+            foreignAccountsArray = new import_lazy21.ForeignAccountArray(accounts);
           } else {
-            foreignAccountsArray = new import_miden_sdk21.ForeignAccountArray();
+            foreignAccountsArray = new import_lazy21.ForeignAccountArray();
           }
           const feltArray = await client.executeProgram(
             accountIdObj,
@@ -3102,11 +3119,11 @@ function useExecuteProgram() {
 
 // src/hooks/useCompile.ts
 var import_react23 = require("react");
-var import_miden_sdk22 = require("@miden-sdk/miden-sdk");
+var import_lazy22 = require("@miden-sdk/miden-sdk");
 function useCompile() {
   const { client, isReady } = useMiden();
   const resource = (0, import_react23.useMemo)(
-    () => client && isReady ? new import_miden_sdk22.CompilerResource(client, import_miden_sdk22.getWasmOrThrow) : null,
+    () => client && isReady ? new import_lazy22.CompilerResource(client, import_lazy22.getWasmOrThrow) : null,
     [client, isReady]
   );
   const requireResource = (0, import_react23.useCallback)(() => {
@@ -3132,7 +3149,7 @@ function useCompile() {
 
 // src/hooks/useSessionAccount.ts
 var import_react24 = require("react");
-var import_miden_sdk23 = require("@miden-sdk/miden-sdk");
+var import_lazy23 = require("@miden-sdk/miden-sdk");
 function useSessionAccount(options) {
   const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
@@ -3146,7 +3163,9 @@ function useSessionAccount(options) {
   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 authScheme = (0, import_lazy23.resolveAuthScheme)(
+    options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME
+  );
   const fundRef = (0, import_react24.useRef)(options.fund);
   fundRef.current = options.fund;
   (0, import_react24.useEffect)(() => {
@@ -3256,11 +3275,11 @@ function useSessionAccount(options) {
 function getStorageMode3(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk23.AccountStorageMode.private();
+      return import_lazy23.AccountStorageMode.private();
     case "public":
-      return import_miden_sdk23.AccountStorageMode.public();
+      return import_lazy23.AccountStorageMode.public();
     default:
-      return import_miden_sdk23.AccountStorageMode.public();
+      return import_lazy23.AccountStorageMode.public();
   }
 }
 async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
@@ -3285,7 +3304,7 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 
 // src/hooks/useExportStore.ts
 var import_react25 = require("react");
-var import_miden_sdk24 = require("@miden-sdk/miden-sdk");
+var import_lazy24 = require("@miden-sdk/miden-sdk");
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
   const [isExporting, setIsExporting] = (0, import_react25.useState)(false);
@@ -3298,7 +3317,7 @@ function useExportStore() {
     setError(null);
     try {
       const storeName = client.storeIdentifier();
-      const snapshot = await runExclusive(() => (0, import_miden_sdk24.exportStore)(storeName));
+      const snapshot = await runExclusive(() => (0, import_lazy24.exportStore)(storeName));
       return snapshot;
     } catch (err) {
       const error2 = err instanceof Error ? err : new Error(String(err));
@@ -3322,7 +3341,7 @@ function useExportStore() {
 
 // src/hooks/useImportStore.ts
 var import_react26 = require("react");
-var import_miden_sdk25 = require("@miden-sdk/miden-sdk");
+var import_lazy25 = require("@miden-sdk/miden-sdk");
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
   const [isImporting, setIsImporting] = (0, import_react26.useState)(false);
@@ -3335,7 +3354,7 @@ function useImportStore() {
       setIsImporting(true);
       setError(null);
       try {
-        await runExclusive(() => (0, import_miden_sdk25.importStore)(storeName, storeDump));
+        await runExclusive(() => (0, import_lazy25.importStore)(storeName, storeDump));
         if (!options?.skipSync) {
           await sync();
         }
@@ -3363,7 +3382,7 @@ function useImportStore() {
 
 // src/hooks/useImportNote.ts
 var import_react27 = require("react");
-var import_miden_sdk26 = require("@miden-sdk/miden-sdk");
+var import_lazy26 = require("@miden-sdk/miden-sdk");
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
   const [isImporting, setIsImporting] = (0, import_react27.useState)(false);
@@ -3376,7 +3395,7 @@ function useImportNote() {
       setIsImporting(true);
       setError(null);
       try {
-        const noteFile = import_miden_sdk26.NoteFile.deserialize(noteBytes);
+        const noteFile = import_lazy26.NoteFile.deserialize(noteBytes);
         const noteId = await runExclusive(
           () => client.importNoteFile(noteFile)
         );
@@ -3406,7 +3425,7 @@ function useImportNote() {
 
 // src/hooks/useExportNote.ts
 var import_react28 = require("react");
-var import_miden_sdk27 = require("@miden-sdk/miden-sdk");
+var import_lazy27 = require("@miden-sdk/miden-sdk");
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
   const [isExporting, setIsExporting] = (0, import_react28.useState)(false);
@@ -3420,7 +3439,7 @@ function useExportNote() {
       setError(null);
       try {
         const noteFile = await runExclusive(
-          () => client.exportNoteFile(noteId, import_miden_sdk27.NoteExportFormat.Full)
+          () => client.exportNoteFile(noteId, import_lazy27.NoteExportFormat.Full)
         );
         return noteFile.serialize();
       } catch (err) {