@miden-sdk/react 0.15.6 → 0.16.0-alpha.1

package/CLAUDE.md

@@ -149,38 +149,6 @@ await mint({
 });
 ```
 
-### Bridge Out (AggLayer)
-```tsx
-const { bridge } = useBridge();
-
-// Emits a public B2AGG note that the bridge account consumes, burning the
-// asset so it can be claimed at the destination Ethereum address.
-await bridge({
-  from: senderAccountId,
-  bridgeAccount: bridgeAccountId,
-  assetId: tokenFaucetId,
-  amount: 100n,
-  destinationNetwork: 1, // AggLayer-assigned network id
-  destinationAddress: "0x000000000000000000000000000000000000dEaD",
-});
-```
-
-### Create a Network Note
-```tsx
-const { createNetworkNote } = useCreateNetworkNote();
-
-// Builds a Public custom-script note carrying a NetworkAccountTarget
-// attachment; the targeted network account auto-consumes it on-chain.
-// Provide exactly one of `script` or `recipient`.
-const { txId, note } = await createNetworkNote({
-  accountId: senderAccountId,
-  target: networkAccountId,
-  script: myNoteScript, // or: recipient: myRecipient
-});
-
-note.isNetworkNote(); // true
-```
-
 ### Create Faucet
 ```tsx
 const { createFaucet } = useCreateFaucet();
@@ -426,9 +394,6 @@ Query hooks return `{ ...data, isLoading, error, refetch }`. Mutation hooks retu
 | `useTransactionHistory(...)` | `transactions` | Local transaction log |
 | `useSessionAccount()` | `account` | The signer's connected account |
 | `useWaitForNotes(...)` | resolves when matching notes appear | Pull-style note waiting |
-| `usePswapLineages()` | `lineages` | All tracked PSWAP order lineages |
-| `usePswapLineagesFor(creator)` | `lineages` | Tracked PSWAP lineages for one creator |
-| `usePswapLineage(orderId)` | `lineage` | One tracked PSWAP lineage by stable order id |
 
 ### Mutation (write)
 | Hook | Action | Returns on success |
@@ -442,14 +407,11 @@ Query hooks return `{ ...data, isLoading, error, refetch }`. Mutation hooks retu
 | `useSend()` | `send({ from, to, assetId, amount, noteType })` | `SendResult` (with `txId`, `note`) |
 | `useMultiSend()` | `multiSend({ from, recipients })` | `TransactionResult` |
 | `useMint()` | `mint({ faucetId, to, amount })` | `TransactionResult` |
-| `useBridge()` | `bridge({ from, bridgeAccount, assetId, amount, destinationNetwork, destinationAddress })` | `TransactionResult` (emits an AggLayer B2AGG bridge-out note) |
-| `useCreateNetworkNote()` | `createNetworkNote({ accountId, target, script \| recipient, ... })` | `NetworkNoteResult` (`{ txId, note }`; note satisfies `note.isNetworkNote()`) |
 | `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` |
-| `usePswapCancelByOrder()` | `pswapCancelByOrder({ orderId })` — creator only, resolves the current tip + creator from the tracked lineage | `TransactionResult` |
 | `useTransaction()` | `transact({ ... })` | `TransactionResult` (custom tx) |
 | `useExecuteProgram()` | `execute(...)` | program output |
 | `useCompile()` | `compile({ source })` | `{ component, txScript, noteScript }` |

package/README.md

@@ -12,8 +12,6 @@ React hooks library for the Miden Web Client. Provides a simple, ergonomic inter
 - **Note Attachments** - Send and read arbitrary data payloads on notes via `useSend()` and `readNoteAttachment()`
 - **Temporal Note Tracking** - `useNoteStream()` tracks when notes first appear, with built-in filtering, handled-note exclusion, and phase snapshots
 - **Session Wallets** - `useSessionAccount()` manages the create-fund-consume lifecycle for temporary wallets
-- **AggLayer Bridge-Out** - `useBridge()` emits a B2AGG note to bridge a fungible asset out to another network via the AggLayer
-- **Network Notes** - `useCreateNetworkNote()` creates custom-script network notes
 - **Concurrency Safety** - Transaction hooks prevent double-sends with built-in concurrency guards
 - **Auto Pre-Sync** - Transaction hooks sync before executing by default (opt out with `skipSync`)
 - **WASM Error Wrapping** - Cryptic WASM errors are intercepted and replaced with actionable messages
@@ -1107,64 +1105,6 @@ function CancelPswapButton({ accountId, note }: Props) {
 }
 ```
 
-#### `usePswapLineages()` / `usePswapLineagesFor()` / `usePswapLineage()`
-
-Read the partial-swap orders this client is tracking. As a PSWAP note is filled
-round by round, the client follows the chain — original note → remainder →
-remainder — and records each step as a **lineage** keyed by a stable `orderId`.
-These query hooks expose that tracked state and refresh after every successful
-sync. They return `{ lineages | lineage, isLoading, error, refetch }`.
-
-```tsx
-import {
-  usePswapLineages,
-  usePswapLineagesFor,
-  usePswapLineage,
-} from '@miden-sdk/react';
-
-// Every lineage tracked by this client
-const { lineages } = usePswapLineages();
-
-// Only the lineages created by one account
-const { lineages: mine } = usePswapLineagesFor('0xmywallet...');
-
-// A single order by its stable id
-const { lineage } = usePswapLineage(orderId);
-
-function OrderRow({ orderId }: { orderId: string }) {
-  const { lineage, isLoading } = usePswapLineage(orderId);
-  if (isLoading) return <span>Loading…</span>;
-  if (!lineage) return <span>Not tracked</span>;
-  return (
-    <span>
-      {lineage.orderId()} — {lineage.remainingOffered().toString()} left,
-      state {lineage.state()}
-    </span>
-  );
-}
-```
-
-#### `usePswapCancelByOrder()`
-
-Cancel a tracked PSWAP by its stable `orderId` and reclaim the unfilled offered
-asset on the lineage's current tip. Unlike `usePswapCancel`, you don't need to
-hold the tip note — the creator account and tip are resolved from the locally
-tracked lineage, so only the order id is required.
-
-```tsx
-import { usePswapCancelByOrder } from '@miden-sdk/react';
-
-function CancelOrderButton({ orderId }: { orderId: string }) {
-  const { pswapCancelByOrder, isLoading, stage } = usePswapCancelByOrder();
-
-  return (
-    <button onClick={() => pswapCancelByOrder({ orderId })} disabled={isLoading}>
-      {isLoading ? stage : 'Cancel order'}
-    </button>
-  );
-}
-```
-
 #### `useTransaction()`
 
 Execute a custom `TransactionRequest` or build one with the client. This is the

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 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, NoteExecutionHint, NoteRecipient, NoteScript, TransactionScript, AdviceInputs, AccountStorageRequirements, TransactionRequest, WasmWebClient, AccountFile, NoteVisibility, ConsumableNoteRecord, NoteInput, PswapLineageRecord, TransactionId, TransactionFilter, TransactionRecord, TransactionProver, CompileComponentOptions, CompileTxScriptOptions, CompileNoteScriptOptions, NoteAttachment } from '@miden-sdk/miden-sdk';
-export { Account, AccountFile, AccountHeader, AccountId, AccountStorageMode, AuthScheme, ConsumableNoteRecord, InputNoteRecord, Note, NoteType, PswapLineageRecord, TransactionFilter, TransactionId, TransactionRecord, TransactionRequest, WasmWebClient as WebClient } 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" {
     interface Account {
@@ -392,46 +392,6 @@ interface MintOptions {
     /** Note type. Default: private */
     noteType?: NoteVisibility;
 }
-interface CreateNetworkNoteOptions {
-    /** Account that creates, funds, and submits the note (executing sender). */
-    accountId: AccountRef;
-    /** The network account the note targets. */
-    target: AccountRef;
-    /** Execution hint. Defaults to `always`. */
-    executionHint?: NoteExecutionHint;
-    /** Recipient carrying the custom script (advanced; else pass `script`). */
-    recipient?: NoteRecipient;
-    /** Custom consumption script; the recipient is built for you. */
-    script?: NoteScript;
-    /** Note storage / inputs the script reads (used with `script`). */
-    inputs?: bigint[];
-    /** Single asset to lock into the note. Optional — omit for a zero-asset note. */
-    assetId?: AccountRef;
-    /** Amount for `assetId`. */
-    amount?: bigint | number;
-    /** Extra attachment payload appended after the NetworkAccountTarget. */
-    attachment?: bigint[] | Uint8Array | number[];
-}
-interface NetworkNoteResult {
-    txId: string;
-    note: Note;
-}
-interface BridgeOptions {
-    /** Account that creates and funds the bridge note (the sender) */
-    from: AccountRef;
-    /** Bridge account that consumes the note and burns the bridged assets */
-    bridgeAccount: AccountRef;
-    /** Faucet/token ID of the fungible asset to bridge */
-    assetId: AccountRef;
-    /** Amount of the asset to bridge */
-    amount: bigint | number;
-    /** AggLayer-assigned network ID of the destination chain */
-    destinationNetwork: number;
-    /** Destination Ethereum address on the destination network (0x-prefixed hex) */
-    destinationAddress: string;
-    /** Skip auto-sync after bridging. Default: false */
-    skipSync?: boolean;
-}
 interface ConsumeOptions {
     /** Account ID that will consume the notes */
     accountId: string;
@@ -502,29 +462,6 @@ interface PswapCancelOptions {
      */
     note: NoteInput;
 }
-interface PswapCancelByOrderOptions {
-    /**
-     * Stable order id of the lineage to cancel (decimal string or bigint).
-     * `number` is not accepted: a PSWAP order id is `u64`-shaped and routinely
-     * exceeds `Number.MAX_SAFE_INTEGER`, which a JS `number` cannot represent
-     * without silent precision loss.
-     */
-    orderId: string | bigint;
-}
-interface PswapLineagesResult {
-    /** Tracked PSWAP lineages. */
-    lineages: PswapLineageRecord[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-}
-interface PswapLineageResult {
-    /** The tracked lineage, or `null` if not tracked. */
-    lineage: PswapLineageRecord | null;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-}
 interface ExecuteTransactionOptions {
     /** Account ID the transaction applies to */
     accountId: AccountRef;
@@ -877,74 +814,6 @@ declare function useAssetMetadata(assetIds?: string[]): {
     assetMetadata: Map<string, AssetMetadata>;
 };
 
-/**
- * Hook to list every partial-swap (PSWAP) lineage tracked by this client.
- *
- * A lineage records how a PSWAP note has been filled round by round, from the
- * original note through each remainder to the current tip. The list refreshes
- * after each successful sync.
- *
- * @example
- * ```tsx
- * function LineageList() {
- *   const { lineages, isLoading } = usePswapLineages();
- *   if (isLoading) return <div>Loading...</div>;
- *   return (
- *     <ul>
- *       {lineages.map((l) => (
- *         <li key={l.orderId()}>
- *           {l.orderId()} — {l.remainingOffered().toString()} remaining
- *         </li>
- *       ))}
- *     </ul>
- *   );
- * }
- * ```
- */
-declare function usePswapLineages(): PswapLineagesResult;
-type UsePswapLineagesResult = PswapLineagesResult;
-
-/**
- * Hook to list the partial-swap (PSWAP) lineages created by a specific local
- * account. Refreshes after each successful sync.
- *
- * @param account - Creator account (hex, bech32, `Account`, or `AccountId`).
- *
- * @example
- * ```tsx
- * function MyLineages({ accountId }: { accountId: string }) {
- *   const { lineages, isLoading } = usePswapLineagesFor(accountId);
- *   if (isLoading) return <div>Loading...</div>;
- *   return <div>{lineages.length} open orders</div>;
- * }
- * ```
- */
-declare function usePswapLineagesFor(account: AccountRef | null | undefined): PswapLineagesResult;
-type UsePswapLineagesForResult = PswapLineagesResult;
-
-/**
- * Hook to fetch a single partial-swap (PSWAP) lineage by its stable order id.
- * Returns `null` if this client is not tracking the order. Refreshes after each
- * successful sync.
- *
- * @param orderId - Stable order id (decimal string or bigint). `number` is
- *   not accepted: a PSWAP order id is `u64`-shaped and routinely exceeds
- *   `Number.MAX_SAFE_INTEGER`, which a JS `number` cannot represent without
- *   silent precision loss.
- *
- * @example
- * ```tsx
- * function OrderStatus({ orderId }: { orderId: string }) {
- *   const { lineage, isLoading } = usePswapLineage(orderId);
- *   if (isLoading) return <div>Loading...</div>;
- *   if (!lineage) return <div>Not tracked</div>;
- *   return <div>State: {lineage.state()}</div>;
- * }
- * ```
- */
-declare function usePswapLineage(orderId: string | bigint | null | undefined): PswapLineageResult;
-type UsePswapLineageResult = PswapLineageResult;
-
 interface UseCreateWalletResult {
     /** Create a new wallet with optional configuration */
     createWallet: (options?: CreateWalletOptions) => Promise<Account>;
@@ -1214,61 +1083,6 @@ interface UseMintResult {
  */
 declare function useMint(): UseMintResult;
 
-interface UseBridgeResult {
-    /** Bridge a fungible asset out to another network via the AggLayer */
-    bridge: (options: BridgeOptions) => 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 bridge a fungible asset out to another network via the AggLayer.
- *
- * Emits a single public B2AGG (Bridge-to-AggLayer) note that the bridge account consumes,
- * burning the asset so it can be claimed at the destination Ethereum address on the destination
- * network. The sender account executes the transaction that emits the note.
- *
- * Returns `{ bridge, result, isLoading, stage, error, reset }`. `bridge` resolves to a
- * `TransactionResult` (`{ transactionId }`) and rejects on failure.
- *
- * @example
- * ```tsx
- * function BridgeButton({ from, bridgeAccount, assetId }: Props) {
- *   const { bridge, isLoading, stage, error } = useBridge();
- *
- *   const handleBridge = async () => {
- *     try {
- *       const result = await bridge({
- *         from,
- *         bridgeAccount,
- *         assetId,
- *         amount: 100n,
- *         destinationNetwork: 1,
- *         destinationAddress: "0x000000000000000000000000000000000000dEaD",
- *       });
- *       console.log("Bridged! TX:", result.transactionId);
- *     } catch (err) {
- *       console.error("Bridge failed:", err);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={handleBridge} disabled={isLoading}>
- *       {isLoading ? stage : "Bridge"}
- *     </button>
- *   );
- * }
- * ```
- */
-declare function useBridge(): UseBridgeResult;
-
 interface UseConsumeResult {
     /** Consume one or more notes */
     consume: (options: ConsumeOptions) => Promise<TransactionResult>;
@@ -1482,56 +1296,6 @@ interface UsePswapCancelResult {
  */
 declare function usePswapCancel(): UsePswapCancelResult;
 
-interface UsePswapCancelByOrderResult {
-    /** Cancel a PSWAP lineage by its stable order id, reclaiming the unfilled offered asset. */
-    pswapCancelByOrder: (options: PswapCancelByOrderOptions) => 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 lineage by its stable order id and reclaim the
- * unfilled offered asset on the lineage's current tip. Unlike
- * {@link usePswapCancel}, the creator account and tip note are resolved from
- * the locally tracked lineage, so only the order id is required.
- *
- * @example
- * ```tsx
- * function CancelOrderButton({ orderId }: { orderId: string }) {
- *   const { pswapCancelByOrder, isLoading, stage } = usePswapCancelByOrder();
- *   return (
- *     <button onClick={() => pswapCancelByOrder({ orderId })} disabled={isLoading}>
- *       {isLoading ? stage : "Cancel order"}
- *     </button>
- *   );
- * }
- * ```
- */
-declare function usePswapCancelByOrder(): UsePswapCancelByOrderResult;
-
-interface UseCreateNetworkNoteResult {
-    /** Build + submit a Public custom-script network note. */
-    createNetworkNote: (options: CreateNetworkNoteOptions) => Promise<NetworkNoteResult>;
-    result: NetworkNoteResult | null;
-    isLoading: boolean;
-    stage: TransactionStage;
-    error: Error | null;
-    reset: () => void;
-}
-/**
- * Hook that builds a Public custom-script note carrying a `NetworkAccountTarget`
- * attachment and submits it as an own output note, so a public network account
- * auto-consumes it. Provide exactly one of `recipient` or `script`.
- */
-declare function useCreateNetworkNote(): UseCreateNetworkNoteResult;
-
 interface UseTransactionResult {
     /** Execute a transaction request end-to-end */
     execute: (options: ExecuteTransactionOptions) => Promise<TransactionResult>;
@@ -1951,4 +1715,4 @@ declare function createMidenStorage(prefix: string): {
     clear(): void;
 };
 
-export { type AccountRef, type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type BridgeOptions, type ConsumeOptions, type CreateFaucetOptions, type CreateNetworkNoteOptions, 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 NetworkNoteResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverTarget, type ProverUrls, type PswapCancelByOrderOptions, type PswapCancelOptions, type PswapConsumeOptions, type PswapCreateOptions, type PswapLineageResult, type PswapLineagesResult, 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 UseBridgeResult, type UseCompileResult, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateNetworkNoteResult, type UseCreateWalletResult, type UseExecuteProgramResult, type UseExportNoteResult, type UseExportStoreResult, type UseImportAccountResult, type UseImportNoteResult, type UseImportStoreResult, type UseMintResult, type UseMultiSendResult, type UseNoteStreamOptions, type UseNoteStreamReturn, type UsePswapCancelByOrderResult, type UsePswapCancelResult, type UsePswapConsumeResult, type UsePswapCreateResult, type UsePswapLineageResult, type UsePswapLineagesForResult, type UsePswapLineagesResult, 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, useBridge, useCompile, useConsume, useCreateFaucet, useCreateNetworkNote, useCreateWallet, useExecuteProgram, useExportNote, useExportStore, useImportAccount, useImportNote, useImportStore, useMiden, useMidenClient, useMint, useMultiSend, useMultiSigner, useNoteStream, useNotes, usePswapCancel, usePswapCancelByOrder, usePswapConsume, usePswapCreate, usePswapLineage, usePswapLineages, usePswapLineagesFor, 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 };