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

package/dist/{index.js → mt.mjs}

@@ -1,102 +1,16 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthScheme: () => import_miden_sdk4.AuthScheme,
-  DEFAULTS: () => DEFAULTS,
-  MidenError: () => MidenError,
-  MidenProvider: () => MidenProvider,
-  MultiSignerProvider: () => MultiSignerProvider,
-  SignerContext: () => SignerContext,
-  SignerSlot: () => SignerSlot,
-  accountIdsEqual: () => accountIdsEqual,
-  bigIntToBytes: () => bigIntToBytes,
-  bytesToBigInt: () => bytesToBigInt,
-  clearMidenStorage: () => clearMidenStorage,
-  concatBytes: () => concatBytes,
-  createMidenStorage: () => createMidenStorage,
-  createNoteAttachment: () => createNoteAttachment,
-  ensureAccountBech32: () => ensureAccountBech32,
-  formatAssetAmount: () => formatAssetAmount,
-  formatNoteSummary: () => formatNoteSummary,
-  getNoteSummary: () => getNoteSummary,
-  installAccountBech32: () => installAccountBech32,
-  migrateStorage: () => migrateStorage,
-  normalizeAccountId: () => normalizeAccountId,
-  parseAssetAmount: () => parseAssetAmount,
-  readNoteAttachment: () => readNoteAttachment,
-  toBech32AccountId: () => toBech32AccountId,
-  useAccount: () => useAccount,
-  useAccounts: () => useAccounts,
-  useAssetMetadata: () => useAssetMetadata,
-  useCompile: () => useCompile,
-  useConsume: () => useConsume,
-  useCreateFaucet: () => useCreateFaucet,
-  useCreateWallet: () => useCreateWallet,
-  useExecuteProgram: () => useExecuteProgram,
-  useExportNote: () => useExportNote,
-  useExportStore: () => useExportStore,
-  useImportAccount: () => useImportAccount,
-  useImportNote: () => useImportNote,
-  useImportStore: () => useImportStore,
-  useMiden: () => useMiden,
-  useMidenClient: () => useMidenClient,
-  useMint: () => useMint,
-  useMultiSend: () => useMultiSend,
-  useMultiSigner: () => useMultiSigner,
-  useNoteStream: () => useNoteStream,
-  useNotes: () => useNotes,
-  useSend: () => useSend,
-  useSessionAccount: () => useSessionAccount,
-  useSigner: () => useSigner,
-  useSwap: () => useSwap,
-  useSyncControl: () => useSyncControl,
-  useSyncState: () => useSyncState,
-  useTransaction: () => useTransaction,
-  useTransactionHistory: () => useTransactionHistory,
-  useWaitForCommit: () => useWaitForCommit,
-  useWaitForNotes: () => useWaitForNotes,
-  waitForWalletDetection: () => waitForWalletDetection,
-  wrapWasmError: () => wrapWasmError
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/types/augmentations.ts
-var import_miden_sdk = require("@miden-sdk/miden-sdk");
+import "@miden-sdk/miden-sdk/mt";
 
 // src/utils/accountBech32.ts
-var import_miden_sdk3 = require("@miden-sdk/miden-sdk");
+import {
+  Account,
+  AccountInterface,
+  Address as Address2,
+  NetworkId
+} from "@miden-sdk/miden-sdk/mt";
 
 // src/store/MidenStore.ts
-var import_zustand = require("zustand");
+import { create } from "zustand";
 var initialSyncState = {
   syncHeight: 0,
   isSyncing: false,
@@ -128,7 +42,7 @@ function freshState() {
     ...freshCachedState()
   };
 }
-var useMidenStore = (0, import_zustand.create)()((set) => ({
+var useMidenStore = create()((set) => ({
   ...freshState(),
   setClient: (client) => set({
     client,
@@ -240,19 +154,19 @@ var useAssetMetadataStore = () => useMidenStore((state) => state.assetMetadata);
 var useNoteFirstSeenStore = () => useMidenStore((state) => state.noteFirstSeen);
 
 // src/utils/accountParsing.ts
-var import_miden_sdk2 = require("@miden-sdk/miden-sdk");
+import { AccountId, Address } from "@miden-sdk/miden-sdk/mt";
 var normalizeAccountIdInput = (value) => value.trim().replace(/^miden:/i, "");
 var isBech32Input = (value) => value.startsWith("m") || value.startsWith("M");
 var normalizeHexInput = (value) => value.startsWith("0x") || value.startsWith("0X") ? value : `0x${value}`;
 var parseAccountIdFromString = (value) => {
   if (isBech32Input(value)) {
     try {
-      return import_miden_sdk2.Address.fromBech32(value).accountId();
+      return Address.fromBech32(value).accountId();
     } catch {
-      return import_miden_sdk2.AccountId.fromBech32(value);
+      return AccountId.fromBech32(value);
     }
   }
-  return import_miden_sdk2.AccountId.fromHex(normalizeHexInput(value));
+  return AccountId.fromHex(normalizeHexInput(value));
 };
 var parseAccountId = (value) => {
   if (typeof value === "string") {
@@ -279,49 +193,49 @@ function isFaucetId(accountId) {
 var parseAddress = (value, accountId) => {
   if (typeof value !== "string") {
     const resolvedId = accountId ?? parseAccountId(value);
-    return import_miden_sdk2.Address.fromAccountId(resolvedId, "BasicWallet");
+    return Address.fromAccountId(resolvedId, "BasicWallet");
   }
   const normalized = normalizeAccountIdInput(value);
   if (isBech32Input(normalized)) {
     try {
-      return import_miden_sdk2.Address.fromBech32(normalized);
+      return Address.fromBech32(normalized);
     } catch {
-      const resolvedAccountId2 = accountId ?? import_miden_sdk2.AccountId.fromBech32(normalized);
-      return import_miden_sdk2.Address.fromAccountId(resolvedAccountId2, "BasicWallet");
+      const resolvedAccountId2 = accountId ?? AccountId.fromBech32(normalized);
+      return Address.fromAccountId(resolvedAccountId2, "BasicWallet");
     }
   }
-  const resolvedAccountId = accountId ?? import_miden_sdk2.AccountId.fromHex(normalizeHexInput(normalized));
-  return import_miden_sdk2.Address.fromAccountId(resolvedAccountId, "BasicWallet");
+  const resolvedAccountId = accountId ?? AccountId.fromHex(normalizeHexInput(normalized));
+  return Address.fromAccountId(resolvedAccountId, "BasicWallet");
 };
 
 // src/utils/accountBech32.ts
 var inferNetworkId = () => {
   const { rpcUrl } = useMidenStore.getState().config;
   if (!rpcUrl) {
-    return import_miden_sdk3.NetworkId.testnet();
+    return NetworkId.testnet();
   }
   const url = rpcUrl.toLowerCase();
   if (url.includes("devnet") || url.includes("mdev")) {
-    return import_miden_sdk3.NetworkId.devnet();
+    return NetworkId.devnet();
   }
   if (url.includes("mainnet")) {
-    return import_miden_sdk3.NetworkId.mainnet();
+    return NetworkId.mainnet();
   }
   if (url.includes("testnet") || url.includes("mtst")) {
-    return import_miden_sdk3.NetworkId.testnet();
+    return NetworkId.testnet();
   }
-  return import_miden_sdk3.NetworkId.testnet();
+  return NetworkId.testnet();
 };
 var toBech32FromAccountId = (id) => {
   try {
-    const address = import_miden_sdk3.Address.fromAccountId(id, "BasicWallet");
+    const address = Address2.fromAccountId(id, "BasicWallet");
     return address.toBech32(inferNetworkId());
   } catch {
   }
   try {
     const maybeBech32 = id.toBech32?.(
       inferNetworkId(),
-      import_miden_sdk3.AccountInterface.BasicWallet
+      AccountInterface.BasicWallet
     );
     if (typeof maybeBech32 === "string") {
       return maybeBech32;
@@ -351,7 +265,7 @@ var defineBech32 = (target) => {
   }
 };
 var installAccountBech32 = () => {
-  const proto = import_miden_sdk3.Account.prototype;
+  const proto = Account.prototype;
   if (proto.bech32id) {
     return;
   }
@@ -383,18 +297,26 @@ var toBech32AccountId = (accountId) => {
 };
 
 // src/context/MidenProvider.tsx
-var import_react2 = require("react");
-var import_miden_sdk6 = require("@miden-sdk/miden-sdk");
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect,
+  useRef,
+  useCallback,
+  useMemo,
+  useState
+} from "react";
+import { WasmWebClient as WebClient } from "@miden-sdk/miden-sdk/mt";
 
 // src/types/index.ts
-var import_miden_sdk4 = require("@miden-sdk/miden-sdk");
+import { AuthScheme } from "@miden-sdk/miden-sdk/mt";
 var DEFAULTS = {
   RPC_URL: void 0,
   // Will use SDK's testnet default
   AUTO_SYNC_INTERVAL: 15e3,
   STORAGE_MODE: "private",
   WALLET_MUTABLE: true,
-  AUTH_SCHEME: import_miden_sdk4.AuthScheme.AuthRpoFalcon512,
+  AUTH_SCHEME: AuthScheme.AuthRpoFalcon512,
   NOTE_TYPE: "private",
   FAUCET_DECIMALS: 8
 };
@@ -438,7 +360,7 @@ function resolveRpcUrl(rpcUrl) {
 }
 
 // src/utils/prover.ts
-var import_miden_sdk5 = require("@miden-sdk/miden-sdk");
+import { TransactionProver } from "@miden-sdk/miden-sdk/mt";
 var DEFAULT_PROVER_URLS = {
   devnet: "https://tx-prover.devnet.miden.io",
   testnet: "https://tx-prover.testnet.miden.io"
@@ -477,16 +399,16 @@ function resolveProverTarget(target, config) {
   if (typeof target === "string") {
     const normalized = target.trim().toLowerCase();
     if (normalized === "local" || normalized === "localhost") {
-      return import_miden_sdk5.TransactionProver.newLocalProver();
+      return TransactionProver.newLocalProver();
     }
     if (normalized === "devnet" || normalized === "testnet") {
       const url = config.proverUrls?.[normalized] ?? DEFAULT_PROVER_URLS[normalized];
-      return import_miden_sdk5.TransactionProver.newRemoteProver(
+      return TransactionProver.newRemoteProver(
         url,
         normalizeTimeout(config.proverTimeoutMs)
       );
     }
-    return import_miden_sdk5.TransactionProver.newRemoteProver(
+    return TransactionProver.newRemoteProver(
       target,
       normalizeTimeout(config.proverTimeoutMs)
     );
@@ -498,7 +420,7 @@ function createRemoteProver(config, fallbackTimeout) {
   if (!url) {
     throw new Error("Remote prover requires a URL");
   }
-  return import_miden_sdk5.TransactionProver.newRemoteProver(
+  return TransactionProver.newRemoteProver(
     url,
     normalizeTimeout(timeoutMs ?? fallbackTimeout)
   );
@@ -514,35 +436,28 @@ function normalizeTimeout(timeoutMs) {
 }
 
 // src/context/SignerContext.ts
-var import_react = require("react");
-var SignerContext = (0, import_react.createContext)(null);
+import { createContext, useContext } from "react";
+var SignerContext = createContext(null);
 function useSigner() {
-  return (0, import_react.useContext)(SignerContext);
+  return useContext(SignerContext);
 }
 
 // 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 } = await import("@miden-sdk/miden-sdk");
+  const { AccountBuilder, AccountComponent, AuthScheme: AuthScheme2, Word: Word2 } = await import("@miden-sdk/miden-sdk/mt");
   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;
       }
     }
@@ -551,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") {
@@ -593,8 +507,8 @@ async function initializeSignerAccount(client, config) {
 }
 
 // src/context/MidenProvider.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
-var MidenContext = (0, import_react2.createContext)(null);
+import { Fragment, jsx } from "react/jsx-runtime";
+var MidenContext = createContext2(null);
 function MidenProvider({
   children,
   config = {},
@@ -614,21 +528,21 @@ function MidenProvider({
     setSyncState,
     setSignerConnected
   } = useMidenStore();
-  const syncIntervalRef = (0, import_react2.useRef)(null);
-  const isInitializedRef = (0, import_react2.useRef)(false);
-  const clientLockRef = (0, import_react2.useRef)(new AsyncLock());
-  const currentStoreNameRef = (0, import_react2.useRef)(null);
-  const signCbRef = (0, import_react2.useRef)(null);
+  const syncIntervalRef = useRef(null);
+  const isInitializedRef = useRef(false);
+  const clientLockRef = useRef(new AsyncLock());
+  const currentStoreNameRef = useRef(null);
+  const signCbRef = useRef(null);
   const signerContext = useSigner();
-  const [signerAccountId, setSignerAccountId] = (0, import_react2.useState)(null);
-  const resolvedConfig = (0, import_react2.useMemo)(
+  const [signerAccountId, setSignerAccountId] = useState(null);
+  const resolvedConfig = useMemo(
     () => ({
       ...config,
       rpcUrl: resolveRpcUrl(config.rpcUrl)
     }),
     [config]
   );
-  const defaultProver = (0, import_react2.useMemo)(
+  const defaultProver = useMemo(
     () => resolveTransactionProver(resolvedConfig),
     [
       resolvedConfig.prover,
@@ -637,11 +551,11 @@ function MidenProvider({
       resolvedConfig.proverUrls?.testnet
     ]
   );
-  const runExclusive = (0, import_react2.useCallback)(
+  const runExclusive = useCallback(
     async (fn) => clientLockRef.current.runExclusive(fn),
     []
   );
-  const sync = (0, import_react2.useCallback)(async () => {
+  const sync = useCallback(async () => {
     if (!client || !isReady) return;
     const store = useMidenStore.getState();
     if (store.sync.isSyncing) return;
@@ -668,10 +582,10 @@ function MidenProvider({
   const signerStoreName = signerContext?.storeName ?? null;
   const signerAccountType = signerContext?.accountConfig?.accountType ?? null;
   const signerStorageMode = signerContext?.accountConfig?.storageMode?.toString() ?? null;
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
     signCbRef.current = signerContext?.signCb ?? null;
   }, [signerContext?.signCb]);
-  const wrappedSignCb = (0, import_react2.useCallback)(
+  const wrappedSignCb = useCallback(
     async (pubKey, signingInputs) => {
       const cb = signCbRef.current;
       if (!cb) {
@@ -681,7 +595,7 @@ function MidenProvider({
     },
     []
   );
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
     if (signerIsConnected === null && isInitializedRef.current) return;
     if (signerIsConnected === false) {
       const store = useMidenStore.getState();
@@ -715,14 +629,16 @@ function MidenProvider({
           if (signerContext && signerIsConnected === true) {
             const storeName = `MidenClientDB_${signerContext.storeName}`;
             signCbRef.current = signerContext.signCb;
-            webClient = await import_miden_sdk6.WasmWebClient.createClientWithExternalKeystore(
+            webClient = await WebClient.createClientWithExternalKeystore(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
               resolvedConfig.seed,
               storeName,
               signerContext.getKeyCb,
               signerContext.insertKeyCb,
-              wrappedSignCb
+              wrappedSignCb,
+              void 0,
+              resolvedConfig.useWorker
             );
             if (cancelled) return;
             const accountId = await initializeSignerAccount(
@@ -735,10 +651,13 @@ function MidenProvider({
             currentStoreNameRef.current = signerContext.storeName;
           } else {
             const seed = resolvedConfig.seed;
-            webClient = await import_miden_sdk6.WasmWebClient.createClient(
+            webClient = await WebClient.createClient(
               resolvedConfig.rpcUrl,
               resolvedConfig.noteTransportUrl,
-              seed
+              seed,
+              void 0,
+              void 0,
+              resolvedConfig.useWorker
             );
             if (cancelled) return;
           }
@@ -804,7 +723,7 @@ function MidenProvider({
     // signCb changes are handled by the dedicated useEffect + signCbRef above,
     // not by this effect.
   ]);
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
     if (!isReady || !client) return;
     const interval = config.autoSyncInterval ?? DEFAULTS.AUTO_SYNC_INTERVAL;
     if (interval <= 0) return;
@@ -820,7 +739,7 @@ function MidenProvider({
       }
     };
   }, [isReady, client, config.autoSyncInterval, sync]);
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
     if (!isReady || !client) return;
     const unsubscribe = client.onStateChanged?.(async () => {
       try {
@@ -835,13 +754,13 @@ function MidenProvider({
     };
   }, [isReady, client, setSyncState]);
   if (isInitializing && loadingComponent) {
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: loadingComponent });
+    return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent });
   }
   if (initError && errorComponent) {
     if (typeof errorComponent === "function") {
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: errorComponent(initError) });
+      return /* @__PURE__ */ jsx(Fragment, { children: errorComponent(initError) });
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: errorComponent });
+    return /* @__PURE__ */ jsx(Fragment, { children: errorComponent });
   }
   const contextValue = {
     client,
@@ -854,10 +773,10 @@ function MidenProvider({
     signerAccountId,
     signerConnected
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MidenContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(MidenContext.Provider, { value: contextValue, children });
 }
 function useMiden() {
-  const context = (0, import_react2.useContext)(MidenContext);
+  const context = useContext2(MidenContext);
   if (!context) {
     throw new Error("useMiden must be used within a MidenProvider");
   }
@@ -874,22 +793,30 @@ function useMidenClient() {
 }
 
 // src/context/MultiSignerProvider.tsx
-var import_react3 = require("react");
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var MultiSignerRegistryContext = (0, import_react3.createContext)(null);
-var MultiSignerContext = (0, import_react3.createContext)(null);
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useState as useState2,
+  useCallback as useCallback2,
+  useMemo as useMemo2
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var MultiSignerRegistryContext = createContext3(null);
+var MultiSignerContext = createContext3(null);
 function MultiSignerProvider({ children }) {
-  const signersRef = (0, import_react3.useRef)(/* @__PURE__ */ new Map());
-  const [signersSnapshot, setSignersSnapshot] = (0, import_react3.useState)(
+  const signersRef = useRef2(/* @__PURE__ */ new Map());
+  const [signersSnapshot, setSignersSnapshot] = useState2(
     []
   );
-  const [activeSignerName, setActiveSignerName] = (0, import_react3.useState)(null);
-  const activeSignerNameRef = (0, import_react3.useRef)(null);
-  const generationRef = (0, import_react3.useRef)(0);
-  const updateSnapshot = (0, import_react3.useCallback)(() => {
+  const [activeSignerName, setActiveSignerName] = useState2(null);
+  const activeSignerNameRef = useRef2(null);
+  const generationRef = useRef2(0);
+  const updateSnapshot = useCallback2(() => {
     setSignersSnapshot(Array.from(signersRef.current.values()));
   }, []);
-  const register = (0, import_react3.useCallback)(
+  const register = useCallback2(
     (value) => {
       const prev = signersRef.current.get(value.name);
       signersRef.current.set(value.name, value);
@@ -899,7 +826,7 @@ function MultiSignerProvider({ children }) {
     },
     [updateSnapshot]
   );
-  const unregister = (0, import_react3.useCallback)(
+  const unregister = useCallback2(
     (name) => {
       signersRef.current.delete(name);
       setActiveSignerName((current) => current === name ? null : current);
@@ -907,12 +834,12 @@ function MultiSignerProvider({ children }) {
     },
     [updateSnapshot]
   );
-  const registry = (0, import_react3.useMemo)(
+  const registry = useMemo2(
     () => ({ register, unregister }),
     [register, unregister]
   );
   const activeSigner = activeSignerName ? signersSnapshot.find((s) => s.name === activeSignerName) ?? null : null;
-  const stableSignCb = (0, import_react3.useCallback)(
+  const stableSignCb = useCallback2(
     async (pubKey, signingInputs) => {
       const name = activeSignerName;
       if (!name) throw new Error("No active signer (signer was disconnected)");
@@ -922,21 +849,21 @@ function MultiSignerProvider({ children }) {
     },
     [activeSignerName]
   );
-  const stableConnect = (0, import_react3.useCallback)(async () => {
+  const stableConnect = useCallback2(async () => {
     const name = activeSignerName;
     if (!name) throw new Error("No active signer (signer was disconnected)");
     const signer = signersRef.current.get(name);
     if (!signer) throw new Error(`Signer "${name}" not found in registry`);
     return signer.connect();
   }, [activeSignerName]);
-  const stableDisconnect = (0, import_react3.useCallback)(async () => {
+  const stableDisconnect = useCallback2(async () => {
     const name = activeSignerName;
     if (!name) throw new Error("No active signer (signer was disconnected)");
     const signer = signersRef.current.get(name);
     if (!signer) throw new Error(`Signer "${name}" not found in registry`);
     return signer.disconnect();
   }, [activeSignerName]);
-  const forwardedValue = (0, import_react3.useMemo)(() => {
+  const forwardedValue = useMemo2(() => {
     if (!activeSigner) return null;
     return {
       name: activeSigner.name,
@@ -956,11 +883,11 @@ function MultiSignerProvider({ children }) {
     stableConnect,
     stableDisconnect
   ]);
-  const setActiveName = (0, import_react3.useCallback)((name) => {
+  const setActiveName = useCallback2((name) => {
     activeSignerNameRef.current = name;
     setActiveSignerName(name);
   }, []);
-  const connectSigner = (0, import_react3.useCallback)(
+  const connectSigner = useCallback2(
     async (name) => {
       const currentName = activeSignerNameRef.current;
       const currentSigner = currentName ? signersRef.current.get(currentName) : null;
@@ -985,7 +912,7 @@ function MultiSignerProvider({ children }) {
     },
     [setActiveName]
   );
-  const disconnectSigner = (0, import_react3.useCallback)(async () => {
+  const disconnectSigner = useCallback2(async () => {
     ++generationRef.current;
     const currentName = activeSignerNameRef.current;
     const signer = currentName ? signersRef.current.get(currentName) : null;
@@ -996,7 +923,7 @@ function MultiSignerProvider({ children }) {
       });
     }
   }, [setActiveName]);
-  const multiSignerValue = (0, import_react3.useMemo)(
+  const multiSignerValue = useMemo2(
     () => ({
       signers: signersSnapshot,
       activeSigner,
@@ -1005,18 +932,18 @@ function MultiSignerProvider({ children }) {
     }),
     [signersSnapshot, activeSigner, connectSigner, disconnectSigner]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SignerContext.Provider, { value: forwardedValue, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerRegistryContext.Provider, { value: registry, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MultiSignerContext.Provider, { value: multiSignerValue, children }) }) });
+  return /* @__PURE__ */ jsx2(SignerContext.Provider, { value: forwardedValue, children: /* @__PURE__ */ jsx2(MultiSignerRegistryContext.Provider, { value: registry, children: /* @__PURE__ */ jsx2(MultiSignerContext.Provider, { value: multiSignerValue, children }) }) });
 }
 function SignerSlot() {
   const signerValue = useSigner();
-  const registry = (0, import_react3.useContext)(MultiSignerRegistryContext);
-  const nameRef = (0, import_react3.useRef)();
-  (0, import_react3.useEffect)(() => {
+  const registry = useContext3(MultiSignerRegistryContext);
+  const nameRef = useRef2();
+  useEffect2(() => {
     if (!signerValue || !registry) return;
     nameRef.current = signerValue.name;
     registry.register(signerValue);
   }, [signerValue, registry]);
-  (0, import_react3.useEffect)(() => {
+  useEffect2(() => {
     return () => {
       if (nameRef.current && registry) {
         registry.unregister(nameRef.current);
@@ -1026,18 +953,18 @@ function SignerSlot() {
   return null;
 }
 function useMultiSigner() {
-  return (0, import_react3.useContext)(MultiSignerContext);
+  return useContext3(MultiSignerContext);
 }
 
 // src/hooks/useAccounts.ts
-var import_react4 = require("react");
+import { useCallback as useCallback3, useEffect as useEffect3 } from "react";
 function useAccounts() {
   const { client, isReady } = useMiden();
   const accounts = useAccountsStore();
   const isLoadingAccounts = useMidenStore((state) => state.isLoadingAccounts);
   const setLoadingAccounts = useMidenStore((state) => state.setLoadingAccounts);
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const refetch = (0, import_react4.useCallback)(async () => {
+  const refetch = useCallback3(async () => {
     if (!client || !isReady) return;
     setLoadingAccounts(true);
     try {
@@ -1049,7 +976,7 @@ function useAccounts() {
       setLoadingAccounts(false);
     }
   }, [client, isReady, setAccounts, setLoadingAccounts]);
-  (0, import_react4.useEffect)(() => {
+  useEffect3(() => {
     if (isReady && accounts.length === 0) {
       refetch();
     }
@@ -1075,11 +1002,15 @@ function useAccounts() {
 }
 
 // src/hooks/useAccount.ts
-var import_react6 = require("react");
+import { useCallback as useCallback4, useEffect as useEffect5, useState as useState3, useMemo as useMemo4 } from "react";
 
 // src/hooks/useAssetMetadata.ts
-var import_react5 = require("react");
-var import_miden_sdk7 = require("@miden-sdk/miden-sdk");
+import { useEffect as useEffect4, useMemo as useMemo3 } from "react";
+import {
+  BasicFungibleFaucetComponent,
+  Endpoint,
+  RpcClient
+} from "@miden-sdk/miden-sdk/mt";
 var inflight = /* @__PURE__ */ new Map();
 var rpcClients = /* @__PURE__ */ new Map();
 var getRpcClient = (rpcUrl) => {
@@ -1087,8 +1018,8 @@ var getRpcClient = (rpcUrl) => {
   const existing = rpcClients.get(key);
   if (existing) return existing;
   try {
-    const endpoint = rpcUrl ? new import_miden_sdk7.Endpoint(rpcUrl) : import_miden_sdk7.Endpoint.testnet();
-    const client = new import_miden_sdk7.RpcClient(endpoint);
+    const endpoint = rpcUrl ? new Endpoint(rpcUrl) : Endpoint.testnet();
+    const client = new RpcClient(endpoint);
     rpcClients.set(key, client);
     return client;
   } catch {
@@ -1102,7 +1033,7 @@ var fetchAssetMetadata = async (rpcClient, assetId) => {
     const fetched = await rpcClient.getAccountDetails(accountId);
     const account = fetched.account?.();
     if (!account) return null;
-    const faucet = import_miden_sdk7.BasicFungibleFaucetComponent.fromAccount(account);
+    const faucet = BasicFungibleFaucetComponent.fromAccount(account);
     const symbol = faucet.symbol().toString();
     const decimals = faucet.decimals();
     return { assetId, symbol, decimals };
@@ -1114,12 +1045,12 @@ function useAssetMetadata(assetIds = []) {
   const assetMetadata = useAssetMetadataStore();
   const setAssetMetadata = useMidenStore((state) => state.setAssetMetadata);
   const rpcUrl = useMidenStore((state) => state.config.rpcUrl);
-  const rpcClient = (0, import_react5.useMemo)(() => getRpcClient(rpcUrl), [rpcUrl]);
-  const uniqueAssetIds = (0, import_react5.useMemo)(
+  const rpcClient = useMemo3(() => getRpcClient(rpcUrl), [rpcUrl]);
+  const uniqueAssetIds = useMemo3(
     () => Array.from(new Set(assetIds.filter(Boolean))),
     [assetIds]
   );
-  (0, import_react5.useEffect)(() => {
+  useEffect4(() => {
     if (!rpcClient || uniqueAssetIds.length === 0) return;
     uniqueAssetIds.forEach((assetId) => {
       const existing = assetMetadata.get(assetId);
@@ -1142,15 +1073,15 @@ function useAccount(accountId) {
   const accountDetails = useMidenStore((state) => state.accountDetails);
   const setAccountDetails = useMidenStore((state) => state.setAccountDetails);
   const { lastSyncTime } = useSyncStateStore();
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const accountIdStr = (0, import_react6.useMemo)(() => {
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const accountIdStr = useMemo4(() => {
     if (!accountId) return void 0;
     if (typeof accountId === "string") return accountId;
     return parseAccountId(accountId).toString();
   }, [accountId]);
   const account = accountIdStr ? accountDetails.get(accountIdStr) ?? null : null;
-  const refetch = (0, import_react6.useCallback)(async () => {
+  const refetch = useCallback4(async () => {
     if (!client || !isReady || !accountIdStr) return;
     setIsLoading(true);
     setError(null);
@@ -1167,16 +1098,16 @@ function useAccount(accountId) {
       setIsLoading(false);
     }
   }, [client, isReady, accountIdStr, setAccountDetails]);
-  (0, import_react6.useEffect)(() => {
+  useEffect5(() => {
     if (isReady && accountIdStr && !account) {
       refetch();
     }
   }, [isReady, accountIdStr, account, refetch]);
-  (0, import_react6.useEffect)(() => {
+  useEffect5(() => {
     if (!isReady || !accountIdStr || !lastSyncTime) return;
     refetch();
   }, [isReady, accountIdStr, lastSyncTime, refetch]);
-  const rawAssets = (0, import_react6.useMemo)(() => {
+  const rawAssets = useMemo4(() => {
     if (!account) return [];
     try {
       const vault = account.vault();
@@ -1193,12 +1124,12 @@ function useAccount(accountId) {
       return [];
     }
   }, [account]);
-  const assetIds = (0, import_react6.useMemo)(
+  const assetIds = useMemo4(
     () => rawAssets.map((asset) => asset.assetId),
     [rawAssets]
   );
   const { assetMetadata } = useAssetMetadata(assetIds);
-  const assets = (0, import_react6.useMemo)(
+  const assets = useMemo4(
     () => rawAssets.map((asset) => {
       const metadata = assetMetadata.get(asset.assetId);
       return {
@@ -1209,7 +1140,7 @@ function useAccount(accountId) {
     }),
     [rawAssets, assetMetadata]
   );
-  const getBalance = (0, import_react6.useCallback)(
+  const getBalance = useCallback4(
     (assetId) => {
       const asset = assets.find((a) => a.assetId === assetId);
       return asset?.amount ?? 0n;
@@ -1227,8 +1158,8 @@ function useAccount(accountId) {
 }
 
 // src/hooks/useNotes.ts
-var import_react7 = require("react");
-var import_miden_sdk9 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useState as useState4 } from "react";
+import { NoteFilter } from "@miden-sdk/miden-sdk/mt";
 
 // src/utils/amounts.ts
 var formatAssetAmount = (amount, decimals) => {
@@ -1270,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") {
@@ -1280,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();
@@ -1333,30 +1287,34 @@ function accountIdsEqual(a, b) {
 }
 
 // src/utils/noteFilters.ts
-var import_miden_sdk8 = require("@miden-sdk/miden-sdk");
+import {
+  NoteFilterTypes,
+  NoteType,
+  TransactionFilter
+} from "@miden-sdk/miden-sdk/mt";
 function getNoteFilterType(status) {
   switch (status) {
     case "consumed":
-      return import_miden_sdk8.NoteFilterTypes.Consumed;
+      return NoteFilterTypes.Consumed;
     case "committed":
-      return import_miden_sdk8.NoteFilterTypes.Committed;
+      return NoteFilterTypes.Committed;
     case "expected":
-      return import_miden_sdk8.NoteFilterTypes.Expected;
+      return NoteFilterTypes.Expected;
     case "processing":
-      return import_miden_sdk8.NoteFilterTypes.Processing;
+      return NoteFilterTypes.Processing;
     case "all":
     default:
-      return import_miden_sdk8.NoteFilterTypes.All;
+      return NoteFilterTypes.All;
   }
 }
 function getNoteType(type) {
   switch (type) {
     case "private":
-      return import_miden_sdk8.NoteType.Private;
+      return NoteType.Private;
     case "public":
-      return import_miden_sdk8.NoteType.Public;
+      return NoteType.Public;
     default:
-      return import_miden_sdk8.NoteType.Private;
+      return NoteType.Private;
   }
 }
 async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWaitMs = 1e4, delayMs = 1e3) {
@@ -1365,7 +1323,7 @@ async function waitForTransactionCommit(client, runExclusiveSafe, txIdHex, maxWa
   while (Date.now() < deadline) {
     await runExclusiveSafe(() => client.syncState());
     const records = await runExclusiveSafe(
-      () => client.getTransactions(import_miden_sdk8.TransactionFilter.all())
+      () => client.getTransactions(TransactionFilter.all())
     );
     const record = records.find(
       (r) => normalizeHex(r.id().toHex()) === targetHex
@@ -1401,14 +1359,14 @@ function useNotes(options) {
     (state) => state.setConsumableNotesIfChanged
   );
   const { lastSyncTime } = useSyncStateStore();
-  const [error, setError] = (0, import_react7.useState)(null);
-  const refetch = (0, import_react7.useCallback)(async () => {
+  const [error, setError] = useState4(null);
+  const refetch = useCallback5(async () => {
     if (!client || !isReady) return;
     setLoadingNotes(true);
     setError(null);
     try {
       const filterType = getNoteFilterType(options?.status);
-      const filter = new import_miden_sdk9.NoteFilter(filterType);
+      const filter = new NoteFilter(filterType);
       const fetchedNotes = await client.getInputNotes(filter);
       let fetchedConsumable;
       if (options?.accountId) {
@@ -1433,16 +1391,16 @@ function useNotes(options) {
     setNotesIfChanged,
     setConsumableNotesIfChanged
   ]);
-  (0, import_react7.useEffect)(() => {
+  useEffect6(() => {
     if (isReady && notes.length === 0) {
       refetch();
     }
   }, [isReady, notes.length, refetch]);
-  (0, import_react7.useEffect)(() => {
+  useEffect6(() => {
     if (!isReady || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refetch]);
-  const noteAssetIds = (0, import_react7.useMemo)(() => {
+  const noteAssetIds = useMemo5(() => {
     const ids = /* @__PURE__ */ new Set();
     const collect = (note) => {
       const summary = getNoteSummary(note);
@@ -1454,11 +1412,11 @@ function useNotes(options) {
     return Array.from(ids);
   }, [notes, consumableNotes]);
   const { assetMetadata } = useAssetMetadata(noteAssetIds);
-  const getMetadata = (0, import_react7.useCallback)(
+  const getMetadata = useCallback5(
     (assetId) => assetMetadata.get(assetId),
     [assetMetadata]
   );
-  const normalizedSender = (0, import_react7.useMemo)(() => {
+  const normalizedSender = useMemo5(() => {
     if (!options?.sender) return null;
     try {
       return normalizeAccountId(options.sender);
@@ -1466,11 +1424,11 @@ function useNotes(options) {
       return options.sender;
     }
   }, [options?.sender]);
-  const excludeIdsKey = (0, import_react7.useMemo)(() => {
+  const excludeIdsKey = useMemo5(() => {
     if (!options?.excludeIds || options.excludeIds.length === 0) return "";
     return [...options.excludeIds].sort().join("\0");
   }, [options?.excludeIds]);
-  const filterBySender = (0, import_react7.useCallback)(
+  const filterBySender = useCallback5(
     (summaries, target) => {
       const cache = /* @__PURE__ */ new Map();
       return summaries.filter((s) => {
@@ -1489,7 +1447,7 @@ function useNotes(options) {
     },
     []
   );
-  const noteSummaries = (0, import_react7.useMemo)(() => {
+  const noteSummaries = useMemo5(() => {
     let summaries = notes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1500,7 +1458,7 @@ function useNotes(options) {
     }
     return summaries;
   }, [notes, getMetadata, normalizedSender, excludeIdsKey, filterBySender]);
-  const consumableNoteSummaries = (0, import_react7.useMemo)(() => {
+  const consumableNoteSummaries = useMemo5(() => {
     let summaries = consumableNotes.map((note) => getNoteSummary(note, getMetadata)).filter(Boolean);
     if (normalizedSender) {
       summaries = filterBySender(summaries, normalizedSender);
@@ -1529,39 +1487,29 @@ function useNotes(options) {
 }
 
 // src/hooks/useNoteStream.ts
-var import_react8 = require("react");
-var import_miden_sdk11 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo6, useRef as useRef3, useState as useState5 } from "react";
+import { NoteFilter as NoteFilter2 } from "@miden-sdk/miden-sdk/mt";
 
 // src/utils/noteAttachment.ts
-var import_miden_sdk10 = require("@miden-sdk/miden-sdk");
+import {
+  NoteAttachment,
+  NoteAttachmentScheme,
+  Word
+} from "@miden-sdk/miden-sdk/mt";
 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 === import_miden_sdk10.NoteAttachmentKind.None) return null;
-    if (kind === import_miden_sdk10.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 === import_miden_sdk10.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;
   }
@@ -1572,30 +1520,29 @@ function createNoteAttachment(values) {
     bigints.push(BigInt(values[i]));
   }
   if (bigints.length === 0) {
-    return new import_miden_sdk10.NoteAttachment();
+    return emptyAttachment();
   }
-  const scheme = import_miden_sdk10.NoteAttachmentScheme.none();
+  const scheme = NoteAttachmentScheme.none();
   if (bigints.length <= 4) {
     while (bigints.length < 4) {
       bigints.push(0n);
     }
-    const word = new import_miden_sdk10.Word(BigUint64Array.from(bigints));
-    return import_miden_sdk10.NoteAttachment.newWord(scheme, word);
+    const word = new Word(BigUint64Array.from(bigints));
+    return NoteAttachment.fromWord(scheme, word);
   }
   while (bigints.length % 4 !== 0) {
     bigints.push(0n);
   }
   const words = [];
   for (let i = 0; i < bigints.length; i += 4) {
-    words.push(new import_miden_sdk10.Word(BigUint64Array.from(bigints.slice(i, i + 4))));
+    words.push(new Word(BigUint64Array.from(bigints.slice(i, i + 4))));
   }
-  const newArray = import_miden_sdk10.NoteAttachment["newArray"];
-  if (typeof newArray !== "function") {
-    throw new Error(
-      "NoteAttachment.newArray is not available. Ensure @miden-sdk/miden-sdk >= 0.13.1."
-    );
-  }
-  return newArray.call(import_miden_sdk10.NoteAttachment, scheme, words);
+  return 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
@@ -1605,32 +1552,32 @@ function useNoteStream(options = {}) {
   const noteFirstSeen = useNoteFirstSeenStore();
   const { lastSyncTime } = useSyncStateStore();
   const setNotesIfChanged = useMidenStore((state) => state.setNotesIfChanged);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const handledIdsRef = (0, import_react8.useRef)(/* @__PURE__ */ new Set());
-  const [handledVersion, setHandledVersion] = (0, import_react8.useState)(0);
+  const [isLoading, setIsLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const handledIdsRef = useRef3(/* @__PURE__ */ new Set());
+  const [handledVersion, setHandledVersion] = useState5(0);
   const status = options.status ?? "committed";
   const sender = options.sender ?? null;
   const since = options.since;
-  const amountFilterRef = (0, import_react8.useRef)(options.amountFilter);
+  const amountFilterRef = useRef3(options.amountFilter);
   amountFilterRef.current = options.amountFilter;
-  const excludeIdsKey = (0, import_react8.useMemo)(() => {
+  const excludeIdsKey = useMemo6(() => {
     if (!options.excludeIds) return "";
     if (options.excludeIds instanceof Set)
       return Array.from(options.excludeIds).sort().join("\0");
     return [...options.excludeIds].sort().join("\0");
   }, [options.excludeIds]);
-  const excludeIdSet = (0, import_react8.useMemo)(() => {
+  const excludeIdSet = useMemo6(() => {
     if (!excludeIdsKey) return null;
     return new Set(excludeIdsKey.split("\0"));
   }, [excludeIdsKey]);
-  const refetch = (0, import_react8.useCallback)(async () => {
+  const refetch = useCallback6(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
     try {
       const filterType = getNoteFilterType(status);
-      const filter = new import_miden_sdk11.NoteFilter(filterType);
+      const filter = new NoteFilter2(filterType);
       const fetched = await client.getInputNotes(filter);
       setNotesIfChanged(fetched);
     } catch (err) {
@@ -1639,12 +1586,12 @@ function useNoteStream(options = {}) {
       setIsLoading(false);
     }
   }, [client, isReady, status, setNotesIfChanged]);
-  (0, import_react8.useEffect)(() => {
+  useEffect7(() => {
     if (isReady) {
       refetch();
     }
   }, [isReady, lastSyncTime, refetch]);
-  const streamedNotes = (0, import_react8.useMemo)(() => {
+  const streamedNotes = useMemo6(() => {
     void handledVersion;
     const result = [];
     let normalizedSender = null;
@@ -1669,15 +1616,15 @@ function useNoteStream(options = {}) {
     result.sort((a, b) => a.firstSeenAt - b.firstSeenAt);
     return result;
   }, [allNotes, noteFirstSeen, excludeIdSet, sender, since, handledVersion]);
-  const latest = (0, import_react8.useMemo)(
+  const latest = useMemo6(
     () => streamedNotes.length > 0 ? streamedNotes[streamedNotes.length - 1] : null,
     [streamedNotes]
   );
-  const markHandled = (0, import_react8.useCallback)((noteId) => {
+  const markHandled = useCallback6((noteId) => {
     handledIdsRef.current = new Set(handledIdsRef.current).add(noteId);
     setHandledVersion((v) => v + 1);
   }, []);
-  const markAllHandled = (0, import_react8.useCallback)(() => {
+  const markAllHandled = useCallback6(() => {
     const newSet = new Set(handledIdsRef.current);
     for (const note of streamedNotes) {
       newSet.add(note.id);
@@ -1685,7 +1632,7 @@ function useNoteStream(options = {}) {
     handledIdsRef.current = newSet;
     setHandledVersion((v) => v + 1);
   }, [streamedNotes]);
-  const snapshot = (0, import_react8.useCallback)(() => {
+  const snapshot = useCallback6(() => {
     const ids = /* @__PURE__ */ new Set();
     for (const note of streamedNotes) {
       ids.add(note.id);
@@ -1704,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) : "";
@@ -1741,20 +1690,20 @@ function buildStreamedNote(record, noteFirstSeen) {
 }
 
 // src/hooks/useTransactionHistory.ts
-var import_react9 = require("react");
-var import_miden_sdk12 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo7, useState as useState6 } from "react";
+import { TransactionFilter as TransactionFilter2 } from "@miden-sdk/miden-sdk/mt";
 function useTransactionHistory(options = {}) {
   const { client, isReady } = useMiden();
   const { lastSyncTime } = useSyncStateStore();
-  const [records, setRecords] = (0, import_react9.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
-  const [error, setError] = (0, import_react9.useState)(null);
-  const rawIds = (0, import_react9.useMemo)(() => {
+  const [records, setRecords] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const rawIds = useMemo7(() => {
     if (options.id) return [options.id];
     if (options.ids && options.ids.length > 0) return options.ids;
     return null;
   }, [options.id, options.ids]);
-  const idsHex = (0, import_react9.useMemo)(() => {
+  const idsHex = useMemo7(() => {
     if (!rawIds) return null;
     return rawIds.map(
       (id) => normalizeHex2(typeof id === "string" ? id : id.toHex())
@@ -1762,7 +1711,7 @@ function useTransactionHistory(options = {}) {
   }, [rawIds]);
   const filter = options.filter;
   const refreshOnSync = options.refreshOnSync !== false;
-  const refetch = (0, import_react9.useCallback)(async () => {
+  const refetch = useCallback7(async () => {
     if (!client || !isReady) return;
     setIsLoading(true);
     setError(null);
@@ -1783,19 +1732,19 @@ function useTransactionHistory(options = {}) {
       setIsLoading(false);
     }
   }, [client, isReady, filter, rawIds, idsHex]);
-  (0, import_react9.useEffect)(() => {
+  useEffect8(() => {
     if (!isReady) return;
     refetch();
   }, [isReady, refetch]);
-  (0, import_react9.useEffect)(() => {
+  useEffect8(() => {
     if (!isReady || !refreshOnSync || !lastSyncTime) return;
     refetch();
   }, [isReady, lastSyncTime, refreshOnSync, refetch]);
-  const record = (0, import_react9.useMemo)(() => {
+  const record = useMemo7(() => {
     if (!idsHex || idsHex.length !== 1) return null;
     return records.find((item) => normalizeHex2(item.id().toHex()) === idsHex[0]) ?? null;
   }, [records, idsHex]);
-  const status = (0, import_react9.useMemo)(() => {
+  const status = useMemo7(() => {
     if (!record) return null;
     const current = record.transactionStatus();
     if (current.isCommitted()) return "committed";
@@ -1817,14 +1766,14 @@ function buildFilter(filter, ids, idsHex) {
     return { filter };
   }
   if (!ids || ids.length === 0) {
-    return { filter: import_miden_sdk12.TransactionFilter.all() };
+    return { filter: TransactionFilter2.all() };
   }
   const allTransactionIds = ids.every((id) => typeof id !== "string");
   if (allTransactionIds) {
-    return { filter: import_miden_sdk12.TransactionFilter.ids(ids) };
+    return { filter: TransactionFilter2.ids(ids) };
   }
   return {
-    filter: import_miden_sdk12.TransactionFilter.all(),
+    filter: TransactionFilter2.all(),
     localFilterHexes: idsHex ?? []
   };
 }
@@ -1835,11 +1784,11 @@ function normalizeHex2(value) {
 }
 
 // src/hooks/useSyncState.ts
-var import_react10 = require("react");
+import { useCallback as useCallback8 } from "react";
 function useSyncState() {
   const { sync: triggerSync } = useMiden();
   const syncState = useSyncStateStore();
-  const sync = (0, import_react10.useCallback)(async () => {
+  const sync = useCallback8(async () => {
     await triggerSync();
   }, [triggerSync]);
   return {
@@ -1849,8 +1798,8 @@ function useSyncState() {
 }
 
 // src/hooks/useCreateWallet.ts
-var import_react11 = require("react");
-var import_miden_sdk13 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback9, useState as useState7 } from "react";
+import { AccountStorageMode } from "@miden-sdk/miden-sdk/mt";
 
 // src/utils/runExclusive.ts
 var runExclusiveDirect = async (fn) => fn();
@@ -1860,10 +1809,10 @@ function useCreateWallet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [wallet, setWallet] = (0, import_react11.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react11.useState)(false);
-  const [error, setError] = (0, import_react11.useState)(null);
-  const createWallet = (0, import_react11.useCallback)(
+  const [wallet, setWallet] = useState7(null);
+  const [isCreating, setIsCreating] = useState7(false);
+  const [error, setError] = useState7(null);
+  const createWallet = useCallback9(
     async (options = {}) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1900,7 +1849,7 @@ function useCreateWallet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react11.useCallback)(() => {
+  const reset = useCallback9(() => {
     setWallet(null);
     setIsCreating(false);
     setError(null);
@@ -1916,27 +1865,25 @@ function useCreateWallet() {
 function getStorageMode(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk13.AccountStorageMode.private();
+      return AccountStorageMode.private();
     case "public":
-      return import_miden_sdk13.AccountStorageMode.public();
-    case "network":
-      return import_miden_sdk13.AccountStorageMode.network();
+      return AccountStorageMode.public();
     default:
-      return import_miden_sdk13.AccountStorageMode.private();
+      return AccountStorageMode.private();
   }
 }
 
 // src/hooks/useCreateFaucet.ts
-var import_react12 = require("react");
-var import_miden_sdk14 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback10, useState as useState8 } from "react";
+import { AccountStorageMode as AccountStorageMode2 } from "@miden-sdk/miden-sdk/mt";
 function useCreateFaucet() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [faucet, setFaucet] = (0, import_react12.useState)(null);
-  const [isCreating, setIsCreating] = (0, import_react12.useState)(false);
-  const [error, setError] = (0, import_react12.useState)(null);
-  const createFaucet = (0, import_react12.useCallback)(
+  const [faucet, setFaucet] = useState8(null);
+  const [isCreating, setIsCreating] = useState8(false);
+  const [error, setError] = useState8(null);
+  const createFaucet = useCallback10(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -1954,6 +1901,7 @@ function useCreateFaucet() {
             storageMode,
             false,
             // nonFungible - currently only fungible faucets supported
+            options.tokenName ?? options.tokenSymbol,
             options.tokenSymbol,
             decimals,
             BigInt(options.maxSupply),
@@ -1975,7 +1923,7 @@ function useCreateFaucet() {
     },
     [client, isReady, runExclusive, setAccounts]
   );
-  const reset = (0, import_react12.useCallback)(() => {
+  const reset = useCallback10(() => {
     setFaucet(null);
     setIsCreating(false);
     setError(null);
@@ -1991,19 +1939,17 @@ function useCreateFaucet() {
 function getStorageMode2(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk14.AccountStorageMode.private();
+      return AccountStorageMode2.private();
     case "public":
-      return import_miden_sdk14.AccountStorageMode.public();
-    case "network":
-      return import_miden_sdk14.AccountStorageMode.network();
+      return AccountStorageMode2.public();
     default:
-      return import_miden_sdk14.AccountStorageMode.private();
+      return AccountStorageMode2.private();
   }
 }
 
 // src/hooks/useImportAccount.ts
-var import_react13 = require("react");
-var import_miden_sdk15 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback11, useState as useState9 } from "react";
+import { AccountFile } from "@miden-sdk/miden-sdk/mt";
 
 // src/utils/errors.ts
 var MidenError = class extends Error {
@@ -2061,10 +2007,10 @@ function wrapWasmError(e) {
 function useImportAccount() {
   const { client, isReady, signerConnected } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [account, setAccount] = (0, import_react13.useState)(null);
-  const [isImporting, setIsImporting] = (0, import_react13.useState)(false);
-  const [error, setError] = (0, import_react13.useState)(null);
-  const importAccount = (0, import_react13.useCallback)(
+  const [account, setAccount] = useState9(null);
+  const [isImporting, setIsImporting] = useState9(false);
+  const [error, setError] = useState9(null);
+  const importAccount = useCallback11(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2160,7 +2106,7 @@ function useImportAccount() {
     },
     [client, isReady, setAccounts, signerConnected]
   );
-  const reset = (0, import_react13.useCallback)(() => {
+  const reset = useCallback11(() => {
     setAccount(null);
     setIsImporting(false);
     setError(null);
@@ -2175,10 +2121,10 @@ function useImportAccount() {
 }
 async function resolveAccountFile(file) {
   if (file instanceof Uint8Array) {
-    return import_miden_sdk15.AccountFile.deserialize(file);
+    return AccountFile.deserialize(file);
   }
   if (file instanceof ArrayBuffer) {
-    return import_miden_sdk15.AccountFile.deserialize(new Uint8Array(file));
+    return AccountFile.deserialize(new Uint8Array(file));
   }
   return file;
 }
@@ -2207,17 +2153,24 @@ function bytesEqual(left, right) {
 }
 
 // src/hooks/useSend.ts
-var import_react14 = require("react");
-var import_miden_sdk16 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback12, useRef as useRef4, useState as useState10 } from "react";
+import {
+  FungibleAsset,
+  Note,
+  NoteAssets,
+  NoteType as NoteType2,
+  NoteArray,
+  TransactionRequestBuilder
+} from "@miden-sdk/miden-sdk/mt";
 function useSend() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = (0, import_react14.useRef)(false);
-  const [result, setResult] = (0, import_react14.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react14.useState)(false);
-  const [stage, setStage] = (0, import_react14.useState)("idle");
-  const [error, setError] = (0, import_react14.useState)(null);
-  const send = (0, import_react14.useCallback)(
+  const isBusyRef = useRef4(false);
+  const [result, setResult] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [stage, setStage] = useState10("idle");
+  const [error, setError] = useState10(null);
+  const send = useCallback12(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2275,26 +2228,26 @@ function useSend() {
             const fromId = parseAccountId(options.from);
             const toId = parseAccountId(options.to);
             const assetObj = parseAccountId(assetId);
-            const assets = new import_miden_sdk16.NoteAssets([
-              new import_miden_sdk16.FungibleAsset(assetObj, BigInt(amount))
+            const assets = new NoteAssets([
+              new FungibleAsset(assetObj, BigInt(amount))
             ]);
-            const p2idNote = import_miden_sdk16.Note.createP2IDNote(
+            const p2idNote = Note.createP2IDNote(
               fromId,
               toId,
               assets,
               noteType,
-              new import_miden_sdk16.NoteAttachment()
+              emptyAttachment()
             );
-            const ownOutputs = new import_miden_sdk16.NoteArray();
+            const ownOutputs = new NoteArray();
             ownOutputs.push(p2idNote);
-            const txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(ownOutputs).build();
+            const txRequest = new TransactionRequestBuilder().withOwnOutputNotes(ownOutputs).build();
             const execFromId = parseAccountId(options.from);
             const txId = prover ? await client.submitNewTransactionWithProver(
               execFromId,
               txRequest,
               prover
             ) : await client.submitNewTransaction(execFromId, txRequest);
-            return { txId: txId.toString(), note: p2idNote };
+            return { txId: txId.toHex(), note: p2idNote };
           });
           setStage("complete");
           setResult(returnResult);
@@ -2308,17 +2261,17 @@ function useSend() {
           let txRequest;
           if (hasAttachment) {
             const attachment = createNoteAttachment(options.attachment);
-            const assets = new import_miden_sdk16.NoteAssets([
-              new import_miden_sdk16.FungibleAsset(assetIdObj, amount)
+            const assets = new NoteAssets([
+              new FungibleAsset(assetIdObj, amount)
             ]);
-            const note = import_miden_sdk16.Note.createP2IDNote(
+            const note = Note.createP2IDNote(
               fromAccountId,
               toAccountId,
               assets,
               noteType,
               attachment
             );
-            txRequest = new import_miden_sdk16.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk16.NoteArray([note])).build();
+            txRequest = new TransactionRequestBuilder().withOwnOutputNotes(new NoteArray([note])).build();
           } else {
             txRequest = await client.newSendTransactionRequest(
               fromAccountId,
@@ -2346,15 +2299,14 @@ function useSend() {
           () => client.submitProvenTransaction(provenTransaction, txResult)
         );
         const txIdHex = txResult.id().toHex();
-        const txIdString = txResult.id().toString();
         let fullNote = null;
-        if (noteType === import_miden_sdk16.NoteType.Private) {
+        if (noteType === NoteType2.Private) {
           fullNote = extractFullNote(txResult);
         }
         await runExclusiveSafe(
           () => client.applyTransaction(txResult, submissionHeight)
         );
-        if (noteType === import_miden_sdk16.NoteType.Private) {
+        if (noteType === NoteType2.Private) {
           if (!fullNote) {
             throw new Error("Missing full note for private send");
           }
@@ -2370,7 +2322,7 @@ function useSend() {
           );
         }
         const sendResult = {
-          txId: txIdString,
+          txId: txIdHex,
           note: null
         };
         setStage("complete");
@@ -2389,7 +2341,7 @@ function useSend() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react14.useCallback)(() => {
+  const reset = useCallback12(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2416,16 +2368,23 @@ function extractFullNote(txResult) {
 }
 
 // src/hooks/useMultiSend.ts
-var import_react15 = require("react");
-var import_miden_sdk17 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback13, useRef as useRef5, useState as useState11 } from "react";
+import {
+  FungibleAsset as FungibleAsset2,
+  Note as Note2,
+  NoteAssets as NoteAssets2,
+  NoteType as NoteType3,
+  NoteArray as NoteArray2,
+  TransactionRequestBuilder as TransactionRequestBuilder2
+} from "@miden-sdk/miden-sdk/mt";
 function useMultiSend() {
   const { client, isReady, sync, prover, signerConnected } = useMiden();
-  const isBusyRef = (0, import_react15.useRef)(false);
-  const [result, setResult] = (0, import_react15.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react15.useState)(false);
-  const [stage, setStage] = (0, import_react15.useState)("idle");
-  const [error, setError] = (0, import_react15.useState)(null);
-  const sendMany = (0, import_react15.useCallback)(
+  const isBusyRef = useRef5(false);
+  const [result, setResult] = useState11(null);
+  const [isLoading, setIsLoading] = useState11(false);
+  const [stage, setStage] = useState11("idle");
+  const [error, setError] = useState11(null);
+  const sendMany = useCallback13(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2454,12 +2413,12 @@ function useMultiSend() {
             const iterSenderId = parseAccountId(options.from);
             const iterAssetId = parseAccountId(options.assetId);
             const receiverId = parseAccountId(to);
-            const assets = new import_miden_sdk17.NoteAssets([
-              new import_miden_sdk17.FungibleAsset(iterAssetId, BigInt(amount))
+            const assets = new NoteAssets2([
+              new FungibleAsset2(iterAssetId, BigInt(amount))
             ]);
             const resolvedNoteType = recipientNoteType ? getNoteType(recipientNoteType) : noteType;
-            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : new import_miden_sdk17.NoteAttachment();
-            const note = import_miden_sdk17.Note.createP2IDNote(
+            const noteAttachment = attachment !== void 0 && attachment !== null ? createNoteAttachment(attachment) : emptyAttachment();
+            const note = Note2.createP2IDNote(
               iterSenderId,
               receiverId,
               assets,
@@ -2474,7 +2433,11 @@ function useMultiSend() {
             };
           }
         );
-        const txRequest = new import_miden_sdk17.TransactionRequestBuilder().withOwnOutputNotes(new import_miden_sdk17.NoteArray(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");
@@ -2491,9 +2454,8 @@ 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 === import_miden_sdk17.NoteType.Private);
+        const hasPrivate = outputs.some((o) => o.noteType === NoteType3.Private);
         if (hasPrivate) {
           await waitForTransactionCommit(
             client,
@@ -2501,7 +2463,7 @@ function useMultiSend() {
             txIdHex
           );
           for (const output of outputs) {
-            if (output.noteType === import_miden_sdk17.NoteType.Private) {
+            if (output.noteType === NoteType3.Private) {
               await client.sendPrivateNote(
                 output.note,
                 output.recipientAddress
@@ -2509,7 +2471,7 @@ function useMultiSend() {
             }
           }
         }
-        const txSummary = { transactionId: txIdString };
+        const txSummary = { transactionId: txIdHex };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -2526,7 +2488,7 @@ function useMultiSend() {
     },
     [client, isReady, prover, signerConnected, sync]
   );
-  const reset = (0, import_react15.useCallback)(() => {
+  const reset = useCallback13(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2543,11 +2505,11 @@ function useMultiSend() {
 }
 
 // src/hooks/useWaitForCommit.ts
-var import_react16 = require("react");
-var import_miden_sdk18 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback14 } from "react";
+import { TransactionFilter as TransactionFilter3 } from "@miden-sdk/miden-sdk/mt";
 function useWaitForCommit() {
   const { client, isReady } = useMiden();
-  const waitForCommit = (0, import_react16.useCallback)(
+  const waitForCommit = useCallback14(
     async (txId, options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2561,7 +2523,7 @@ function useWaitForCommit() {
       while (Date.now() < deadline) {
         await client.syncState();
         const records = await client.getTransactions(
-          typeof txId === "string" ? import_miden_sdk18.TransactionFilter.all() : import_miden_sdk18.TransactionFilter.ids([txId])
+          typeof txId === "string" ? TransactionFilter3.all() : TransactionFilter3.ids([txId])
         );
         const record = records.find(
           (item) => normalizeHex3(item.id().toHex()) === targetHex
@@ -2590,11 +2552,11 @@ function normalizeHex3(value) {
 }
 
 // src/hooks/useWaitForNotes.ts
-var import_react17 = require("react");
+import { useCallback as useCallback15 } from "react";
 function useWaitForNotes() {
   const { client, isReady, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const waitForConsumableNotes = (0, import_react17.useCallback)(
+  const waitForConsumableNotes = useCallback15(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2625,15 +2587,15 @@ function useWaitForNotes() {
 }
 
 // src/hooks/useMint.ts
-var import_react18 = require("react");
+import { useCallback as useCallback16, useState as useState12 } from "react";
 function useMint() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react18.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react18.useState)(false);
-  const [stage, setStage] = (0, import_react18.useState)("idle");
-  const [error, setError] = (0, import_react18.useState)(null);
-  const mint = (0, import_react18.useCallback)(
+  const [result, setResult] = useState12(null);
+  const [isLoading, setIsLoading] = useState12(false);
+  const [stage, setStage] = useState12("idle");
+  const [error, setError] = useState12(null);
+  const mint = useCallback16(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2658,7 +2620,7 @@ function useMint() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(faucetIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2675,7 +2637,7 @@ function useMint() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react18.useCallback)(() => {
+  const reset = useCallback16(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2692,16 +2654,16 @@ function useMint() {
 }
 
 // src/hooks/useConsume.ts
-var import_react19 = require("react");
-var import_miden_sdk19 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback17, useState as useState13 } from "react";
+import { NoteFilter as NoteFilter3, NoteFilterTypes as NoteFilterTypes2, NoteId } from "@miden-sdk/miden-sdk/mt";
 function useConsume() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react19.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react19.useState)(false);
-  const [stage, setStage] = (0, import_react19.useState)("idle");
-  const [error, setError] = (0, import_react19.useState)(null);
-  const consume = (0, import_react19.useCallback)(
+  const [result, setResult] = useState13(null);
+  const [isLoading, setIsLoading] = useState13(false);
+  const [stage, setStage] = useState13("idle");
+  const [error, setError] = useState13(null);
+  const consume = useCallback17(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2723,7 +2685,7 @@ function useConsume() {
             const item = options.notes[i];
             if (typeof item === "string") {
               lookupIndices.push(i);
-              lookupIds.push(import_miden_sdk19.NoteId.fromHex(item));
+              lookupIds.push(NoteId.fromHex(item));
             } else if (item !== null && typeof item === "object" && typeof item.toNote === "function") {
               resolved[i] = item.toNote();
             } else if (item !== null && typeof item === "object" && typeof item.id === "function") {
@@ -2734,16 +2696,25 @@ function useConsume() {
             }
           }
           if (lookupIds.length > 0) {
-            const filter = new import_miden_sdk19.NoteFilter(import_miden_sdk19.NoteFilterTypes.List, lookupIds);
+            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"
@@ -2759,7 +2730,7 @@ function useConsume() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2776,7 +2747,7 @@ function useConsume() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react19.useCallback)(() => {
+  const reset = useCallback17(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2793,15 +2764,15 @@ function useConsume() {
 }
 
 // src/hooks/useSwap.ts
-var import_react20 = require("react");
+import { useCallback as useCallback18, useState as useState14 } from "react";
 function useSwap() {
   const { client, isReady, sync, runExclusive, prover } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const [result, setResult] = (0, import_react20.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react20.useState)(false);
-  const [stage, setStage] = (0, import_react20.useState)("idle");
-  const [error, setError] = (0, import_react20.useState)(null);
-  const swap = (0, import_react20.useCallback)(
+  const [result, setResult] = useState14(null);
+  const [isLoading, setIsLoading] = useState14(false);
+  const [stage, setStage] = useState14("idle");
+  const [error, setError] = useState14(null);
+  const swap = useCallback18(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2833,7 +2804,7 @@ function useSwap() {
             txRequest,
             prover
           ) : await client.submitNewTransaction(accountIdObj, txRequest);
-          return { transactionId: txId.toString() };
+          return { transactionId: txId.toHex() };
         });
         setStage("complete");
         setResult(txResult);
@@ -2850,7 +2821,7 @@ function useSwap() {
     },
     [client, isReady, prover, runExclusive, sync]
   );
-  const reset = (0, import_react20.useCallback)(() => {
+  const reset = useCallback18(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -2866,17 +2837,237 @@ 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
-var import_react21 = require("react");
+import { useCallback as useCallback22, useRef as useRef6, useState as useState18 } from "react";
 
 // src/utils/transactions.ts
-var import_miden_sdk20 = require("@miden-sdk/miden-sdk");
+import { NoteType as NoteType4, TransactionFilter as TransactionFilter4 } from "@miden-sdk/miden-sdk/mt";
 async function waitForTransactionCommit2(client, runExclusiveSafe, txId, maxWaitMs = 1e4, delayMs = 1e3) {
   let waited = 0;
   while (waited < maxWaitMs) {
     await runExclusiveSafe(() => client.syncState());
     const [record] = await runExclusiveSafe(
-      () => client.getTransactions(import_miden_sdk20.TransactionFilter.ids([txId]))
+      () => client.getTransactions(TransactionFilter4.ids([txId]))
     );
     if (record) {
       const status = record.transactionStatus();
@@ -2898,7 +3089,7 @@ function extractFullNotes(txResult) {
     const notes = executedTx?.outputNotes?.().notes?.() ?? [];
     const result = [];
     for (const note of notes) {
-      if (note.noteType?.() === import_miden_sdk20.NoteType.Private) {
+      if (note.noteType?.() === NoteType4.Private) {
         const full = note.intoFull?.();
         if (full) result.push(full);
       }
@@ -2913,12 +3104,12 @@ function extractFullNotes(txResult) {
 function useTransaction() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = (0, import_react21.useRef)(false);
-  const [result, setResult] = (0, import_react21.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react21.useState)(false);
-  const [stage, setStage] = (0, import_react21.useState)("idle");
-  const [error, setError] = (0, import_react21.useState)(null);
-  const execute = (0, import_react21.useCallback)(
+  const isBusyRef = useRef6(false);
+  const [result, setResult] = useState18(null);
+  const [isLoading, setIsLoading] = useState18(false);
+  const [stage, setStage] = useState18("idle");
+  const [error, setError] = useState18(null);
+  const execute = useCallback22(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -2968,7 +3159,7 @@ function useTransaction() {
             );
           }
         }
-        const txSummary = { transactionId: txId.toString() };
+        const txSummary = { transactionId: txId.toHex() };
         setStage("complete");
         setResult(txSummary);
         await sync();
@@ -2985,7 +3176,7 @@ function useTransaction() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = (0, import_react21.useCallback)(() => {
+  const reset = useCallback22(() => {
     setResult(null);
     setIsLoading(false);
     setStage("idle");
@@ -3008,19 +3199,24 @@ async function resolveRequest(request, client) {
 }
 
 // src/hooks/useExecuteProgram.ts
-var import_react22 = require("react");
-var import_miden_sdk21 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback23, useRef as useRef7, useState as useState19 } from "react";
+import {
+  AdviceInputs,
+  ForeignAccount,
+  ForeignAccountArray,
+  AccountStorageRequirements
+} from "@miden-sdk/miden-sdk/mt";
 function isForeignAccountWrapper(fa) {
   return fa !== null && typeof fa === "object" && "id" in fa && typeof fa.id !== "function";
 }
 function useExecuteProgram() {
   const { client, isReady, sync, runExclusive } = useMiden();
   const runExclusiveSafe = runExclusive ?? runExclusiveDirect;
-  const isBusyRef = (0, import_react22.useRef)(false);
-  const [result, setResult] = (0, import_react22.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react22.useState)(false);
-  const [error, setError] = (0, import_react22.useState)(null);
-  const execute = (0, import_react22.useCallback)(
+  const isBusyRef = useRef7(false);
+  const [result, setResult] = useState19(null);
+  const [isLoading, setIsLoading] = useState19(false);
+  const [error, setError] = useState19(null);
+  const execute = useCallback23(
     async (options) => {
       if (!client || !isReady) {
         throw new Error("Miden client is not ready");
@@ -3040,18 +3236,18 @@ function useExecuteProgram() {
         }
         const programResult = await runExclusiveSafe(async () => {
           const accountIdObj = parseAccountId(options.accountId);
-          const adviceInputs = options.adviceInputs ?? new import_miden_sdk21.AdviceInputs();
+          const adviceInputs = options.adviceInputs ?? new AdviceInputs();
           let foreignAccountsArray;
           if (options.foreignAccounts?.length) {
             const accounts = options.foreignAccounts.map((fa) => {
               const wrapper = isForeignAccountWrapper(fa);
               const id = parseAccountId(wrapper ? fa.id : fa);
-              const storage = wrapper && fa.storage ? fa.storage : new import_miden_sdk21.AccountStorageRequirements();
-              return import_miden_sdk21.ForeignAccount.public(id, storage);
+              const storage = wrapper && fa.storage ? fa.storage : new AccountStorageRequirements();
+              return ForeignAccount.public(id, storage);
             });
-            foreignAccountsArray = new import_miden_sdk21.ForeignAccountArray(accounts);
+            foreignAccountsArray = new ForeignAccountArray(accounts);
           } else {
-            foreignAccountsArray = new import_miden_sdk21.ForeignAccountArray();
+            foreignAccountsArray = new ForeignAccountArray();
           }
           const feltArray = await client.executeProgram(
             accountIdObj,
@@ -3079,7 +3275,7 @@ function useExecuteProgram() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = (0, import_react22.useCallback)(() => {
+  const reset = useCallback23(() => {
     setResult(null);
     setIsLoading(false);
     setError(null);
@@ -3094,29 +3290,29 @@ function useExecuteProgram() {
 }
 
 // src/hooks/useCompile.ts
-var import_react23 = require("react");
-var import_miden_sdk22 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback24, useMemo as useMemo8 } from "react";
+import { CompilerResource, getWasmOrThrow } from "@miden-sdk/miden-sdk/mt";
 function useCompile() {
   const { client, isReady } = useMiden();
-  const resource = (0, import_react23.useMemo)(
-    () => client && isReady ? new import_miden_sdk22.CompilerResource(client, import_miden_sdk22.getWasmOrThrow) : null,
+  const resource = useMemo8(
+    () => client && isReady ? new CompilerResource(client, getWasmOrThrow) : null,
     [client, isReady]
   );
-  const requireResource = (0, import_react23.useCallback)(() => {
+  const requireResource = useCallback24(() => {
     if (!resource) {
       throw new Error("Miden client is not ready");
     }
     return resource;
   }, [resource]);
-  const component = (0, import_react23.useCallback)(
+  const component = useCallback24(
     async (options) => requireResource().component(options),
     [requireResource]
   );
-  const txScript = (0, import_react23.useCallback)(
+  const txScript = useCallback24(
     async (options) => requireResource().txScript(options),
     [requireResource]
   );
-  const noteScript = (0, import_react23.useCallback)(
+  const noteScript = useCallback24(
     async (options) => requireResource().noteScript(options),
     [requireResource]
   );
@@ -3124,25 +3320,25 @@ function useCompile() {
 }
 
 // src/hooks/useSessionAccount.ts
-var import_react24 = require("react");
-var import_miden_sdk23 = require("@miden-sdk/miden-sdk");
+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";
 function useSessionAccount(options) {
   const { client, isReady, sync } = useMiden();
   const setAccounts = useMidenStore((state) => state.setAccounts);
-  const [sessionAccountId, setSessionAccountId] = (0, import_react24.useState)(null);
-  const [step, setStep] = (0, import_react24.useState)("idle");
-  const [error, setError] = (0, import_react24.useState)(null);
-  const cancelledRef = (0, import_react24.useRef)(false);
-  const isBusyRef = (0, import_react24.useRef)(false);
+  const [sessionAccountId, setSessionAccountId] = useState20(null);
+  const [step, setStep] = useState20("idle");
+  const [error, setError] = useState20(null);
+  const cancelledRef = useRef8(false);
+  const isBusyRef = useRef8(false);
   const storagePrefix = options.storagePrefix ?? "miden-session";
   const pollIntervalMs = options.pollIntervalMs ?? 3e3;
   const maxWaitMs = options.maxWaitMs ?? 6e4;
   const storageMode = options.walletOptions?.storageMode ?? "public";
   const mutable = options.walletOptions?.mutable ?? DEFAULTS.WALLET_MUTABLE;
   const authScheme = options.walletOptions?.authScheme ?? DEFAULTS.AUTH_SCHEME;
-  const fundRef = (0, import_react24.useRef)(options.fund);
+  const fundRef = useRef8(options.fund);
   fundRef.current = options.fund;
-  (0, import_react24.useEffect)(() => {
+  useEffect9(() => {
     try {
       const stored = localStorage.getItem(`${storagePrefix}:accountId`);
       const storedReady = localStorage.getItem(`${storagePrefix}:ready`);
@@ -3159,7 +3355,7 @@ function useSessionAccount(options) {
       localStorage.removeItem(`${storagePrefix}:ready`);
     }
   }, [storagePrefix]);
-  const initialize = (0, import_react24.useCallback)(async () => {
+  const initialize = useCallback25(async () => {
     if (!client || !isReady) {
       throw new Error("Miden client is not ready");
     }
@@ -3228,7 +3424,7 @@ function useSessionAccount(options) {
     maxWaitMs,
     setAccounts
   ]);
-  const reset = (0, import_react24.useCallback)(() => {
+  const reset = useCallback25(() => {
     cancelledRef.current = true;
     isBusyRef.current = false;
     setSessionAccountId(null);
@@ -3249,11 +3445,11 @@ function useSessionAccount(options) {
 function getStorageMode3(mode) {
   switch (mode) {
     case "private":
-      return import_miden_sdk23.AccountStorageMode.private();
+      return AccountStorageMode3.private();
     case "public":
-      return import_miden_sdk23.AccountStorageMode.public();
+      return AccountStorageMode3.public();
     default:
-      return import_miden_sdk23.AccountStorageMode.public();
+      return AccountStorageMode3.public();
   }
 }
 async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cancelledRef) {
@@ -3277,13 +3473,13 @@ async function waitAndConsume(client, walletId, pollIntervalMs, maxWaitMs, cance
 }
 
 // src/hooks/useExportStore.ts
-var import_react25 = require("react");
-var import_miden_sdk24 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback26, useState as useState21 } from "react";
+import { exportStore as sdkExportStore } from "@miden-sdk/miden-sdk/mt";
 function useExportStore() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = (0, import_react25.useState)(false);
-  const [error, setError] = (0, import_react25.useState)(null);
-  const exportStore = (0, import_react25.useCallback)(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");
     }
@@ -3291,7 +3487,7 @@ function useExportStore() {
     setError(null);
     try {
       const storeName = await client.storeIdentifier();
-      const snapshot = await runExclusive(() => (0, import_miden_sdk24.exportStore)(storeName));
+      const snapshot = await runExclusive(() => sdkExportStore(storeName));
       return snapshot;
     } catch (err) {
       const error2 = err instanceof Error ? err : new Error(String(err));
@@ -3301,7 +3497,7 @@ function useExportStore() {
       setIsExporting(false);
     }
   }, [client, isReady, runExclusive]);
-  const reset = (0, import_react25.useCallback)(() => {
+  const reset = useCallback26(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3314,13 +3510,13 @@ function useExportStore() {
 }
 
 // src/hooks/useImportStore.ts
-var import_react26 = require("react");
-var import_miden_sdk25 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback27, useState as useState22 } from "react";
+import { importStore as sdkImportStore } from "@miden-sdk/miden-sdk/mt";
 function useImportStore() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = (0, import_react26.useState)(false);
-  const [error, setError] = (0, import_react26.useState)(null);
-  const importStore = (0, import_react26.useCallback)(
+  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");
@@ -3328,7 +3524,7 @@ function useImportStore() {
       setIsImporting(true);
       setError(null);
       try {
-        await runExclusive(() => (0, import_miden_sdk25.importStore)(storeName, storeDump));
+        await runExclusive(() => sdkImportStore(storeName, storeDump));
         if (!options?.skipSync) {
           await sync();
         }
@@ -3342,7 +3538,7 @@ function useImportStore() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = (0, import_react26.useCallback)(() => {
+  const reset = useCallback27(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3355,13 +3551,13 @@ function useImportStore() {
 }
 
 // src/hooks/useImportNote.ts
-var import_react27 = require("react");
-var import_miden_sdk26 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback28, useState as useState23 } from "react";
+import { NoteFile } from "@miden-sdk/miden-sdk/mt";
 function useImportNote() {
   const { client, isReady, runExclusive, sync } = useMiden();
-  const [isImporting, setIsImporting] = (0, import_react27.useState)(false);
-  const [error, setError] = (0, import_react27.useState)(null);
-  const importNote = (0, import_react27.useCallback)(
+  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");
@@ -3369,7 +3565,7 @@ function useImportNote() {
       setIsImporting(true);
       setError(null);
       try {
-        const noteFile = import_miden_sdk26.NoteFile.deserialize(noteBytes);
+        const noteFile = NoteFile.deserialize(noteBytes);
         const noteId = await runExclusive(
           () => client.importNoteFile(noteFile)
         );
@@ -3385,7 +3581,7 @@ function useImportNote() {
     },
     [client, isReady, runExclusive, sync]
   );
-  const reset = (0, import_react27.useCallback)(() => {
+  const reset = useCallback28(() => {
     setIsImporting(false);
     setError(null);
   }, []);
@@ -3398,13 +3594,13 @@ function useImportNote() {
 }
 
 // src/hooks/useExportNote.ts
-var import_react28 = require("react");
-var import_miden_sdk27 = require("@miden-sdk/miden-sdk");
+import { useCallback as useCallback29, useState as useState24 } from "react";
+import { NoteExportFormat } from "@miden-sdk/miden-sdk/mt";
 function useExportNote() {
   const { client, isReady, runExclusive } = useMiden();
-  const [isExporting, setIsExporting] = (0, import_react28.useState)(false);
-  const [error, setError] = (0, import_react28.useState)(null);
-  const exportNote = (0, import_react28.useCallback)(
+  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");
@@ -3413,7 +3609,7 @@ function useExportNote() {
       setError(null);
       try {
         const noteFile = await runExclusive(
-          () => client.exportNoteFile(noteId, import_miden_sdk27.NoteExportFormat.Full)
+          () => client.exportNoteFile(noteId, NoteExportFormat.Full)
         );
         return noteFile.serialize();
       } catch (err) {
@@ -3426,7 +3622,7 @@ function useExportNote() {
     },
     [client, isReady, runExclusive]
   );
-  const reset = (0, import_react28.useCallback)(() => {
+  const reset = useCallback29(() => {
     setIsExporting(false);
     setError(null);
   }, []);
@@ -3439,12 +3635,12 @@ function useExportNote() {
 }
 
 // src/hooks/useSyncControl.ts
-var import_react29 = require("react");
+import { useCallback as useCallback30 } from "react";
 function useSyncControl() {
   const isPaused = useMidenStore((state) => state.syncPaused);
   const setSyncPaused = useMidenStore((state) => state.setSyncPaused);
-  const pauseSync = (0, import_react29.useCallback)(() => setSyncPaused(true), [setSyncPaused]);
-  const resumeSync = (0, import_react29.useCallback)(() => setSyncPaused(false), [setSyncPaused]);
+  const pauseSync = useCallback30(() => setSyncPaused(true), [setSyncPaused]);
+  const resumeSync = useCallback30(() => setSyncPaused(false), [setSyncPaused]);
   return {
     pauseSync,
     resumeSync,
@@ -3601,8 +3797,7 @@ function createMidenStorage(prefix) {
 
 // src/index.ts
 installAccountBech32();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   AuthScheme,
   DEFAULTS,
   MidenError,
@@ -3647,6 +3842,9 @@ installAccountBech32();
   useMultiSigner,
   useNoteStream,
   useNotes,
+  usePswapCancel,
+  usePswapConsume,
+  usePswapCreate,
   useSend,
   useSessionAccount,
   useSigner,
@@ -3659,4 +3857,4 @@ installAccountBech32();
   useWaitForNotes,
   waitForWalletDetection,
   wrapWasmError
-});
+};