@miden-sdk/react 0.14.11 → 0.15.0-alpha.5

package/dist/mt/lazy.mjs

@@ -316,7 +316,7 @@ var DEFAULTS = {
   AUTO_SYNC_INTERVAL: 15e3,
   STORAGE_MODE: "private",
   WALLET_MUTABLE: true,
-  AUTH_SCHEME: AuthScheme.Falcon,
+  AUTH_SCHEME: AuthScheme.AuthRpoFalcon512,
   NOTE_TYPE: "private",
   FAUCET_DECIMALS: 8
 };
@@ -402,10 +402,7 @@ function resolveProverTarget(target, config) {
       return TransactionProver.newLocalProver();
     }
     if (normalized === "devnet" || normalized === "testnet") {
-      const url = config.proverUrls?.[normalized] ?? DEFAULT_PROVER_URLS[normalized] ?? null;
-      if (!url) {
-        throw new Error(`Missing ${normalized} prover URL`);
-      }
+      const url = config.proverUrls?.[normalized] ?? DEFAULT_PROVER_URLS[normalized];
       return TransactionProver.newRemoteProver(
         url,
         normalizeTimeout(config.proverTimeoutMs)
@@ -425,7 +422,6 @@ function createRemoteProver(config, fallbackTimeout) {
   }
   return TransactionProver.newRemoteProver(
     url,
-    /* v8 ignore next 1 — timeoutMs is always provided in tests; ?? fallbackTimeout path unreachable */
     normalizeTimeout(timeoutMs ?? fallbackTimeout)
   );
 }
@@ -447,34 +443,21 @@ 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";
 }
 async function initializeSignerAccount(client, config) {
-  const {
-    AccountBuilder,
-    AccountComponent,
-    AuthScheme: AuthScheme2,
-    Word: Word2,
-    resolveAuthScheme: resolveAuthScheme5
-  } = await import("@miden-sdk/miden-sdk/mt/lazy");
+  const { AccountBuilder, AccountComponent, AuthScheme: AuthScheme2, Word: Word2 } = await import("@miden-sdk/miden-sdk/mt/lazy");
   await client.syncState();
   if (config.importAccountId) {
     const accountId2 = parseAccountId(config.importAccountId);
     try {
       await client.importAccountById(accountId2);
     } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (!msg.includes("already being tracked")) {
+      const code = e?.code;
+      const isFreshAccount = code === "ACCOUNT_NOT_FOUND_ON_CHAIN";
+      const isAlreadyTracked = code === "ACCOUNT_ALREADY_TRACKED";
+      if (!isAlreadyTracked && !isFreshAccount) {
         throw e;
       }
     }
@@ -483,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,
-      resolveAuthScheme5(AuthScheme2.ECDSA)
+      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") {
@@ -560,23 +542,16 @@ function MidenProvider({
     }),
     [config]
   );
-  const [defaultProver, setDefaultProver] = useState(null);
-  useEffect(() => {
-    if (!isReady) {
-      setDefaultProver(null);
-      return;
-    }
-    setDefaultProver(resolveTransactionProver(resolvedConfig));
-  }, [
-    isReady,
-    resolvedConfig.prover,
-    resolvedConfig.proverTimeoutMs,
-    /* v8 ignore next 2 — optional chain on proverUrls; tests don't pass proverUrls config */
-    resolvedConfig.proverUrls?.devnet,
-    resolvedConfig.proverUrls?.testnet
-  ]);
+  const defaultProver = useMemo(
+    () => resolveTransactionProver(resolvedConfig),
+    [
+      resolvedConfig.prover,
+      resolvedConfig.proverTimeoutMs,
+      resolvedConfig.proverUrls?.devnet,
+      resolvedConfig.proverUrls?.testnet
+    ]
+  );
   const runExclusive = useCallback(
-    /* v8 ignore next 3 — runExclusive callback body; only called by advanced consumers, not directly in tests */
     async (fn) => clientLockRef.current.runExclusive(fn),
     []
   );
@@ -611,8 +586,6 @@ function MidenProvider({
     signCbRef.current = signerContext?.signCb ?? null;
   }, [signerContext?.signCb]);
   const wrappedSignCb = useCallback(
-    /* v8 ignore next 11 — wrappedSignCb body is only called during external signer operations;
-     * tests don't exercise the full signing flow through MidenProvider directly. */
     async (pubKey, signingInputs) => {
       const cb = signCbRef.current;
       if (!cb) {
@@ -865,10 +838,7 @@ function MultiSignerProvider({ children }) {
     () => ({ register, unregister }),
     [register, unregister]
   );
-  const activeSigner = activeSignerName ? (
-    /* v8 ignore next 1 — ?? null fallback; find() returns undefined only when the signer was unregistered between renders */
-    signersSnapshot.find((s) => s.name === activeSignerName) ?? null
-  ) : null;
+  const activeSigner = activeSignerName ? signersSnapshot.find((s) => s.name === activeSignerName) ?? null : null;
   const stableSignCb = useCallback2(
     async (pubKey, signingInputs) => {
       const name = activeSignerName;
@@ -1231,6 +1201,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") {
@@ -1241,7 +1232,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();
@@ -1320,7 +1313,6 @@ function getNoteType(type) {
       return NoteType.Private;
     case "public":
       return NoteType.Public;
-    /* v8 ignore next 2 — TypeScript type ensures only "private"|"public"; default is unreachable */
     default:
       return NoteType.Private;
   }
@@ -1501,38 +1493,23 @@ import { NoteFilter as NoteFilter2 } from "@miden-sdk/miden-sdk/mt/lazy";
 // src/utils/noteAttachment.ts
 import {
   NoteAttachment,
-  NoteAttachmentKind,
   NoteAttachmentScheme,
   Word
 } from "@miden-sdk/miden-sdk/mt/lazy";
 function readNoteAttachment(note) {
   try {
-    const metadata = note.metadata?.();
-    if (!metadata) return null;
-    const attachment = metadata.attachment?.();
-    if (!attachment) return null;
-    const kind = attachment.kind?.();
-    if (!kind) return null;
-    if (kind === 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;
   }
@@ -1543,7 +1520,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) {
@@ -1551,7 +1528,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);
@@ -1560,13 +1537,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
@@ -1675,7 +1651,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) : "";
@@ -1796,7 +1774,6 @@ function buildFilter(filter, ids, idsHex) {
   }
   return {
     filter: TransactionFilter2.all(),
-    /* v8 ignore next 1 — idsHex is always non-null when ids is non-empty; ?? [] is a safety net */
     localFilterHexes: idsHex ?? []
   };
 }
@@ -1822,10 +1799,7 @@ function useSyncState() {
 
 // src/hooks/useCreateWallet.ts
 import { useCallback as useCallback9, useState as useState7 } from "react";
-import {
-  AccountStorageMode,
-  resolveAuthScheme
-} from "@miden-sdk/miden-sdk/mt/lazy";
+import { AccountStorageMode } from "@miden-sdk/miden-sdk/mt/lazy";
 
 // src/utils/runExclusive.ts
 var runExclusiveDirect = async (fn) => fn();
@@ -1850,9 +1824,7 @@ function useCreateWallet() {
           options.storageMode ?? DEFAULTS.STORAGE_MODE
         );
         const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
-        const authScheme = resolveAuthScheme(
-          options.authScheme ?? DEFAULTS.AUTH_SCHEME
-        );
+        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
         const newWallet = await runExclusiveSafe(async () => {
           const createdWallet = await client.newWallet(
             storageMode,
@@ -1896,8 +1868,6 @@ function getStorageMode(mode) {
       return AccountStorageMode.private();
     case "public":
       return AccountStorageMode.public();
-    case "network":
-      return AccountStorageMode.network();
     default:
       return AccountStorageMode.private();
   }
@@ -1905,10 +1875,7 @@ function getStorageMode(mode) {
 
 // src/hooks/useCreateFaucet.ts
 import { useCallback as useCallback10, useState as useState8 } from "react";
-import {
-  AccountStorageMode as AccountStorageMode2,
-  resolveAuthScheme as resolveAuthScheme2
-} from "@miden-sdk/miden-sdk/mt/lazy";
+import { AccountStorageMode as AccountStorageMode2 } from "@miden-sdk/miden-sdk/mt/lazy";
 function useCreateFaucet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
@@ -1928,14 +1895,13 @@ function useCreateFaucet() {
           options.storageMode ?? DEFAULTS.STORAGE_MODE
         );
         const decimals = options.decimals ?? DEFAULTS.FAUCET_DECIMALS;
-        const authScheme = resolveAuthScheme2(
-          options.authScheme ?? DEFAULTS.AUTH_SCHEME
-        );
+        const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
         const newFaucet = await runExclusiveSafe(async () => {
           const createdFaucet = await client.newFaucet(
             storageMode,
             false,
             // nonFungible - currently only fungible faucets supported
+            options.tokenName ?? options.tokenSymbol,
             options.tokenSymbol,
             decimals,
             BigInt(options.maxSupply),
@@ -1976,8 +1942,6 @@ function getStorageMode2(mode) {
       return AccountStorageMode2.private();
     case "public":
       return AccountStorageMode2.public();
-    case "network":
-      return AccountStorageMode2.network();
     default:
       return AccountStorageMode2.private();
   }
@@ -1985,7 +1949,7 @@ function getStorageMode2(mode) {
 
 // src/hooks/useImportAccount.ts
 import { useCallback as useCallback11, useState as useState9 } from "react";
-import { AccountFile, resolveAuthScheme as resolveAuthScheme3 } from "@miden-sdk/miden-sdk/mt/lazy";
+import { AccountFile } from "@miden-sdk/miden-sdk/mt/lazy";
 
 // src/utils/errors.ts
 var MidenError = class extends Error {
@@ -2118,9 +2082,7 @@ function useImportAccount() {
             }
             case "seed": {
               const mutable = options.mutable ?? DEFAULTS.WALLET_MUTABLE;
-              const authScheme = resolveAuthScheme3(
-                options.authScheme ?? DEFAULTS.AUTH_SCHEME
-              );
+              const authScheme = options.authScheme ?? DEFAULTS.AUTH_SCHEME;
               return await client.importPublicAccountFromSeed(
                 options.seed,
                 mutable,
@@ -2196,7 +2158,6 @@ import {
   FungibleAsset,
   Note,
   NoteAssets,
-  NoteAttachment as NoteAttachment2,
   NoteType as NoteType2,
   NoteArray,
   TransactionRequestBuilder
@@ -2275,7 +2236,7 @@ function useSend() {
               toId,
               assets,
               noteType,
-              new NoteAttachment2()
+              emptyAttachment()
             );
             const ownOutputs = new NoteArray();
             ownOutputs.push(p2idNote);
@@ -2312,7 +2273,7 @@ function useSend() {
             );
             txRequest = new TransactionRequestBuilder().withOwnOutputNotes(new NoteArray([note])).build();
           } else {
-            txRequest = client.newSendTransactionRequest(
+            txRequest = await client.newSendTransactionRequest(
               fromAccountId,
               toAccountId,
               assetIdObj,
@@ -2329,7 +2290,7 @@ function useSend() {
         const proverConfig = useMidenStore.getState().config;
         const provenTransaction = await proveWithFallback(
           (resolvedProver) => runExclusiveSafe(
-            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+            () => client.proveTransaction(txResult, resolvedProver)
           ),
           proverConfig
         );
@@ -2412,7 +2373,6 @@ import {
   FungibleAsset as FungibleAsset2,
   Note as Note2,
   NoteAssets as NoteAssets2,
-  NoteAttachment as NoteAttachment3,
   NoteType as NoteType3,
   NoteArray as NoteArray2,
   TransactionRequestBuilder as TransactionRequestBuilder2
@@ -2457,7 +2417,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,
@@ -2484,7 +2444,7 @@ function useMultiSend() {
         const proverConfig = useMidenStore.getState().config;
         const provenTransaction = await proveWithFallback(
           (resolvedProver) => runExclusiveDirect(
-            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+            () => client.proveTransaction(txResult, resolvedProver)
           ),
           proverConfig
         );
@@ -2649,7 +2609,7 @@ function useMint() {
         const faucetIdObj = parseAccountId(options.faucetId);
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
-          const txRequest = client.newMintTransactionRequest(
+          const txRequest = await client.newMintTransactionRequest(
             targetAccountIdObj,
             faucetIdObj,
             noteType,
@@ -2743,7 +2703,15 @@ function useConsume() {
               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(lookupIdStrings[j]);
@@ -2756,12 +2724,6 @@ function useConsume() {
             }
           }
           const notes = resolved;
-          if (notes.length === 0) {
-            throw new Error("No notes found for provided IDs");
-          }
-          if (notes.length !== options.notes.length) {
-            throw new Error("Some notes could not be found for provided IDs");
-          }
           const txRequest = client.newConsumeTransactionRequest(notes);
           const txId = prover ? await client.submitNewTransactionWithProver(
             accountIdObj,
@@ -2828,7 +2790,7 @@ function useSwap() {
         const requestedFaucetIdObj = parseAccountId(options.requestedFaucetId);
         setStage("proving");
         const txResult = await runExclusiveSafe(async () => {
-          const txRequest = client.newSwapTransactionRequest(
+          const txRequest = await client.newSwapTransactionRequest(
             accountIdObj,
             offeredFaucetIdObj,
             BigInt(options.offeredAmount),
@@ -2875,8 +2837,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/mt/lazy";
@@ -2923,11 +3105,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");
@@ -2955,7 +3137,7 @@ function useTransaction() {
         const proverConfig = useMidenStore.getState().config;
         const provenTransaction = await proveWithFallback(
           (resolvedProver) => runExclusiveSafe(
-            () => resolvedProver ? client.proveTransactionWithProver(txResult, resolvedProver) : client.proveTransaction(txResult)
+            () => client.proveTransaction(txResult, resolvedProver)
           ),
           proverConfig
         );
@@ -2994,7 +3176,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback19(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3017,7 +3199,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,
@@ -3031,10 +3213,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");
@@ -3093,7 +3275,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback20(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3108,7 +3290,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/mt/lazy";
 function useCompile() {
   const { client, isReady } = useMiden();
@@ -3116,21 +3298,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]
   );
@@ -3138,17 +3320,14 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-import { useCallback as useCallback22, useEffect as useEffect9, useRef as useRef8, useState as useState17 } from "react";
-import {
-  AccountStorageMode as AccountStorageMode3,
-  resolveAuthScheme as resolveAuthScheme4
-} from "@miden-sdk/miden-sdk/mt/lazy";
+import { useCallback as useCallback25, useEffect as useEffect9, useRef as useRef8, useState as useState20 } from "react";
+import { AccountStorageMode as AccountStorageMode3 } from "@miden-sdk/miden-sdk/mt/lazy";
 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";
@@ -3156,9 +3335,7 @@ function useSessionAccount(options) {
   const maxWaitMs = options.maxWaitMs ?? 6e4;
   const storageMode = options.walletOptions?.storageMode ?? "public";
   const mutable = options.walletOptions?.mutable ?? DEFAULTS.WALLET_MUTABLE;
-  const authScheme = resolveAuthScheme4(
-    options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME
-  );
+  const authScheme = options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME;
   const fundRef = useRef8(options.fund);
   fundRef.current = options.fund;
   useEffect9(() => {
@@ -3178,7 +3355,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");
     }
@@ -3209,14 +3386,13 @@ function useSessionAccount(options) {
         setSessionAccountId(walletId);
         localStorage.setItem(`${storagePrefix}:accountId`, walletId);
       }
-      const resolvedWalletId = walletId;
       setStep("funding");
-      await fundRef.current(resolvedWalletId);
+      await fundRef.current(walletId);
       if (cancelledRef.current) return;
       setStep("consuming");
       await waitAndConsume(
         client,
-        resolvedWalletId,
+        walletId,
         pollIntervalMs,
         maxWaitMs,
         cancelledRef
@@ -3248,7 +3424,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = useCallback22(() => {
+  const reset = useCallback25(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3297,20 +3473,20 @@ 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/mt/lazy";
 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");
     }
     setIsExporting(true);
     setError(null);
     try {
-      const storeName = client.storeIdentifier();
+      const storeName = await client.storeIdentifier();
       const snapshot = await runExclusive(() => sdkExportStore(storeName));
       return snapshot;
     } catch (err) {
@@ -3321,7 +3497,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = useCallback23(() => {
+  const reset = useCallback26(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3334,13 +3510,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/mt/lazy";
 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");
@@ -3362,7 +3538,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback24(() => {
+  const reset = useCallback27(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3375,13 +3551,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/mt/lazy";
 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");
@@ -3405,7 +3581,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = useCallback25(() => {
+  const reset = useCallback28(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3418,13 +3594,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/mt/lazy";
 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");
@@ -3446,7 +3622,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = useCallback26(() => {
+  const reset = useCallback29(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3459,12 +3635,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,
@@ -3636,9 +3812,11 @@ export {
   concatBytes,
   createMidenStorage,
   createNoteAttachment,
+  ensureAccountBech32,
   formatAssetAmount,
   formatNoteSummary,
   getNoteSummary,
+  installAccountBech32,
   migrateStorage,
   normalizeAccountId,
   parseAssetAmount,
@@ -3664,6 +3842,9 @@ export {
   useMultiSigner,
   useNoteStream,
   useNotes,
+  usePswapCancel,
+  usePswapConsume,
+  usePswapCreate,
   useSend,
   useSessionAccount,
   useSigner,