@miden-sdk/react 0.15.0-alpha.4 → 0.15.0-alpha.6

package/dist/index.mjs

@@ -443,15 +443,6 @@ function useSigner() {
 }
 
 // src/utils/signerAccount.ts
-var WASM_ACCOUNT_TYPE = {
-  FungibleFaucet: 0,
-  NonFungibleFaucet: 1,
-  RegularAccountImmutableCode: 2,
-  RegularAccountUpdatableCode: 3
-};
-function getAccountType(accountType) {
-  return WASM_ACCOUNT_TYPE[accountType] ?? WASM_ACCOUNT_TYPE.RegularAccountImmutableCode;
-}
 function isPrivateStorageMode(storageMode) {
   return storageMode.toString() === "private";
 }
@@ -463,8 +454,10 @@ async function initializeSignerAccount(client, config) {
     try {
       await client.importAccountById(accountId2);
     } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (!msg.includes("already being tracked")) {
+      const code = e?.code;
+      const isFreshAccount = code === "ACCOUNT_NOT_FOUND_ON_CHAIN";
+      const isAlreadyTracked = code === "ACCOUNT_ALREADY_TRACKED";
+      if (!isAlreadyTracked && !isFreshAccount) {
         throw e;
       }
     }
@@ -473,13 +466,12 @@ async function initializeSignerAccount(client, config) {
   }
   const commitmentWord = Word2.deserialize(config.publicKeyCommitment);
   const seed = config.accountSeed ?? crypto.getRandomValues(new Uint8Array(32));
-  const accountType = getAccountType(config.accountType);
   let builder = new AccountBuilder(seed).withAuthComponent(
     AccountComponent.createAuthComponentFromCommitment(
       commitmentWord,
       AuthScheme2.AuthEcdsaK256Keccak
     )
-  ).accountType(accountType).storageMode(config.storageMode).withBasicWalletComponent();
+  ).storageMode(config.storageMode).withBasicWalletComponent();
   if (config.customComponents?.length) {
     for (const component of config.customComponents) {
       if (component == null || typeof component.getProcedures !== "function") {
@@ -550,15 +542,20 @@ function MidenProvider({
     }),
     [config]
   );
-  const defaultProver = useMemo(
-    () => resolveTransactionProver(resolvedConfig),
-    [
-      resolvedConfig.prover,
-      resolvedConfig.proverTimeoutMs,
-      resolvedConfig.proverUrls?.devnet,
-      resolvedConfig.proverUrls?.testnet
-    ]
-  );
+  const [defaultProver, setDefaultProver] = useState(null);
+  useEffect(() => {
+    if (!isReady) {
+      setDefaultProver(null);
+      return;
+    }
+    setDefaultProver(resolveTransactionProver(resolvedConfig));
+  }, [
+    isReady,
+    resolvedConfig.prover,
+    resolvedConfig.proverTimeoutMs,
+    resolvedConfig.proverUrls?.devnet,
+    resolvedConfig.proverUrls?.testnet
+  ]);
   const runExclusive = useCallback(
     async (fn) => clientLockRef.current.runExclusive(fn),
     []
@@ -644,7 +641,9 @@ function MidenProvider({
               storeName,
               signerContext.getKeyCb,
               signerContext.insertKeyCb,
-              wrappedSignCb
+              wrappedSignCb,
+              void 0,
+              resolvedConfig.useWorker
             );
             if (cancelled) return;
             const accountId = await initializeSignerAccount(
@@ -660,7 +659,10 @@ function MidenProvider({
             webClient = await WebClient.createClient(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
-              seed
+              seed,
+              void 0,
+              void 0,
+              resolvedConfig.useWorker
             );
             if (cancelled) return;
           }
@@ -1204,6 +1206,27 @@ var parseAssetAmount = (input, decimals) => {
 };
 
 // src/utils/notes.ts
+var resolveNoteInput = async (input, client) => {
+  if (typeof input === "string") {
+    const record2 = await client.getInputNote(input);
+    if (!record2) {
+      throw new Error(`Note not found: ${input}`);
+    }
+    return record2.toNote();
+  }
+  if (typeof input.toNote === "function") {
+    return input.toNote();
+  }
+  if (typeof input.id === "function") {
+    return input;
+  }
+  const hex = input.toString();
+  const record = await client.getInputNote(hex);
+  if (!record) {
+    throw new Error(`Note not found: ${hex}`);
+  }
+  return record.toNote();
+};
 var getInputNoteRecord = (note) => {
   const maybeConsumable = note;
   if (typeof maybeConsumable.inputNoteRecord === "function") {
@@ -1214,7 +1237,9 @@ var getInputNoteRecord = (note) => {
 var getNoteSummary = (note, getAssetMetadata) => {
   try {
     const record = getInputNoteRecord(note);
-    const id = record.id().toString();
+    const rawId = record.id();
+    if (!rawId) return null;
+    const id = rawId.toString();
     const assets = [];
     try {
       const details = record.details();
@@ -1473,38 +1498,23 @@ import { NoteFilter as NoteFilter2 } from "@miden-sdk/miden-sdk";
 // src/utils/noteAttachment.ts
 import {
   NoteAttachment,
-  NoteAttachmentKind,
   NoteAttachmentScheme,
   Word
 } from "@miden-sdk/miden-sdk";
 function readNoteAttachment(note) {
   try {
-    const metadata = note.metadata?.();
-    if (!metadata) return null;
-    const attachment = metadata.attachment?.();
-    if (!attachment) return null;
-    const kind = attachment.kind?.();
-    if (!kind) return null;
-    if (kind === NoteAttachmentKind.None) return null;
-    if (kind === NoteAttachmentKind.Word) {
-      const word = attachment.asWord?.();
-      if (!word) return null;
-      const u64s = word.toU64s();
-      const values = Array.from(u64s).map(
-        (v) => BigInt(v)
-      );
-      return { values, kind: "word" };
-    }
-    if (kind === NoteAttachmentKind.Array) {
-      const arr = attachment.asArray?.();
-      if (!arr) return null;
-      const u64s = arr.toU64s();
-      const values = Array.from(u64s).map(
-        (v) => BigInt(v)
-      );
-      return { values, kind: "array" };
-    }
-    return null;
+    const attachments = note.attachments?.();
+    if (!attachments || attachments.length === 0) return null;
+    const words = attachments[0].toWords();
+    if (words.length === 0) return null;
+    const values = [];
+    for (const word of words) {
+      for (const value of word.toU64s()) {
+        values.push(BigInt(value));
+      }
+    }
+    if (values.every((value) => value === 0n)) return null;
+    return { values, kind: words.length === 1 ? "word" : "array" };
   } catch {
     return null;
   }
@@ -1515,7 +1525,7 @@ function createNoteAttachment(values) {
     bigints.push(BigInt(values[i]));
   }
   if (bigints.length === 0) {
-    return new NoteAttachment();
+    return emptyAttachment();
   }
   const scheme = NoteAttachmentScheme.none();
   if (bigints.length <= 4) {
@@ -1523,7 +1533,7 @@ function createNoteAttachment(values) {
       bigints.push(0n);
     }
     const word = new Word(BigUint64Array.from(bigints));
-    return NoteAttachment.newWord(scheme, word);
+    return NoteAttachment.fromWord(scheme, word);
   }
   while (bigints.length % 4 !== 0) {
     bigints.push(0n);
@@ -1532,13 +1542,12 @@ function createNoteAttachment(values) {
   for (let i = 0; i < bigints.length; i += 4) {
     words.push(new Word(BigUint64Array.from(bigints.slice(i, i + 4))));
   }
-  const newArray = 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(NoteAttachment, scheme, words);
+  return NoteAttachment.fromWords(scheme, words);
+}
+function emptyAttachment() {
+  const scheme = NoteAttachmentScheme.none();
+  const word = new Word(BigUint64Array.from([0n, 0n, 0n, 0n]));
+  return NoteAttachment.fromWord(scheme, word);
 }
 
 // src/hooks/useNoteStream.ts
@@ -1647,7 +1656,9 @@ function useNoteStream(options = {}) {
 }
 function buildStreamedNote(record, noteFirstSeen) {
   try {
-    const id = record.id().toString();
+    const rawId = record.id();
+    if (!rawId) return null;
+    const id = rawId.toString();
     const metadata = record.metadata?.();
     const senderHex = metadata?.sender?.()?.toString?.();
     const sender = senderHex ? toBech32AccountId(senderHex) : "";
@@ -1862,8 +1873,6 @@ function getStorageMode(mode) {
       return AccountStorageMode.private();
     case "public":
       return AccountStorageMode.public();
-    case "network":
-      return AccountStorageMode.network();
     default:
       return AccountStorageMode.private();
   }
@@ -1897,6 +1906,7 @@ function useCreateFaucet() {
             storageMode,
             false,
             // nonFungible - currently only fungible faucets supported
+            options.tokenName ?? options.tokenSymbol,
             options.tokenSymbol,
             decimals,
             BigInt(options.maxSupply),
@@ -1937,8 +1947,6 @@ function getStorageMode2(mode) {
       return AccountStorageMode2.private();
     case "public":
       return AccountStorageMode2.public();
-    case "network":
-      return AccountStorageMode2.network();
     default:
       return AccountStorageMode2.private();
   }
@@ -2155,7 +2163,6 @@ import {
   FungibleAsset,
   Note,
   NoteAssets,
-  NoteAttachment as NoteAttachment2,
   NoteType as NoteType2,
   NoteArray,
   TransactionRequestBuilder
@@ -2234,7 +2241,7 @@ function useSend() {
               toId,
               assets,
               noteType,
-              new NoteAttachment2()
+              emptyAttachment()
             );
             const ownOutputs = new NoteArray();
             ownOutputs.push(p2idNote);
@@ -2245,7 +2252,7 @@ function useSend() {
               txRequest,
               prover
             ) : await client.submitNewTransaction(execFromId, txRequest);
-            return { txId: txId.toString(), note: p2idNote };
+            return { txId: txId.toHex(), note: p2idNote };
           });
           setStage("complete");
           setResult(returnResult);
@@ -2297,7 +2304,6 @@ function useSend() {
           () => client.submitProvenTransaction(provenTransaction, txResult)
         );
         const txIdHex = txResult.id().toHex();
-        const txIdString = txResult.id().toString();
         let fullNote = null;
         if (noteType === NoteType2.Private) {
           fullNote = extractFullNote(txResult);
@@ -2321,7 +2327,7 @@ function useSend() {
           );
         }
         const sendResult = {
-          txId: txIdString,
+          txId: txIdHex,
           note: null
         };
         setStage("complete");
@@ -2372,7 +2378,6 @@ import {
   FungibleAsset as FungibleAsset2,
   Note as Note2,
   NoteAssets as NoteAssets2,
-  NoteAttachment as NoteAttachment3,
   NoteType as NoteType3,
   NoteArray as NoteArray2,
   TransactionRequestBuilder as TransactionRequestBuilder2
@@ -2417,7 +2422,7 @@ function useMultiSend() {
               new FungibleAsset2(iterAssetId, BigInt(amount))
             ]);
             const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
-            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new NoteAttachment3();
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : emptyAttachment();
             const note = Note2.createP2IDNote(
               iterSenderId,
               receiverId,
@@ -2433,7 +2438,11 @@ function useMultiSend() {
             };
           }
         );
-        const txRequest = new TransactionRequestBuilder2().withOwnOutputNotes(new NoteArray2(outputs.map((o) => o.note))).build();
+        const ownOutputs = new NoteArray2();
+        for (const o of outputs) {
+          ownOutputs.push(o.note);
+        }
+        const txRequest = new TransactionRequestBuilder2().withOwnOutputNotes(ownOutputs).build();
         const txSenderId = parseAccountId(options.from);
         const txResult = await client.executeTransaction(txSenderId, txRequest);
         setStage("proving");
@@ -2450,7 +2459,6 @@ function useMultiSend() {
           txResult
         );
         const txIdHex = txResult.id().toHex();
-        const txIdString = txResult.id().toString();
         await client.applyTransaction(txResult, submissionHeight);
         const hasPrivate = outputs.some((o) => o.noteType === NoteType3.Private);
         if (hasPrivate) {
@@ -2468,7 +2476,7 @@ function useMultiSend() {
             }
           }
         }
-        const txSummary = { transactionId: txIdString };
+        const txSummary = { transactionId: txIdHex };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -2617,7 +2625,7 @@ function useMint() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(faucetIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2693,16 +2701,25 @@ function useConsume() {
             }
           }
           if (lookupIds.length > 0) {
+            const lookupIdStrings = lookupIds.map((id) => id.toString());
             const filter = new NoteFilter3(NoteFilterTypes2.List, lookupIds);
             const noteRecords = await client.getInputNotes(filter);
-            if (noteRecords.length !== lookupIds.length) {
+            if (noteRecords.length !== lookupIdStrings.length) {
               throw new Error("Some notes could not be found for provided IDs");
             }
             const recordById = new Map(
-              noteRecords.map((r) => [r.id().toString(), r])
+              noteRecords.map((r) => {
+                const id = r.id();
+                if (!id) {
+                  throw new Error(
+                    "getInputNotes returned a record without a note id"
+                  );
+                }
+                return [id.toString(), r];
+              })
             );
             for (let j = 0; j < lookupIndices.length; j++) {
-              const record = recordById.get(lookupIds[j].toString());
+              const record = recordById.get(lookupIdStrings[j]);
               if (!record) {
                 throw new Error(
                   "Some notes could not be found for provided IDs"
@@ -2718,7 +2735,7 @@ function useConsume() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2792,7 +2809,7 @@ function useSwap() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2825,8 +2842,228 @@ function useSwap() {
   };
 }
 
+// src/hooks/usePswapCreate.ts
+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] = 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");
+      }
+      const offeredAmount = BigInt(options.offeredAmount);
+      const requestedAmount = BigInt(options.requestedAmount);
+      if (offeredAmount <= 0n) {
+        throw new Error("offeredAmount must be greater than 0");
+      }
+      if (requestedAmount <= 0n) {
+        throw new Error("requestedAmount must be greater than 0");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const noteType = getNoteType(options.noteType ?? DEFAULTS.NOTE_TYPE);
+        const paybackNoteType = getNoteType(
+          options.paybackNoteType ?? DEFAULTS.NOTE_TYPE
+        );
+        const accountIdObj = parseAccountId(options.accountId);
+        const offeredFaucetIdObj = parseAccountId(options.offeredFaucetId);
+        const requestedFaucetIdObj = parseAccountId(options.requestedFaucetId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const txRequest = await client.newPswapCreateTransactionRequest(
+            accountIdObj,
+            offeredFaucetIdObj,
+            offeredAmount,
+            requestedFaucetIdObj,
+            requestedAmount,
+            noteType,
+            paybackNoteType
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toHex() };
+        });
+        setStage("complete");
+        setResult(txResult);
+        await sync();
+        return txResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback19(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    pswapCreate,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/usePswapConsume.ts
+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] = 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");
+      }
+      const fillAmount = BigInt(options.fillAmount);
+      const noteFillAmount = BigInt(options.noteFillAmount ?? 0);
+      if (fillAmount <= 0n) {
+        throw new Error("fillAmount must be greater than 0");
+      }
+      if (noteFillAmount < 0n) {
+        throw new Error("noteFillAmount must not be negative");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const accountIdObj = parseAccountId(options.accountId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const note = await resolveNoteInput(options.note, client);
+          const txRequest = await client.newPswapConsumeTransactionRequest(
+            note,
+            accountIdObj,
+            fillAmount,
+            noteFillAmount
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toHex() };
+        });
+        setStage("complete");
+        setResult(txResult);
+        await sync();
+        return txResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback20(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    pswapConsume,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
+// src/hooks/usePswapCancel.ts
+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] = 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");
+      }
+      setIsLoading(true);
+      setStage("executing");
+      setError(null);
+      try {
+        const accountIdObj = parseAccountId(options.accountId);
+        setStage("proving");
+        const txResult = await runExclusiveSafe(async () => {
+          const note = await resolveNoteInput(options.note, client);
+          const txRequest = await client.newPswapCancelTransactionRequest(
+            note,
+            accountIdObj
+          );
+          const txId = prover ? await client.submitNewTransactionWithProver(
+            accountIdObj,
+            txRequest,
+            prover
+          ) : await client.submitNewTransaction(accountIdObj, txRequest);
+          return { transactionId: txId.toHex() };
+        });
+        setStage("complete");
+        setResult(txResult);
+        await sync();
+        return txResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setStage("idle");
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isReady, prover, runExclusive, sync]
+  );
+  const reset = useCallback21(() => {
+    setResult(null);
+    setIsLoading(false);
+    setStage("idle");
+    setError(null);
+  }, []);
+  return {
+    pswapCancel,
+    result,
+    isLoading,
+    stage,
+    error,
+    reset
+  };
+}
+
 // src/hooks/useTransaction.ts
-import { useCallback as useCallback19, useRef as useRef6, useState as useState15 } from "react";
+import { useCallback as useCallback22, useRef as useRef6, useState as useState18 } from "react";
 
 // src/utils/transactions.ts
 import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk";
@@ -2873,11 +3110,11 @@ function useTransaction() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const isBusyRef = useRef6(false);
-  const [result, setResult] = useState15(null);
-  const [isLoading, setIsLoading] = useState15(false);
-  const [stage, setStage] = useState15("idle");
-  const [error, setError] = useState15(null);
-  const execute = useCallback19(
+  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");
@@ -2927,7 +3164,7 @@ function useTransaction() {
             );
           }
         }
-        const txSummary = { transactionId: txId.toString() };
+        const txSummary = { transactionId: txId.toHex() };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -2944,7 +3181,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback19(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2967,7 +3204,7 @@ async function resolveRequest(request, client) {
 }
 
 // src/hooks/useExecuteProgram.ts
-import { useCallback as useCallback20, useRef as useRef7, useState as useState16 } from "react";
+import { useCallback as useCallback23, useRef as useRef7, useState as useState19 } from "react";
 import {
   AdviceInputs,
   ForeignAccount,
@@ -2981,10 +3218,10 @@ function useExecuteProgram() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const isBusyRef = useRef7(false);
-  const [result, setResult] = useState16(null);
-  const [isLoading, setIsLoading] = useState16(false);
-  const [error, setError] = useState16(null);
-  const execute = useCallback20(
+  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");
@@ -3043,7 +3280,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback20(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3058,7 +3295,7 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-import { useCallback as useCallback21, useMemo as useMemo8 } from "react";
+import { useCallback as useCallback24, useMemo as useMemo8 } from "react";
 import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk";
 function useCompile() {
   const { client, isReady } = useMiden();
@@ -3066,21 +3303,21 @@ function useCompile() {
     () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = useCallback21(() => {
+  const requireResource = useCallback24(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = useCallback21(
+  const component = useCallback24(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = useCallback21(
+  const txScript = useCallback24(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = useCallback21(
+  const noteScript = useCallback24(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3088,14 +3325,14 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback22, useEffect as useEffect9, useRef as useRef8, useState as useState17 } 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";
 function useSessionAccount(options) {
   const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = useState17(null);
-  const [step, setStep] = useState17("idle");
-  const [error, setError] = useState17(null);
+  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";
@@ -3123,7 +3360,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = useCallback22(async () => {
+  const initialize = useCallback25(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3192,7 +3429,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback22(() => {
+  const reset = useCallback25(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3241,13 +3478,13 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 }
 
 // src/hooks/useExportStore.ts
-import { useCallback as useCallback23, useState as useState18 } from "react";
+import { useCallback as useCallback26, useState as useState21 } from "react";
 import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState18(false);
-  const [error, setError] = useState18(null);
-  const exportStore = useCallback23(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");
     }
@@ -3265,7 +3502,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback23(() => {
+  const reset = useCallback26(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3278,13 +3515,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-import { useCallback as useCallback24, useState as useState19 } from "react";
+import { useCallback as useCallback27, useState as useState22 } from "react";
 import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState19(false);
-  const [error, setError] = useState19(null);
-  const importStore = useCallback24(
+  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");
@@ -3306,7 +3543,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback24(() => {
+  const reset = useCallback27(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3319,13 +3556,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-import { useCallback as useCallback25, useState as useState20 } from "react";
+import { useCallback as useCallback28, useState as useState23 } from "react";
 import { NoteFile } from "@miden-sdk/miden-sdk";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = useState20(false);
-  const [error, setError] = useState20(null);
-  const importNote = useCallback25(
+  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");
@@ -3349,7 +3586,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback25(() => {
+  const reset = useCallback28(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3362,13 +3599,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-import { useCallback as useCallback26, useState as useState21 } from "react";
+import { useCallback as useCallback29, useState as useState24 } from "react";
 import { NoteExportFormat } from "@miden-sdk/miden-sdk";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = useState21(false);
-  const [error, setError] = useState21(null);
-  const exportNote = useCallback26(
+  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");
@@ -3390,7 +3627,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback26(() => {
+  const reset = useCallback29(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3403,12 +3640,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-import { useCallback as useCallback27 } from "react";
+import { useCallback as useCallback30 } from "react";
 function useSyncControl() {
   const isPaused = useMidenStore((state) => state.syncPaused);
   const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
-  const pauseSync = useCallback27(() => setSyncPaused(true), [setSyncPaused]);
-  const resumeSync = useCallback27(() => setSyncPaused(false), [setSyncPaused]);
+  const pauseSync = useCallback30(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback30(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -3610,6 +3847,9 @@ export {
   useMultiSigner,
   useNoteStream,
   useNotes,
+  usePswapCancel,
+  usePswapConsume,
+  usePswapCreate,
   useSend,
   useSessionAccount,
   useSigner,