@miden-sdk/react 0.15.1 → 0.15.3

package/dist/lazy.mjs

@@ -1775,8 +1775,142 @@ 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 useCallback9, useState as useState7 } from "react";
+import { useCallback as useCallback12, useState as useState10 } from "react";
 import { AccountStorageMode } from "@miden-sdk/miden-sdk/lazy";
 
 // src/utils/runExclusive.ts
@@ -1787,10 +1921,10 @@ function useCreateWallet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [wallet, setWallet] = useState7(null);
-  const [isCreating, setIsCreating] = useState7(false);
-  const [error, setError] = useState7(null);
-  const createWallet = useCallback9(
+  const [wallet, setWallet] = useState10(null);
+  const [isCreating, setIsCreating] = useState10(false);
+  const [error, setError] = useState10(null);
+  const createWallet = useCallback12(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1825,7 +1959,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback9(() => {
+  const reset = useCallback12(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1850,16 +1984,16 @@ function getStorageMode(mode) {
 }
 
 // src/hooks/useCreateFaucet.ts
-import { useCallback as useCallback10, useState as useState8 } from "react";
+import { useCallback as useCallback13, useState as useState11 } 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] = useState8(null);
-  const [isCreating, setIsCreating] = useState8(false);
-  const [error, setError] = useState8(null);
-  const createFaucet = useCallback10(
+  const [faucet, setFaucet] = useState11(null);
+  const [isCreating, setIsCreating] = useState11(false);
+  const [error, setError] = useState11(null);
+  const createFaucet = useCallback13(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1899,7 +2033,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = useCallback10(() => {
+  const reset = useCallback13(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -1924,7 +2058,7 @@ function getStorageMode2(mode) {
 }
 
 // src/hooks/useImportAccount.ts
-import { useCallback as useCallback11, useState as useState9 } from "react";
+import { useCallback as useCallback14, useState as useState12 } from "react";
 import { AccountFile } from "@miden-sdk/miden-sdk/lazy";
 
 // src/utils/errors.ts
@@ -1983,10 +2117,10 @@ function wrapWasmError(e) {
 function useImportAccount() {
   const { client, isReady, signerConnected } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [account, setAccount] = useState9(null);
-  const [isImporting, setIsImporting] = useState9(false);
-  const [error, setError] = useState9(null);
-  const importAccount = useCallback11(
+  const [account, setAccount] = useState12(null);
+  const [isImporting, setIsImporting] = useState12(false);
+  const [error, setError] = useState12(null);
+  const importAccount = useCallback14(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2080,7 +2214,7 @@ function useImportAccount() {
     },
     [client, isReady, setAccounts, signerConnected]
   );
-  const reset = useCallback11(() => {
+  const reset = useCallback14(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -2127,7 +2261,7 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-import { useCallback as useCallback12, useRef as useRef4, useState as useState10 } from "react";
+import { useCallback as useCallback15, useRef as useRef7, useState as useState13 } from "react";
 import {
   FungibleAsset,
   Note,
@@ -2139,12 +2273,12 @@ import {
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  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(
+  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(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2315,7 +2449,7 @@ function useSend() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback12(() => {
+  const reset = useCallback15(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2342,7 +2476,7 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-import { useCallback as useCallback13, useRef as useRef5, useState as useState11 } from "react";
+import { useCallback as useCallback16, useRef as useRef8, useState as useState14 } from "react";
 import {
   FungibleAsset as FungibleAsset2,
   Note as Note2,
@@ -2353,12 +2487,12 @@ import {
 } from "@miden-sdk/miden-sdk/lazy";
 function useMultiSend() {
   const { client, isReady, sync, prover, signerConnected } = useMiden();
-  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(
+  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(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2462,7 +2596,7 @@ function useMultiSend() {
     },
     [client, isReady, prover, signerConnected, sync]
   );
-  const reset = useCallback13(() => {
+  const reset = useCallback16(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2479,11 +2613,11 @@ function useMultiSend() {
 }
 
 // src/hooks/useWaitForCommit.ts
-import { useCallback as useCallback14 } from "react";
+import { useCallback as useCallback17 } from "react";
 import { TransactionFilter as TransactionFilter3 } from "@miden-sdk/miden-sdk/lazy";
 function useWaitForCommit() {
   const { client, isReady } = useMiden();
-  const waitForCommit = useCallback14(
+  const waitForCommit = useCallback17(
     async (txId, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2526,11 +2660,11 @@ function normalizeHex3(value) {
 }
 
 // src/hooks/useWaitForNotes.ts
-import { useCallback as useCallback15 } from "react";
+import { useCallback as useCallback18 } from "react";
 function useWaitForNotes() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const waitForConsumableNotes = useCallback15(
+  const waitForConsumableNotes = useCallback18(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2561,15 +2695,15 @@ function useWaitForNotes() {
 }
 
 // src/hooks/useMint.ts
-import { useCallback as useCallback16, useState as useState12 } from "react";
+import { useCallback as useCallback19, useState as useState15 } from "react";
 function useMint() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState12(null);
-  const [isLoading, setIsLoading] = useState12(false);
-  const [stage, setStage] = useState12("idle");
-  const [error, setError] = useState12(null);
-  const mint = useCallback16(
+  const [result, setResult] = useState15(null);
+  const [isLoading, setIsLoading] = useState15(false);
+  const [stage, setStage] = useState15("idle");
+  const [error, setError] = useState15(null);
+  const mint = useCallback19(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2611,7 +2745,7 @@ function useMint() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback16(() => {
+  const reset = useCallback19(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2628,16 +2762,16 @@ function useMint() {
 }
 
 // src/hooks/useConsume.ts
-import { useCallback as useCallback17, useState as useState13 } from "react";
+import { useCallback as useCallback20, useState as useState16 } 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] = useState13(null);
-  const [isLoading, setIsLoading] = useState13(false);
-  const [stage, setStage] = useState13("idle");
-  const [error, setError] = useState13(null);
-  const consume = useCallback17(
+  const [result, setResult] = useState16(null);
+  const [isLoading, setIsLoading] = useState16(false);
+  const [stage, setStage] = useState16("idle");
+  const [error, setError] = useState16(null);
+  const consume = useCallback20(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2721,7 +2855,7 @@ function useConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback17(() => {
+  const reset = useCallback20(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2738,15 +2872,15 @@ function useConsume() {
 }
 
 // src/hooks/useSwap.ts
-import { useCallback as useCallback18, useState as useState14 } from "react";
+import { useCallback as useCallback21, useState as useState17 } from "react";
 function useSwap() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = useState14(null);
-  const [isLoading, setIsLoading] = useState14(false);
-  const [stage, setStage] = useState14("idle");
-  const [error, setError] = useState14(null);
-  const swap = useCallback18(
+  const [result, setResult] = useState17(null);
+  const [isLoading, setIsLoading] = useState17(false);
+  const [stage, setStage] = useState17("idle");
+  const [error, setError] = useState17(null);
+  const swap = useCallback21(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2795,7 +2929,7 @@ function useSwap() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback18(() => {
+  const reset = useCallback21(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2812,15 +2946,15 @@ function useSwap() {
 }
 
 // src/hooks/usePswapCreate.ts
-import { useCallback as useCallback19, useState as useState15 } from "react";
+import { useCallback as useCallback22, useState as useState18 } from "react";
 function usePswapCreate() {
   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 pswapCreate = useCallback19(
+  const [result, setResult] = useState18(null);
+  const [isLoading, setIsLoading] = useState18(false);
+  const [stage, setStage] = useState18("idle");
+  const [error, setError] = useState18(null);
+  const pswapCreate = useCallback22(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2877,7 +3011,7 @@ function usePswapCreate() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback19(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2894,15 +3028,15 @@ function usePswapCreate() {
 }
 
 // src/hooks/usePswapConsume.ts
-import { useCallback as useCallback20, useState as useState16 } from "react";
+import { useCallback as useCallback23, useState as useState19 } from "react";
 function usePswapConsume() {
   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 pswapConsume = useCallback20(
+  const [result, setResult] = useState19(null);
+  const [isLoading, setIsLoading] = useState19(false);
+  const [stage, setStage] = useState19("idle");
+  const [error, setError] = useState19(null);
+  const pswapConsume = useCallback23(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2951,7 +3085,7 @@ function usePswapConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback20(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2968,15 +3102,15 @@ function usePswapConsume() {
 }
 
 // src/hooks/usePswapCancel.ts
-import { useCallback as useCallback21, useState as useState17 } from "react";
+import { useCallback as useCallback24, useState as useState20 } from "react";
 function usePswapCancel() {
   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 pswapCancel = useCallback21(
+  const [result, setResult] = useState20(null);
+  const [isLoading, setIsLoading] = useState20(false);
+  const [stage, setStage] = useState20("idle");
+  const [error, setError] = useState20(null);
+  const pswapCancel = useCallback24(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3015,7 +3149,7 @@ function usePswapCancel() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = useCallback21(() => {
+  const reset = useCallback24(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3031,8 +3165,73 @@ function usePswapCancel() {
   };
 }
 
+// src/hooks/usePswapCancelByOrder.ts
+import { useCallback as useCallback25, useState as useState21 } from "react";
+function usePswapCancelByOrder() {
+  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 pswapCancelByOrder = useCallback25(
+    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 = useCallback25(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    pswapCancelByOrder,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback22, useRef as useRef6, useState as useState18 } from "react";
+import { useCallback as useCallback26, useRef as useRef9, useState as useState22 } from "react";
 
 // src/utils/transactions.ts
 import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/lazy";
@@ -3078,12 +3277,12 @@ function extractFullNotes(txResult) {
 function useTransaction() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  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(
+  const isBusyRef = useRef9(false);
+  const [result, setResult] = useState22(null);
+  const [isLoading, setIsLoading] = useState22(false);
+  const [stage, setStage] = useState22("idle");
+  const [error, setError] = useState22(null);
+  const execute = useCallback26(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3150,7 +3349,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback22(() => {
+  const reset = useCallback26(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3173,7 +3372,7 @@ async function resolveRequest(request, client) {
 }
 
 // src/hooks/useExecuteProgram.ts
-import { useCallback as useCallback23, useRef as useRef7, useState as useState19 } from "react";
+import { useCallback as useCallback27, useRef as useRef10, useState as useState23 } from "react";
 import {
   AdviceInputs,
   ForeignAccount,
@@ -3186,11 +3385,11 @@ function isForeignAccountWrapper(fa) {
 function useExecuteProgram() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = useRef7(false);
-  const [result, setResult] = useState19(null);
-  const [isLoading, setIsLoading] = useState19(false);
-  const [error, setError] = useState19(null);
-  const execute = useCallback23(
+  const isBusyRef = useRef10(false);
+  const [result, setResult] = useState23(null);
+  const [isLoading, setIsLoading] = useState23(false);
+  const [error, setError] = useState23(null);
+  const execute = useCallback27(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3249,7 +3448,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback23(() => {
+  const reset = useCallback27(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3264,29 +3463,29 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-import { useCallback as useCallback24, useMemo as useMemo8 } from "react";
+import { useCallback as useCallback28, useMemo as useMemo9 } from "react";
 import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk/lazy";
 function useCompile() {
   const { client, isReady } = useMiden();
-  const resource = useMemo8(
+  const resource = useMemo9(
     () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = useCallback24(() => {
+  const requireResource = useCallback28(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = useCallback24(
+  const component = useCallback28(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = useCallback24(
+  const txScript = useCallback28(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = useCallback24(
+  const noteScript = useCallback28(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3294,24 +3493,24 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback25, useEffect as useEffect9, useRef as useRef8, useState as useState20 } from "react";
+import { useCallback as useCallback29, useEffect as useEffect12, useRef as useRef11, useState as useState24 } 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] = useState20(null);
-  const [step, setStep] = useState20("idle");
-  const [error, setError] = useState20(null);
-  const cancelledRef = useRef8(false);
-  const isBusyRef = useRef8(false);
+  const [sessionAccountId, setSessionAccountId] = useState24(null);
+  const [step, setStep] = useState24("idle");
+  const [error, setError] = useState24(null);
+  const cancelledRef = useRef11(false);
+  const isBusyRef = useRef11(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 = useRef8(options.fund);
+  const fundRef = useRef11(options.fund);
   fundRef.current = options.fund;
-  useEffect9(() => {
+  useEffect12(() => {
     try {
       const stored = localStorage.getItem(`${storagePrefix}:accountId`);
       const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
@@ -3328,7 +3527,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback25(async () => {
+  const initialize = useCallback29(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3392,7 +3591,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback25(() => {
+  const reset = useCallback29(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3441,13 +3640,13 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 }
 
 // src/hooks/useExportStore.ts
-import { useCallback as useCallback26, useState as useState21 } from "react";
+import { useCallback as useCallback30, useState as useState25 } from "react";
 import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk/lazy";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState21(false);
-  const [error, setError] = useState21(null);
-  const exportStore = useCallback26(async () => {
+  const [isExporting, setIsExporting] = useState25(false);
+  const [error, setError] = useState25(null);
+  const exportStore = useCallback30(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3465,7 +3664,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback26(() => {
+  const reset = useCallback30(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3478,13 +3677,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-import { useCallback as useCallback27, useState as useState22 } from "react";
+import { useCallback as useCallback31, useState as useState26 } from "react";
 import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk/lazy";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState22(false);
-  const [error, setError] = useState22(null);
-  const importStore = useCallback27(
+  const [isImporting, setIsImporting] = useState26(false);
+  const [error, setError] = useState26(null);
+  const importStore = useCallback31(
     async (storeDump, storeName, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3506,7 +3705,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback27(() => {
+  const reset = useCallback31(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3519,13 +3718,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-import { useCallback as useCallback28, useState as useState23 } from "react";
+import { useCallback as useCallback32, useState as useState27 } from "react";
 import { NoteFile } from "@miden-sdk/miden-sdk/lazy";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState23(false);
-  const [error, setError] = useState23(null);
-  const importNote = useCallback28(
+  const [isImporting, setIsImporting] = useState27(false);
+  const [error, setError] = useState27(null);
+  const importNote = useCallback32(
     async (noteBytes) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3549,7 +3748,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback28(() => {
+  const reset = useCallback32(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3562,13 +3761,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-import { useCallback as useCallback29, useState as useState24 } from "react";
+import { useCallback as useCallback33, useState as useState28 } from "react";
 import { NoteExportFormat } from "@miden-sdk/miden-sdk/lazy";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState24(false);
-  const [error, setError] = useState24(null);
-  const exportNote = useCallback29(
+  const [isExporting, setIsExporting] = useState28(false);
+  const [error, setError] = useState28(null);
+  const exportNote = useCallback33(
     async (noteId) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3590,7 +3789,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback29(() => {
+  const reset = useCallback33(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3603,12 +3802,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-import { useCallback as useCallback30 } from "react";
+import { useCallback as useCallback34 } from "react";
 function useSyncControl() {
   const isPaused = useMidenStore((state) => state.syncPaused);
   const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
-  const pauseSync = useCallback30(() => setSyncPaused(true), [setSyncPaused]);
-  const resumeSync = useCallback30(() => setSyncPaused(false), [setSyncPaused]);
+  const pauseSync = useCallback34(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback34(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -3811,8 +4010,12 @@ export {
   useNoteStream,
   useNotes,
   usePswapCancel,
+  usePswapCancelByOrder,
   usePswapConsume,
   usePswapCreate,
+  usePswapLineage,
+  usePswapLineages,
+  usePswapLineagesFor,
   useSend,
   useSessionAccount,
   useSigner,