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

package/CLAUDE.md

@@ -409,6 +409,9 @@ Query hooks return `{ ...data, isLoading, error, refetch }`. Mutation hooks retu
 | `useMint()` | `mint({ faucetId, to, amount })` | `TransactionResult` |
 | `useConsume()` | `consume({ accountId, notes })` | `TransactionResult` |
 | `useSwap()` | `swap({ ... })` | `TransactionResult` |
+| `usePswapCreate()` | `pswapCreate({ accountId, offeredFaucetId, offeredAmount, requestedFaucetId, requestedAmount, ... })` | `TransactionResult` (creates partial-swap note) |
+| `usePswapConsume()` | `pswapConsume({ accountId, note, fillAmount, noteFillAmount? })` — `note` accepts hex string \| `NoteId` \| `InputNoteRecord` \| `Note` | `TransactionResult` (fills PSWAP fully or partially) |
+| `usePswapCancel()` | `pswapCancel({ accountId, note })` — creator only, reclaims unfilled offered asset | `TransactionResult` |
 | `useTransaction()` | `transact({ ... })` | `TransactionResult` (custom tx) |
 | `useExecuteProgram()` | `execute(...)` | program output |
 | `useCompile()` | `compile({ source })` | `{ component, txScript, noteScript }` |

package/README.md

@@ -22,8 +22,6 @@ React hooks library for the Miden Web Client. Provides a simple, ergonomic inter
 npm install @miden-sdk/react @miden-sdk/miden-sdk
 # or
 pnpm add @miden-sdk/react @miden-sdk/miden-sdk
-# or
-pnpm add @miden-sdk/react @miden-sdk/miden-sdk
 ```
 
 ## Testing
@@ -119,14 +117,25 @@ function App() {
 }
 ```
 
-## Next.js & SSR
+## Subpaths: Eager / Lazy × ST / MT
+
+The React SDK ships **four** bundle variants built from a single source tree. The two axes are independent:
+
+- **WASM init timing** — _eager_ awaits at SDK load (TLA); _lazy_ leaves init to `MidenClient.ready()` or first awaiting method.
+- **WASM threading model** — _ST_ (single-threaded) loads anywhere; _MT_ (multi-threaded via `wasm-bindgen-rayon`) parallelizes proving but **requires the page to be cross-origin-isolated**.
+
+| Subpath                            | SDK variant                       | When to use                                                |
+| ---------------------------------- | --------------------------------- | ---------------------------------------------------------- |
+| `@miden-sdk/react`                 | eager + ST                        | Plain browser apps, Vite, CRA, esbuild — no host control needed. |
+| `@miden-sdk/react/lazy`            | lazy + ST                         | Next.js / SSR, Capacitor (iOS/Android WKWebView).          |
+| `@miden-sdk/react/mt`              | eager + MT                        | dApps with COOP/COEP set; want fast proving and tolerate TLA. |
+| `@miden-sdk/react/mt/lazy`         | lazy + MT                         | dApps with COOP/COEP set, on Next.js or anywhere TLA can't run. |
 
-The React SDK is Next.js-compatible out of the box: it ships two bundle variants built from a single source tree, and both internally import `@miden-sdk/miden-sdk/lazy` — the lazy entry point that does **not** use a top-level `await`. Nothing initializes WASM at module evaluation, so server-side rendering never hangs.
+All four exports have identical APIs. The choice affects which `@miden-sdk/miden-sdk` variant your bundler resolves and therefore the underlying WASM behavior.
 
-- Default (`@miden-sdk/react`) — internally consumes the eager SDK. Use this in plain browser apps, Vite, CRA.
-- `@miden-sdk/react/lazy` — internally consumes the lazy SDK. Use this in Next.js (app router or pages), SSR, or inside a Capacitor iOS/Android WKWebView host (the wallet shell uses this).
+### Next.js / SSR
 
-Both exports have identical APIs. The choice only affects which `@miden-sdk/miden-sdk` variant your bundler ends up resolving.
+The lazy variants (`/lazy`, `/mt/lazy`) do not run a top-level `await` at module evaluation. Server-side rendering never hangs on WASM init. Use these in any Next.js app or Capacitor host:
 
 ```tsx
 // Next.js: app/providers.tsx
@@ -141,6 +150,50 @@ export function Providers({ children }: { children: React.ReactNode }) {
 
 `MidenProvider` gates child rendering on `isReady`, so you don't have to await anything manually in components — hooks already fire only after WASM is initialized.
 
+### Multi-threaded proving (`/mt`, `/mt/lazy`)
+
+The MT variants enable `wasm-bindgen-rayon` for ~3–5× faster local proving on commodity laptops. Same API surface as the ST variants. Two extra requirements compared to ST:
+
+**1. The page must be cross-origin-isolated.** Set the host response headers:
+
+```
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
+```
+
+Without those, the browser refuses to construct `WebAssembly.Memory({ shared: true })` and the MT WASM fails to instantiate at SDK load. See the underlying [`@miden-sdk/miden-sdk` README](https://github.com/0xMiden/web-sdk/blob/main/crates/web-client/README.md#setting-cross-origin-isolation-headers) for snippets per host (Vite, Next.js, Express, browser-extension manifests). COEP also blocks cross-origin resources unless they carry CORP / proper CORS — opt in deliberately.
+
+**2. Bring up the rayon thread pool once at startup.** Re-exported as `initThreadPool(n)`. The React SDK does NOT call this for you — consumers must `await` it before the first transaction:
+
+```tsx
+"use client";
+import { useEffect } from "react";
+import { MidenProvider, useMiden } from "@miden-sdk/react/mt/lazy";
+import { initThreadPool } from "@miden-sdk/miden-sdk/mt/lazy";
+
+function ThreadPoolBoot() {
+  const { isReady } = useMiden();
+  useEffect(() => {
+    if (!isReady) return;
+    void initThreadPool(navigator.hardwareConcurrency);
+  }, [isReady]);
+  return null;
+}
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <MidenProvider config={{ rpcUrl: "testnet" }}>
+      <ThreadPoolBoot />
+      {children}
+    </MidenProvider>
+  );
+}
+```
+
+`initThreadPool` is idempotent — calling it multiple times resolves with the existing pool. Without this call, the rayon global thread pool spawns zero workers on `wasm32` and every `par_iter(...)` falls through to a sequential loop. You'd be shipping multi-threaded WASM that runs single-threaded.
+
+If you can't satisfy the COI requirement (third-party host, CDN that won't set headers), stay on the default `@miden-sdk/react` / `/lazy` subpaths — they ship the ST WASM and load anywhere.
+
 ### Constructing wasm-bindgen types directly in Next.js
 
 Hooks accept strings for account IDs, asset IDs, and note IDs (auto-detecting hex vs. bech32) and parse them internally inside async callbacks, so **most apps never touch wasm-bindgen types directly**. If you do need to (e.g. to inspect an ID's prefix/suffix, validate a pasted string, or use a low-level API like `new Felt(…)`), import from `@miden-sdk/miden-sdk/lazy` and gate the call on `isReady`:
@@ -966,6 +1019,92 @@ function SwapForm() {
 }
 ```
 
+#### `usePswapCreate()`
+
+Create a partial-swap (PSWAP) note. Unlike `useSwap`, a PSWAP can be filled by
+multiple consumers — each fill emits a payback note to the creator and, on a
+partial fill, a remainder PSWAP note carrying the unfilled portion. Use this
+when you want an offer that lives on-chain and can be matched piecemeal.
+
+```tsx
+import { usePswapCreate } from '@miden-sdk/react';
+
+function CreatePswapForm() {
+  const { pswapCreate, isLoading, stage } = usePswapCreate();
+
+  const handleCreate = async () => {
+    await pswapCreate({
+      accountId: '0xmywallet...',
+      offeredFaucetId: '0xtokenA...',
+      offeredAmount: 100n,
+      requestedFaucetId: '0xtokenB...',
+      requestedAmount: 50n,
+      // noteType, paybackNoteType — default 'private'
+    });
+  };
+
+  return (
+    <button onClick={handleCreate} disabled={isLoading}>
+      {isLoading ? `Creating PSWAP (${stage})...` : 'Create PSWAP'}
+    </button>
+  );
+}
+```
+
+#### `usePswapConsume()`
+
+Fill an existing PSWAP note in whole or in part. The consumer supplies
+`fillAmount` of the requested asset and receives a proportional share of the
+offered asset. The `note` field accepts a hex string ID, a `NoteId` object,
+an `InputNoteRecord`, or a `Note` — strings and `NoteId`s are looked up from
+the local store; records and `Note`s are used directly.
+
+```tsx
+import { usePswapConsume } from '@miden-sdk/react';
+
+function FillPswapButton({ accountId, note }: Props) {
+  const { pswapConsume, isLoading, stage } = usePswapConsume();
+
+  const handleFill = async () => {
+    await pswapConsume({
+      accountId,
+      note, // string | NoteId | InputNoteRecord | Note
+      fillAmount: 25n,
+    });
+  };
+
+  return (
+    <button onClick={handleFill} disabled={isLoading}>
+      {isLoading ? stage : 'Fill PSWAP'}
+    </button>
+  );
+}
+```
+
+#### `usePswapCancel()`
+
+Cancel a PSWAP note as its creator and reclaim the unfilled offered asset.
+The submitting account must be the original creator; the WASM builder
+enforces this at request-build time.
+
+```tsx
+import { usePswapCancel } from '@miden-sdk/react';
+
+function CancelPswapButton({ accountId, note }: Props) {
+  const { pswapCancel, isLoading, stage } = usePswapCancel();
+
+  const handleCancel = async () => {
+    await pswapCancel({ accountId, note });
+  };
+
+  return (
+    <button onClick={handleCancel} disabled={isLoading}>
+      {isLoading ? stage : 'Cancel PSWAP'}
+    </button>
+  );
+}
+```
+
 #### `useTransaction()`
 
 Execute a custom `TransactionRequest` or build one with the client. This is the

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { AccountId, Account, AccountHeader, AccountStorageMode, AccountComponent, NoteId, InputNoteRecord, Note, StorageMode, AuthScheme, TransactionScript, AdviceInputs, AccountStorageRequirements, TransactionRequest, WasmWebClient, AccountFile, NoteVisibility, ConsumableNoteRecord, TransactionId, TransactionFilter, TransactionRecord, TransactionProver, CompileComponentOptions, CompileTxScriptOptions, CompileNoteScriptOptions, NoteScript, NoteAttachment } from '@miden-sdk/miden-sdk';
+import { AccountId, Account, AccountHeader, AccountStorageMode, AccountComponent, NoteId, InputNoteRecord, Note, StorageMode, AuthScheme, TransactionScript, AdviceInputs, AccountStorageRequirements, TransactionRequest, WasmWebClient, AccountFile, NoteVisibility, ConsumableNoteRecord, NoteInput, TransactionId, TransactionFilter, TransactionRecord, TransactionProver, CompileComponentOptions, CompileTxScriptOptions, CompileNoteScriptOptions, NoteScript, NoteAttachment } from '@miden-sdk/miden-sdk';
 export { Account, AccountFile, AccountHeader, AccountId, AccountStorageMode, AuthScheme, ConsumableNoteRecord, InputNoteRecord, Note, NoteType, TransactionFilter, TransactionId, TransactionRecord, TransactionRequest, WasmWebClient as WebClient } from '@miden-sdk/miden-sdk';
 
 declare module "@miden-sdk/miden-sdk" {
@@ -150,6 +150,22 @@ interface MidenConfig {
     proverUrls?: ProverUrls;
     /** Default timeout for remote prover requests in milliseconds. */
     proverTimeoutMs?: number | bigint;
+    /**
+     * Enable the Web Worker shim that runs WASM calls off the main thread.
+     * Defaults to `true` — leave it that way in browsers/extensions so the UI
+     * stays responsive while WASM is busy.
+     *
+     * Set to `false` when:
+     * - You pass a `CallbackProver` (e.g. a native iOS/Android prover via
+     *   a Capacitor plugin). The worker boundary serializes the prover with
+     *   `TransactionProver.serialize()`, which has no encoding for the
+     *   callback variant and silently downgrades to `"local"` — your
+     *   callback would never fire.
+     * - You're embedding the client in a single-WebView native shell
+     *   (Capacitor host, Tauri, Electron preload), where the UI thread
+     *   isn't competing with the WASM thread anyway.
+     */
+    useWorker?: boolean;
 }
 interface MidenState {
     client: WasmWebClient | null;
@@ -267,6 +283,8 @@ interface CreateWalletOptions {
 interface CreateFaucetOptions {
     /** Token symbol (e.g., "TEST") */
     tokenSymbol: string;
+    /** Human-readable token name. Defaults to `tokenSymbol` when omitted. */
+    tokenName?: string;
     /** Number of decimals. Default: 8 */
     decimals?: number;
     /** Maximum supply */
@@ -386,6 +404,54 @@ interface SwapOptions {
     /** Note type for payback note. Default: private */
     paybackNoteType?: NoteVisibility;
 }
+interface PswapCreateOptions {
+    /** Account that creates the PSWAP note */
+    accountId: AccountRef;
+    /** Faucet ID of the offered asset */
+    offeredFaucetId: AccountRef;
+    /** Amount being offered */
+    offeredAmount: bigint | number;
+    /** Faucet ID of the requested asset */
+    requestedFaucetId: AccountRef;
+    /** Amount being requested */
+    requestedAmount: bigint | number;
+    /** Visibility of the PSWAP note. Default: private */
+    noteType?: NoteVisibility;
+    /** Visibility of the payback note. Default: private */
+    paybackNoteType?: NoteVisibility;
+}
+interface PswapConsumeOptions {
+    /** Consumer account filling the PSWAP note */
+    accountId: AccountRef;
+    /**
+     * PSWAP note to consume. Accepts a hex string ID, `NoteId` object,
+     * `InputNoteRecord`, or `Note` — string/NoteId values are looked up from
+     * the local store; record/Note values are used directly.
+     */
+    note: NoteInput;
+    /**
+     * Amount of the requested asset the consumer is providing from its own
+     * vault. Receives a proportional share of the offered asset; partial fills
+     * also produce a remainder PSWAP note carrying the unfilled portion.
+     */
+    fillAmount: bigint | number;
+    /**
+     * Amount of the requested asset supplied by other (in-flight) notes routed
+     * into the same transaction. Defaults to `0`; most callers should leave
+     * this unset.
+     */
+    noteFillAmount?: bigint | number;
+}
+interface PswapCancelOptions {
+    /** Creator account reclaiming the offered asset */
+    accountId: AccountRef;
+    /**
+     * PSWAP note to cancel. Accepts a hex string ID, `NoteId` object,
+     * `InputNoteRecord`, or `Note` — string/NoteId values are looked up from
+     * the local store; record/Note values are used directly.
+     */
+    note: NoteInput;
+}
 interface ExecuteTransactionOptions {
     /** Account ID the transaction applies to */
     accountId: AccountRef;
@@ -1101,6 +1167,128 @@ interface UseSwapResult {
  */
 declare function useSwap(): UseSwapResult;
 
+interface UsePswapCreateResult {
+    /** Create a partial-swap (PSWAP) note */
+    pswapCreate: (options: PswapCreateOptions) => Promise<TransactionResult>;
+    /** The transaction result */
+    result: TransactionResult | null;
+    /** Whether the transaction is in progress */
+    isLoading: boolean;
+    /** Current stage of the transaction */
+    stage: TransactionStage;
+    /** Error if transaction failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to create a partial-swap (PSWAP) note. The note can be filled by
+ * multiple consumers; partial fills emit a remainder PSWAP note.
+ *
+ * @example
+ * ```tsx
+ * function CreatePswapButton({ accountId }: { accountId: string }) {
+ *   const { pswapCreate, isLoading, stage, error } = usePswapCreate();
+ *
+ *   const handleCreate = async () => {
+ *     const result = await pswapCreate({
+ *       accountId,
+ *       offeredFaucetId: '0x...',
+ *       offeredAmount: 100n,
+ *       requestedFaucetId: '0x...',
+ *       requestedAmount: 50n,
+ *     });
+ *     console.log('PSWAP created! TX:', result.transactionId);
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isLoading}>
+ *       {isLoading ? stage : 'Create PSWAP'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function usePswapCreate(): UsePswapCreateResult;
+
+interface UsePswapConsumeResult {
+    /** Fill (consume) an existing partial-swap (PSWAP) note */
+    pswapConsume: (options: PswapConsumeOptions) => Promise<TransactionResult>;
+    /** The transaction result */
+    result: TransactionResult | null;
+    /** Whether the transaction is in progress */
+    isLoading: boolean;
+    /** Current stage of the transaction */
+    stage: TransactionStage;
+    /** Error if transaction failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to consume (fully or partially fill) an existing PSWAP note. The
+ * consumer supplies `fillAmount` and receives a proportional share of the
+ * offered asset.
+ *
+ * @example
+ * ```tsx
+ * function FillPswapButton({ accountId, note }: Props) {
+ *   const { pswapConsume, isLoading, stage } = usePswapConsume();
+ *
+ *   const handleFill = async () => {
+ *     await pswapConsume({
+ *       accountId,
+ *       note,
+ *       fillAmount: 25n,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleFill} disabled={isLoading}>
+ *       {isLoading ? stage : 'Fill PSWAP'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function usePswapConsume(): UsePswapConsumeResult;
+
+interface UsePswapCancelResult {
+    /** Cancel a partial-swap (PSWAP) note as the creator */
+    pswapCancel: (options: PswapCancelOptions) => Promise<TransactionResult>;
+    /** The transaction result */
+    result: TransactionResult | null;
+    /** Whether the transaction is in progress */
+    isLoading: boolean;
+    /** Current stage of the transaction */
+    stage: TransactionStage;
+    /** Error if transaction failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to cancel a PSWAP note as the creator and reclaim the offered asset.
+ *
+ * @example
+ * ```tsx
+ * function CancelPswapButton({ accountId, note }: Props) {
+ *   const { pswapCancel, isLoading, stage } = usePswapCancel();
+ *
+ *   const handleCancel = async () => {
+ *     await pswapCancel({ accountId, note });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCancel} disabled={isLoading}>
+ *       {isLoading ? stage : 'Cancel PSWAP'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function usePswapCancel(): UsePswapCancelResult;
+
 interface UseTransactionResult {
     /** Execute a transaction request end-to-end */
     execute: (options: ExecuteTransactionOptions) => Promise<TransactionResult>;
@@ -1417,17 +1605,41 @@ interface NoteAttachmentData {
     kind: "word" | "array";
 }
 /**
- * Decode a note's attachment. Returns null if no attachment.
+ * Decode a note's attachment payload back into the bigint values that
+ * `createNoteAttachment` packed in.
+ *
+ * On the 0.15 protocol surface the full attachment content (the packed words)
+ * lives on the note record (`InputNoteRecord.attachments()`), not on
+ * `NoteMetadata`. This reads the note's first attachment and flattens its
+ * words back into a `bigint[]`, the inverse of `createNoteAttachment`.
+ *
+ * - No attachments → `null`.
+ * - An all-zero payload (regardless of word count) → `null`. This covers the
+ *   placeholder produced by `emptyAttachment()` (a single all-zero word) and
+ *   matches the pre-0.15 behavior where a `None`-kind attachment decoded to
+ *   `null`.
+ * - Otherwise → `{ values, kind }` where `kind` is `"word"` for a single-word
+ *   attachment and `"array"` for multi-word content.
+ *
+ * The returned `values` include the trailing-zero padding `createNoteAttachment`
+ * added to reach word boundaries; consumers that need the original unpadded
+ * values should strip trailing zeros.
  */
 declare function readNoteAttachment(note: InputNoteRecord): NoteAttachmentData | null;
 /**
- * Encode values into a NoteAttachment.
- * <= 4 values -> Word (avoids miden-standards 0.13.x Array advice-map bug).
- * > 4 values -> Array.
- *
- * Note: Values are padded to word boundaries (multiples of 4) with trailing 0n.
- * `readNoteAttachment` returns raw values including padding. Consumers should
- * strip trailing zeros if they need the original unpadded values.
+ * Encode bigint values into a `NoteAttachment`.
+ *
+ * - 0 values → falls back to `emptyAttachment()` (a single zero-Word
+ *   attachment with the `none` scheme). On the 0.15 protocol surface there
+ *   is no native "empty" attachment; this preserves the pre-migration
+ *   "default attachment when caller has no payload" behavior at the cost
+ *   of one trivial word.
+ * - 1..=4 values → padded to 4 elements and wrapped as a single Word via
+ *   `NoteAttachment.fromWord(scheme, word)`.
+ * - >4 values → padded to a multiple of 4, chunked into Words, and wrapped
+ *   via `NoteAttachment.fromWords(scheme, words)`.
+ *
+ * Values are padded to word boundaries (multiples of 4) with trailing `0n`.
  */
 declare function createNoteAttachment(values: bigint[] | Uint8Array | number[]): NoteAttachment;
 
@@ -1496,4 +1708,4 @@ declare function createMidenStorage(prefix: string): {
     clear(): void;
 };
 
-export { type AccountRef, type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type ConsumeOptions, type CreateFaucetOptions, type CreateWalletOptions, DEFAULTS, type ExecuteProgramOptions, type ExecuteProgramResult, type ExecuteTransactionOptions, type ImportAccountOptions, type ImportStoreOptions, type MidenConfig, MidenError, type MidenErrorCode, MidenProvider, type MidenState, type MigrateStorageOptions, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MultiSignerContextValue, MultiSignerProvider, type MutationResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverTarget, type ProverUrls, type QueryResult, type RpcUrlConfig, type SendOptions, type SendResult, type SessionAccountStep, type SignCallback, type SignerAccountConfig, type SignerAccountType, SignerContext, type SignerContextValue, SignerSlot, type StreamedNote, type SwapOptions, type SyncState, type TransactionHistoryOptions, type TransactionHistoryResult, type TransactionResult, type TransactionStage, type TransactionStatus, type UseCompileResult, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateWalletResult, type UseExecuteProgramResult, type UseExportNoteResult, type UseExportStoreResult, type UseImportAccountResult, type UseImportNoteResult, type UseImportStoreResult, type UseMintResult, type UseMultiSendResult, type UseNoteStreamOptions, type UseNoteStreamReturn, type UseSendResult, type UseSessionAccountOptions, type UseSessionAccountReturn, type UseSwapResult, type UseSyncControlResult, type UseSyncStateResult, type UseTransactionHistoryResult, type UseTransactionResult, type UseWaitForCommitResult, type UseWaitForNotesResult, type WaitForCommitOptions, type WaitForNotesOptions, type WalletAdapterLike, accountIdsEqual, bigIntToBytes, bytesToBigInt, clearMidenStorage, concatBytes, createMidenStorage, createNoteAttachment, ensureAccountBech32, formatAssetAmount, formatNoteSummary, getNoteSummary, installAccountBech32, migrateStorage, normalizeAccountId, parseAssetAmount, readNoteAttachment, toBech32AccountId, useAccount, useAccounts, useAssetMetadata, useCompile, useConsume, useCreateFaucet, useCreateWallet, useExecuteProgram, useExportNote, useExportStore, useImportAccount, useImportNote, useImportStore, useMiden, useMidenClient, useMint, useMultiSend, useMultiSigner, useNoteStream, useNotes, useSend, useSessionAccount, useSigner, useSwap, useSyncControl, useSyncState, useTransaction, useTransactionHistory, useWaitForCommit, useWaitForNotes, waitForWalletDetection, wrapWasmError };
+export { type AccountRef, type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type ConsumeOptions, type CreateFaucetOptions, type CreateWalletOptions, DEFAULTS, type ExecuteProgramOptions, type ExecuteProgramResult, type ExecuteTransactionOptions, type ImportAccountOptions, type ImportStoreOptions, type MidenConfig, MidenError, type MidenErrorCode, MidenProvider, type MidenState, type MigrateStorageOptions, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MultiSignerContextValue, MultiSignerProvider, type MutationResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverTarget, type ProverUrls, type PswapCancelOptions, type PswapConsumeOptions, type PswapCreateOptions, type QueryResult, type RpcUrlConfig, type SendOptions, type SendResult, type SessionAccountStep, type SignCallback, type SignerAccountConfig, type SignerAccountType, SignerContext, type SignerContextValue, SignerSlot, type StreamedNote, type SwapOptions, type SyncState, type TransactionHistoryOptions, type TransactionHistoryResult, type TransactionResult, type TransactionStage, type TransactionStatus, type UseCompileResult, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateWalletResult, type UseExecuteProgramResult, type UseExportNoteResult, type UseExportStoreResult, type UseImportAccountResult, type UseImportNoteResult, type UseImportStoreResult, type UseMintResult, type UseMultiSendResult, type UseNoteStreamOptions, type UseNoteStreamReturn, type UsePswapCancelResult, type UsePswapConsumeResult, type UsePswapCreateResult, type UseSendResult, type UseSessionAccountOptions, type UseSessionAccountReturn, type UseSwapResult, type UseSyncControlResult, type UseSyncStateResult, type UseTransactionHistoryResult, type UseTransactionResult, type UseWaitForCommitResult, type UseWaitForNotesResult, type WaitForCommitOptions, type WaitForNotesOptions, type WalletAdapterLike, accountIdsEqual, bigIntToBytes, bytesToBigInt, clearMidenStorage, concatBytes, createMidenStorage, createNoteAttachment, ensureAccountBech32, formatAssetAmount, formatNoteSummary, getNoteSummary, installAccountBech32, migrateStorage, normalizeAccountId, parseAssetAmount, readNoteAttachment, toBech32AccountId, useAccount, useAccounts, useAssetMetadata, useCompile, useConsume, useCreateFaucet, useCreateWallet, useExecuteProgram, useExportNote, useExportStore, useImportAccount, useImportNote, useImportStore, useMiden, useMidenClient, useMint, useMultiSend, useMultiSigner, useNoteStream, useNotes, usePswapCancel, usePswapConsume, usePswapCreate, useSend, useSessionAccount, useSigner, useSwap, useSyncControl, useSyncState, useTransaction, useTransactionHistory, useWaitForCommit, useWaitForNotes, waitForWalletDetection, wrapWasmError };