@miden-sdk/react 0.15.7 → 0.16.0-alpha.1

package/dist/lazy.mjs

@@ -1775,142 +1775,8 @@ function useSyncState() {
   };
 }
 
-// src/hooks/usePswapLineages.ts
-import { useCallback as useCallback9, useEffect as useEffect9, useRef as useRef4, useState as useState7 } from "react";
-function usePswapLineages() {
-  const { client, isReady } = useMiden();
-  const { lastSyncTime } = useSyncStateStore();
-  const [lineages, setLineages] = useState7([]);
-  const [isLoading, setIsLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const fetchGenRef = useRef4(0);
-  const refetch = useCallback9(async () => {
-    if (!client || !isReady) return;
-    const gen = ++fetchGenRef.current;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const fetched = await client.getPswapLineages();
-      if (gen === fetchGenRef.current) setLineages(fetched);
-    } catch (err) {
-      if (gen === fetchGenRef.current)
-        setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      if (gen === fetchGenRef.current) setIsLoading(false);
-    }
-  }, [client, isReady]);
-  useEffect9(() => {
-    if (!isReady) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, refetch]);
-  useEffect9(() => {
-    if (!isReady || !lastSyncTime) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, lastSyncTime, refetch]);
-  return { lineages, isLoading, error, refetch };
-}
-
-// src/hooks/usePswapLineagesFor.ts
-import { useCallback as useCallback10, useEffect as useEffect10, useMemo as useMemo8, useRef as useRef5, useState as useState8 } from "react";
-import { AccountId as AccountId3 } from "@miden-sdk/miden-sdk/lazy";
-function usePswapLineagesFor(account) {
-  const { client, isReady } = useMiden();
-  const { lastSyncTime } = useSyncStateStore();
-  const [lineages, setLineages] = useState8([]);
-  const [isLoading, setIsLoading] = useState8(false);
-  const [error, setError] = useState8(null);
-  const fetchGenRef = useRef5(0);
-  const accountKey = useMemo8(() => {
-    if (account == null) return null;
-    try {
-      return parseAccountId(account).toString();
-    } catch {
-      return null;
-    }
-  }, [account]);
-  const refetch = useCallback10(async () => {
-    if (!client || !isReady || accountKey == null) return;
-    const gen = ++fetchGenRef.current;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const accountIdObj = AccountId3.fromHex(accountKey);
-      const fetched = await client.getPswapLineagesFor(accountIdObj);
-      if (gen === fetchGenRef.current) setLineages(fetched);
-    } catch (err) {
-      if (gen === fetchGenRef.current)
-        setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      if (gen === fetchGenRef.current) setIsLoading(false);
-    }
-  }, [client, isReady, accountKey]);
-  useEffect10(() => {
-    if (!isReady) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, refetch]);
-  useEffect10(() => {
-    if (!isReady || !lastSyncTime) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, lastSyncTime, refetch]);
-  return { lineages, isLoading, error, refetch };
-}
-
-// src/hooks/usePswapLineage.ts
-import { useCallback as useCallback11, useEffect as useEffect11, useRef as useRef6, useState as useState9 } from "react";
-function usePswapLineage(orderId) {
-  const { client, isReady } = useMiden();
-  const { lastSyncTime } = useSyncStateStore();
-  const [lineage, setLineage] = useState9(null);
-  const [isLoading, setIsLoading] = useState9(false);
-  const [error, setError] = useState9(null);
-  const orderIdStr = orderId == null ? null : String(orderId);
-  const fetchGenRef = useRef6(0);
-  const refetch = useCallback11(async () => {
-    if (!client || !isReady || orderIdStr == null) return;
-    const gen = ++fetchGenRef.current;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const fetched = await client.getPswapLineage(orderIdStr);
-      if (gen === fetchGenRef.current) setLineage(fetched ?? null);
-    } catch (err) {
-      if (gen === fetchGenRef.current)
-        setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      if (gen === fetchGenRef.current) setIsLoading(false);
-    }
-  }, [client, isReady, orderIdStr]);
-  useEffect11(() => {
-    if (!isReady) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, refetch]);
-  useEffect11(() => {
-    if (!isReady || !lastSyncTime) return;
-    refetch();
-    return () => {
-      fetchGenRef.current++;
-    };
-  }, [isReady, lastSyncTime, refetch]);
-  return { lineage, isLoading, error, refetch };
-}
-
 // src/hooks/useCreateWallet.ts
-import { useCallback as useCallback12, useState as useState10 } from "react";
+import { useCallback as useCallback9, useState as useState7 } from "react";
 import { AccountStorageMode } from "@miden-sdk/miden-sdk/lazy";
 
 // src/utils/runExclusive.ts
@@ -1921,10 +1787,10 @@ function useCreateWallet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [wallet, setWallet] = useState10(null);
-  const [isCreating, setIsCreating] = useState10(false);
-  const [error, setError] = useState10(null);
-  const createWallet = useCallback12(
+  const [wallet, setWallet] = useState7(null);
+  const [isCreating, setIsCreating] = useState7(false);
+  const [error, setError] = useState7(null);
+  const createWallet = useCallback9(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1959,7 +1825,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback12(() => {
+  const reset = useCallback9(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1984,16 +1850,16 @@ function getStorageMode(mode) {
 }
 
 // src/hooks/useCreateFaucet.ts
-import { useCallback as useCallback13, useState as useState11 } from "react";
+import { useCallback as useCallback10, useState as useState8 } from "react";
 import { AccountStorageMode as AccountStorageMode2 } from "@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] = useState11(null);
-  const [isCreating, setIsCreating] = useState11(false);
-  const [error, setError] = useState11(null);
-  const createFaucet = useCallback13(
+  const [faucet, setFaucet] = useState8(null);
+  const [isCreating, setIsCreating] = useState8(false);
+  const [error, setError] = useState8(null);
+  const createFaucet = useCallback10(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2033,7 +1899,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback13(() => {
+  const reset = useCallback10(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -2058,7 +1924,7 @@ function getStorageMode2(mode) {
 }
 
 // src/hooks/useImportAccount.ts
-import { useCallback as useCallback14, useState as useState12 } from "react";
+import { useCallback as useCallback11, useState as useState9 } from "react";
 import { AccountFile } from "@miden-sdk/miden-sdk/lazy";
 
 // src/utils/errors.ts
@@ -2117,10 +1983,10 @@ function wrapWasmError(e) {
 function useImportAccount() {
   const { client, isReady, signerConnected } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [account, setAccount] = useState12(null);
-  const [isImporting, setIsImporting] = useState12(false);
-  const [error, setError] = useState12(null);
-  const importAccount = useCallback14(
+  const [account, setAccount] = useState9(null);
+  const [isImporting, setIsImporting] = useState9(false);
+  const [error, setError] = useState9(null);
+  const importAccount = useCallback11(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2214,7 +2080,7 @@ function useImportAccount() {
     },
     [client, isReady, setAccounts, signerConnected]
   );
-  const reset = useCallback14(() => {
+  const reset = useCallback11(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -2261,7 +2127,7 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-import { useCallback as useCallback15, useRef as useRef7, useState as useState13 } from "react";
+import { useCallback as useCallback12, useRef as useRef4, useState as useState10 } from "react";
 import {
   FungibleAsset,
   Note,
@@ -2273,12 +2139,12 @@ import {
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef7(false);
-  const [result, setResult] = useState13(null);
-  const [isLoading, setIsLoading] = useState13(false);
-  const [stage, setStage] = useState13("idle");
-  const [error, setError] = useState13(null);
-  const send = useCallback15(
+  const isBusyRef = useRef4(false);
+  const [result, setResult] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [stage, setStage] = useState10("idle");
+  const [error, setError] = useState10(null);
+  const send = useCallback12(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2449,7 +2315,7 @@ function useSend() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback15(() => {
+  const reset = useCallback12(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2476,7 +2342,7 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-import { useCallback as useCallback16, useRef as useRef8, useState as useState14 } from "react";
+import { useCallback as useCallback13, useRef as useRef5, useState as useState11 } from "react";
 import {
   FungibleAsset as FungibleAsset2,
   Note as Note2,
@@ -2487,12 +2353,12 @@ import {
 } from "@miden-sdk/miden-sdk/lazy";
 function useMultiSend() {
   const { client, isReady, sync, prover, signerConnected } = useMiden();
-  const isBusyRef = useRef8(false);
-  const [result, setResult] = useState14(null);
-  const [isLoading, setIsLoading] = useState14(false);
-  const [stage, setStage] = useState14("idle");
-  const [error, setError] = useState14(null);
-  const sendMany = useCallback16(
+  const isBusyRef = useRef5(false);
+  const [result, setResult] = useState11(null);
+  const [isLoading, setIsLoading] = useState11(false);
+  const [stage, setStage] = useState11("idle");
+  const [error, setError] = useState11(null);
+  const sendMany = useCallback13(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2596,7 +2462,7 @@ function useMultiSend() {
     },
     [client, isReady, prover, signerConnected, sync]
   );
-  const reset = useCallback16(() => {
+  const reset = useCallback13(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2613,11 +2479,11 @@ function useMultiSend() {
 }
 
 // src/hooks/useWaitForCommit.ts
-import { useCallback as useCallback17 } from "react";
+import { useCallback as useCallback14 } from "react";
 import { TransactionFilter as TransactionFilter3 } from "@miden-sdk/miden-sdk/lazy";
 function useWaitForCommit() {
   const { client, isReady } = useMiden();
-  const waitForCommit = useCallback17(
+  const waitForCommit = useCallback14(
     async (txId, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2660,11 +2526,11 @@ function normalizeHex3(value) {
 }
 
 // src/hooks/useWaitForNotes.ts
-import { useCallback as useCallback18 } from "react";
+import { useCallback as useCallback15 } from "react";
 function useWaitForNotes() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const waitForConsumableNotes = useCallback18(
+  const waitForConsumableNotes = useCallback15(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2695,15 +2561,15 @@ function useWaitForNotes() {
 }
 
 // src/hooks/useMint.ts
-import { useCallback as useCallback19, useState as useState15 } from "react";
+import { useCallback as useCallback16, useState as useState12 } from "react";
 function useMint() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState15(null);
-  const [isLoading, setIsLoading] = useState15(false);
-  const [stage, setStage] = useState15("idle");
-  const [error, setError] = useState15(null);
-  const mint = useCallback19(
+  const [result, setResult] = useState12(null);
+  const [isLoading, setIsLoading] = useState12(false);
+  const [stage, setStage] = useState12("idle");
+  const [error, setError] = useState12(null);
+  const mint = useCallback16(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2745,7 +2611,7 @@ function useMint() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback19(() => {
+  const reset = useCallback16(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2761,92 +2627,17 @@ function useMint() {
   };
 }
 
-// src/hooks/useBridge.ts
-import { useCallback as useCallback20, useState as useState16 } from "react";
-import { EthAddress } from "@miden-sdk/miden-sdk/lazy";
-function useBridge() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState16(null);
-  const [isLoading, setIsLoading] = useState16(false);
-  const [stage, setStage] = useState16("idle");
-  const [error, setError] = useState16(null);
-  const bridge = useCallback20(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      setIsLoading(true);
-      setStage("executing");
-      setError(null);
-      try {
-        const senderId = parseAccountId(options.from);
-        const bridgeId = parseAccountId(options.bridgeAccount);
-        const assetId = parseAccountId(options.assetId);
-        const destinationAddress = EthAddress.fromHex(
-          options.destinationAddress
-        );
-        setStage("proving");
-        const txResult = await runExclusiveSafe(async () => {
-          const txRequest = await client.newB2AggTransactionRequest(
-            senderId,
-            bridgeId,
-            assetId,
-            BigInt(options.amount),
-            options.destinationNetwork,
-            destinationAddress
-          );
-          const txId = prover ? await client.submitNewTransactionWithProver(
-            senderId,
-            txRequest,
-            prover
-          ) : await client.submitNewTransaction(senderId, txRequest);
-          return { transactionId: txId.toHex() };
-        });
-        setStage("complete");
-        setResult(txResult);
-        if (!options.skipSync) {
-          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 = useCallback20(() => {
-    setResult(null);
-    setIsLoading(false);
-    setStage("idle");
-    setError(null);
-  }, []);
-  return {
-    bridge,
-    result,
-    isLoading,
-    stage,
-    error,
-    reset
-  };
-}
-
 // src/hooks/useConsume.ts
-import { useCallback as useCallback21, useState as useState17 } from "react";
+import { useCallback as useCallback17, useState as useState13 } from "react";
 import { NoteFilter as NoteFilter3, NoteFilterTypes as NoteFilterTypes2, NoteId } from "@miden-sdk/miden-sdk/lazy";
 function useConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState17(null);
-  const [isLoading, setIsLoading] = useState17(false);
-  const [stage, setStage] = useState17("idle");
-  const [error, setError] = useState17(null);
-  const consume = useCallback21(
+  const [result, setResult] = useState13(null);
+  const [isLoading, setIsLoading] = useState13(false);
+  const [stage, setStage] = useState13("idle");
+  const [error, setError] = useState13(null);
+  const consume = useCallback17(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2930,7 +2721,7 @@ function useConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback21(() => {
+  const reset = useCallback17(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2947,15 +2738,15 @@ function useConsume() {
 }
 
 // src/hooks/useSwap.ts
-import { useCallback as useCallback22, useState as useState18 } from "react";
+import { useCallback as useCallback18, useState as useState14 } from "react";
 function useSwap() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState18(null);
-  const [isLoading, setIsLoading] = useState18(false);
-  const [stage, setStage] = useState18("idle");
-  const [error, setError] = useState18(null);
-  const swap = useCallback22(
+  const [result, setResult] = useState14(null);
+  const [isLoading, setIsLoading] = useState14(false);
+  const [stage, setStage] = useState14("idle");
+  const [error, setError] = useState14(null);
+  const swap = useCallback18(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3004,7 +2795,7 @@ function useSwap() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback22(() => {
+  const reset = useCallback18(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3021,15 +2812,15 @@ function useSwap() {
 }
 
 // src/hooks/usePswapCreate.ts
-import { useCallback as useCallback23, useState as useState19 } from "react";
+import { useCallback as useCallback19, useState as useState15 } from "react";
 function usePswapCreate() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState19(null);
-  const [isLoading, setIsLoading] = useState19(false);
-  const [stage, setStage] = useState19("idle");
-  const [error, setError] = useState19(null);
-  const pswapCreate = useCallback23(
+  const [result, setResult] = useState15(null);
+  const [isLoading, setIsLoading] = useState15(false);
+  const [stage, setStage] = useState15("idle");
+  const [error, setError] = useState15(null);
+  const pswapCreate = useCallback19(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3086,7 +2877,7 @@ function usePswapCreate() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback23(() => {
+  const reset = useCallback19(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3103,15 +2894,15 @@ function usePswapCreate() {
 }
 
 // src/hooks/usePswapConsume.ts
-import { useCallback as useCallback24, useState as useState20 } from "react";
+import { useCallback as useCallback20, useState as useState16 } from "react";
 function usePswapConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState20(null);
-  const [isLoading, setIsLoading] = useState20(false);
-  const [stage, setStage] = useState20("idle");
-  const [error, setError] = useState20(null);
-  const pswapConsume = useCallback24(
+  const [result, setResult] = useState16(null);
+  const [isLoading, setIsLoading] = useState16(false);
+  const [stage, setStage] = useState16("idle");
+  const [error, setError] = useState16(null);
+  const pswapConsume = useCallback20(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3160,7 +2951,7 @@ function usePswapConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback24(() => {
+  const reset = useCallback20(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3177,15 +2968,15 @@ function usePswapConsume() {
 }
 
 // src/hooks/usePswapCancel.ts
-import { useCallback as useCallback25, useState as useState21 } from "react";
+import { useCallback as useCallback21, useState as useState17 } from "react";
 function usePswapCancel() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState21(null);
-  const [isLoading, setIsLoading] = useState21(false);
-  const [stage, setStage] = useState21("idle");
-  const [error, setError] = useState21(null);
-  const pswapCancel = useCallback25(
+  const [result, setResult] = useState17(null);
+  const [isLoading, setIsLoading] = useState17(false);
+  const [stage, setStage] = useState17("idle");
+  const [error, setError] = useState17(null);
+  const pswapCancel = useCallback21(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3224,7 +3015,7 @@ function usePswapCancel() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback25(() => {
+  const reset = useCallback21(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3240,189 +3031,11 @@ function usePswapCancel() {
   };
 }
 
-// src/hooks/usePswapCancelByOrder.ts
-import { useCallback as useCallback26, useState as useState22 } from "react";
-function usePswapCancelByOrder() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState22(null);
-  const [isLoading, setIsLoading] = useState22(false);
-  const [stage, setStage] = useState22("idle");
-  const [error, setError] = useState22(null);
-  const pswapCancelByOrder = useCallback26(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      setIsLoading(true);
-      setStage("executing");
-      setError(null);
-      try {
-        const orderId = String(options.orderId);
-        setStage("proving");
-        const txResult = await runExclusiveSafe(async () => {
-          const lineage = await client.getPswapLineage(orderId);
-          if (!lineage) {
-            throw new Error(`No PSWAP lineage tracked for order ${orderId}`);
-          }
-          const accountIdObj = lineage.creatorAccountId();
-          const txRequest = await client.buildPswapCancelByOrder(orderId);
-          const txId = prover ? await client.submitNewTransactionWithProver(
-            accountIdObj,
-            txRequest,
-            prover
-          ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toHex() };
-        });
-        setResult(txResult);
-        await sync();
-        setStage("complete");
-        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 = useCallback26(() => {
-    setResult(null);
-    setIsLoading(false);
-    setStage("idle");
-    setError(null);
-  }, []);
-  return {
-    pswapCancelByOrder,
-    result,
-    isLoading,
-    stage,
-    error,
-    reset
-  };
-}
-
-// src/hooks/useCreateNetworkNote.ts
-import { useCallback as useCallback27, useState as useState23 } from "react";
-import {
-  Felt,
-  FeltArray,
-  FungibleAsset as FungibleAsset3,
-  Note as Note3,
-  NoteArray as NoteArray3,
-  NoteAssets as NoteAssets3,
-  NoteMetadata,
-  NoteStorage,
-  NoteRecipient,
-  NoteTag,
-  NoteType as NoteType4,
-  NetworkAccountTarget,
-  TransactionRequestBuilder as TransactionRequestBuilder3
-} from "@miden-sdk/miden-sdk/lazy";
-function useCreateNetworkNote() {
-  const { client, isReady, sync, runExclusive, prover } = useMiden();
-  const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState23(null);
-  const [isLoading, setIsLoading] = useState23(false);
-  const [stage, setStage] = useState23("idle");
-  const [error, setError] = useState23(null);
-  const createNetworkNote = useCallback27(
-    async (options) => {
-      if (!client || !isReady) {
-        throw new Error("Miden client is not ready");
-      }
-      if (options.recipient && options.script) {
-        throw new Error(
-          "createNetworkNote requires exactly one of `recipient` or `script`, not both."
-        );
-      }
-      if (!options.recipient && !options.script) {
-        throw new Error(
-          "createNetworkNote requires either `recipient` or `script`."
-        );
-      }
-      setIsLoading(true);
-      setStage("executing");
-      setError(null);
-      try {
-        const built = await runExclusiveSafe(async () => {
-          const senderId = parseAccountId(options.accountId);
-          const targetId = parseAccountId(options.target);
-          const target = new NetworkAccountTarget(
-            targetId,
-            options.executionHint
-          );
-          const noteAssets = options.assetId != null ? new NoteAssets3([
-            new FungibleAsset3(
-              parseAccountId(options.assetId),
-              BigInt(options.amount ?? 0)
-            )
-          ]) : new NoteAssets3();
-          const metadata = new NoteMetadata(
-            senderId,
-            NoteType4.Public,
-            NoteTag.withAccountTarget(target.targetId())
-          );
-          const recipient = options.recipient ?? NoteRecipient.fromScript(
-            options.script,
-            new NoteStorage(
-              new FeltArray(
-                (options.inputs ?? []).map((value) => new Felt(value))
-              )
-            )
-          );
-          const attachments = [target.toAttachment()];
-          if (options.attachment) {
-            attachments.push(createNoteAttachment(options.attachment));
-          }
-          const note = Note3.withAttachments(
-            noteAssets,
-            metadata,
-            recipient,
-            attachments
-          );
-          const ownOutputs = new NoteArray3();
-          ownOutputs.push(note);
-          const txRequest = new TransactionRequestBuilder3().withOwnOutputNotes(ownOutputs).build();
-          const txId = prover ? await client.submitNewTransactionWithProver(
-            senderId,
-            txRequest,
-            prover
-          ) : await client.submitNewTransaction(senderId, txRequest);
-          return { txId: txId.toHex(), note };
-        });
-        setStage("complete");
-        setResult(built);
-        await sync();
-        return built;
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error(String(err));
-        setError(e);
-        setStage("idle");
-        throw e;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [client, isReady, prover, runExclusive, sync]
-  );
-  const reset = useCallback27(() => {
-    setResult(null);
-    setIsLoading(false);
-    setStage("idle");
-    setError(null);
-  }, []);
-  return { createNetworkNote, result, isLoading, stage, error, reset };
-}
-
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback28, useRef as useRef9, useState as useState24 } from "react";
+import { useCallback as useCallback22, useRef as useRef6, useState as useState18 } from "react";
 
 // src/utils/transactions.ts
-import { NoteType as NoteType5, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/lazy";
+import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/lazy";
 async function waitForTransactionCommit2(client, runExclusiveSafe, txId, maxWaitMs = 1e4, delayMs = 1e3) {
   let waited = 0;
   while (waited < maxWaitMs) {
@@ -3450,7 +3063,7 @@ function extractFullNotes(txResult) {
     const notes = executedTx?.outputNotes?.().notes?.() ?? [];
     const result = [];
     for (const note of notes) {
-      if (note.noteType?.() === NoteType5.Private) {
+      if (note.noteType?.() === NoteType4.Private) {
         const full = note.intoFull?.();
         if (full) result.push(full);
       }
@@ -3465,12 +3078,12 @@ function extractFullNotes(txResult) {
 function useTransaction() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef9(false);
-  const [result, setResult] = useState24(null);
-  const [isLoading, setIsLoading] = useState24(false);
-  const [stage, setStage] = useState24("idle");
-  const [error, setError] = useState24(null);
-  const execute = useCallback28(
+  const isBusyRef = useRef6(false);
+  const [result, setResult] = useState18(null);
+  const [isLoading, setIsLoading] = useState18(false);
+  const [stage, setStage] = useState18("idle");
+  const [error, setError] = useState18(null);
+  const execute = useCallback22(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3537,7 +3150,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback28(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3560,7 +3173,7 @@ async function resolveRequest(request, client) {
 }
 
 // src/hooks/useExecuteProgram.ts
-import { useCallback as useCallback29, useRef as useRef10, useState as useState25 } from "react";
+import { useCallback as useCallback23, useRef as useRef7, useState as useState19 } from "react";
 import {
   AdviceInputs,
   ForeignAccount,
@@ -3573,11 +3186,11 @@ function isForeignAccountWrapper(fa) {
 function useExecuteProgram() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef10(false);
-  const [result, setResult] = useState25(null);
-  const [isLoading, setIsLoading] = useState25(false);
-  const [error, setError] = useState25(null);
-  const execute = useCallback29(
+  const isBusyRef = useRef7(false);
+  const [result, setResult] = useState19(null);
+  const [isLoading, setIsLoading] = useState19(false);
+  const [error, setError] = useState19(null);
+  const execute = useCallback23(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3636,7 +3249,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback29(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3651,29 +3264,29 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-import { useCallback as useCallback30, useMemo as useMemo9 } from "react";
+import { useCallback as useCallback24, useMemo as useMemo8 } from "react";
 import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk/lazy";
 function useCompile() {
   const { client, isReady } = useMiden();
-  const resource = useMemo9(
+  const resource = useMemo8(
     () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = useCallback30(() => {
+  const requireResource = useCallback24(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = useCallback30(
+  const component = useCallback24(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = useCallback30(
+  const txScript = useCallback24(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = useCallback30(
+  const noteScript = useCallback24(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3681,24 +3294,24 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback31, useEffect as useEffect12, useRef as useRef11, useState as useState26 } from "react";
+import { useCallback as useCallback25, useEffect as useEffect9, useRef as useRef8, useState as useState20 } from "react";
 import { AccountStorageMode as AccountStorageMode3 } from "@miden-sdk/miden-sdk/lazy";
 function useSessionAccount(options) {
   const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = useState26(null);
-  const [step, setStep] = useState26("idle");
-  const [error, setError] = useState26(null);
-  const cancelledRef = useRef11(false);
-  const isBusyRef = useRef11(false);
+  const [sessionAccountId, setSessionAccountId] = useState20(null);
+  const [step, setStep] = useState20("idle");
+  const [error, setError] = useState20(null);
+  const cancelledRef = useRef8(false);
+  const isBusyRef = useRef8(false);
   const storagePrefix = options.storagePrefix ?? "miden-session";
   const pollIntervalMs = options.pollIntervalMs ?? 3e3;
   const maxWaitMs = options.maxWaitMs ?? 6e4;
   const storageMode = options.walletOptions?.storageMode ?? "public";
   const authScheme = options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME;
-  const fundRef = useRef11(options.fund);
+  const fundRef = useRef8(options.fund);
   fundRef.current = options.fund;
-  useEffect12(() => {
+  useEffect9(() => {
     try {
       const stored = localStorage.getItem(`${storagePrefix}:accountId`);
       const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
@@ -3715,7 +3328,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback31(async () => {
+  const initialize = useCallback25(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3779,7 +3392,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback31(() => {
+  const reset = useCallback25(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3828,13 +3441,13 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 }
 
 // src/hooks/useExportStore.ts
-import { useCallback as useCallback32, useState as useState27 } from "react";
+import { useCallback as useCallback26, useState as useState21 } from "react";
 import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk/lazy";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState27(false);
-  const [error, setError] = useState27(null);
-  const exportStore = useCallback32(async () => {
+  const [isExporting, setIsExporting] = useState21(false);
+  const [error, setError] = useState21(null);
+  const exportStore = useCallback26(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3852,7 +3465,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback32(() => {
+  const reset = useCallback26(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3865,13 +3478,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-import { useCallback as useCallback33, useState as useState28 } from "react";
+import { useCallback as useCallback27, useState as useState22 } from "react";
 import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk/lazy";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState28(false);
-  const [error, setError] = useState28(null);
-  const importStore = useCallback33(
+  const [isImporting, setIsImporting] = useState22(false);
+  const [error, setError] = useState22(null);
+  const importStore = useCallback27(
     async (storeDump, storeName, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3893,7 +3506,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback33(() => {
+  const reset = useCallback27(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3906,13 +3519,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-import { useCallback as useCallback34, useState as useState29 } from "react";
+import { useCallback as useCallback28, useState as useState23 } from "react";
 import { NoteFile } from "@miden-sdk/miden-sdk/lazy";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState29(false);
-  const [error, setError] = useState29(null);
-  const importNote = useCallback34(
+  const [isImporting, setIsImporting] = useState23(false);
+  const [error, setError] = useState23(null);
+  const importNote = useCallback28(
     async (noteBytes) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3936,7 +3549,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback34(() => {
+  const reset = useCallback28(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3949,13 +3562,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-import { useCallback as useCallback35, useState as useState30 } from "react";
+import { useCallback as useCallback29, useState as useState24 } from "react";
 import { NoteExportFormat } from "@miden-sdk/miden-sdk/lazy";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState30(false);
-  const [error, setError] = useState30(null);
-  const exportNote = useCallback35(
+  const [isExporting, setIsExporting] = useState24(false);
+  const [error, setError] = useState24(null);
+  const exportNote = useCallback29(
     async (noteId) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3977,7 +3590,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback35(() => {
+  const reset = useCallback29(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3990,12 +3603,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-import { useCallback as useCallback36 } from "react";
+import { useCallback as useCallback30 } from "react";
 function useSyncControl() {
   const isPaused = useMidenStore((state) => state.syncPaused);
   const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
-  const pauseSync = useCallback36(() => setSyncPaused(true), [setSyncPaused]);
-  const resumeSync = useCallback36(() => setSyncPaused(false), [setSyncPaused]);
+  const pauseSync = useCallback30(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback30(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -4180,11 +3793,9 @@ export {
   useAccount,
   useAccounts,
   useAssetMetadata,
-  useBridge,
   useCompile,
   useConsume,
   useCreateFaucet,
-  useCreateNetworkNote,
   useCreateWallet,
   useExecuteProgram,
   useExportNote,
@@ -4200,12 +3811,8 @@ export {
   useNoteStream,
   useNotes,
   usePswapCancel,
-  usePswapCancelByOrder,
   usePswapConsume,
   usePswapCreate,
-  usePswapLineage,
-  usePswapLineages,
-  usePswapLineagesFor,
   useSend,
   useSessionAccount,
   useSigner,