@miden-sdk/react 0.14.3 → 0.14.4

package/dist/lazy.d.mts

@@ -0,0 +1,1497 @@
+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/lazy';
+export { Account, AccountFile, AccountHeader, AccountId, AccountStorageMode, AuthScheme, ConsumableNoteRecord, InputNoteRecord, Note, NoteType, TransactionFilter, TransactionId, TransactionRecord, TransactionRequest, WasmWebClient as WebClient } from '@miden-sdk/miden-sdk/lazy';
+
+declare module "@miden-sdk/miden-sdk/lazy" {
+    interface Account {
+        /** Returns the bech32-encoded account id using the configured network. */
+        bech32id(): string;
+    }
+}
+
+/** Account reference — any account ID form accepted by the React SDK hooks. */
+type AccountRef = string | AccountId | Account | AccountHeader;
+
+/**
+ * Sign callback for WebClient.createClientWithExternalKeystore.
+ * Called when a transaction needs to be signed.
+ *
+ * @param pubKey - Public key commitment bytes
+ * @param signingInputs - Serialized signing inputs
+ * @returns Promise resolving to the signature bytes
+ */
+type SignCallback = (pubKey: Uint8Array, signingInputs: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Get-key callback for WebClient.createClientWithExternalKeystore.
+ * Called to retrieve a secret key by its public key commitment.
+ *
+ * @param pubKey - Public key commitment bytes
+ * @returns Promise resolving to the secret key bytes
+ */
+type GetKeyCallback = (pubKey: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Insert-key callback for WebClient.createClientWithExternalKeystore.
+ * Called when the SDK needs to persist a newly-generated key pair.
+ *
+ * @param pubKey - Public key commitment bytes
+ * @param secretKey - Secret key bytes to store
+ */
+type InsertKeyCallback = (pubKey: Uint8Array, secretKey: Uint8Array) => void;
+/**
+ * Account type for signer accounts.
+ * Matches the AccountType enum from the SDK.
+ */
+type SignerAccountType = "RegularAccountImmutableCode" | "RegularAccountUpdatableCode" | "FungibleFaucet" | "NonFungibleFaucet";
+/**
+ * Account configuration provided by the signer.
+ * Used to initialize the account in the client store.
+ */
+interface SignerAccountConfig {
+    /** Public key commitment (for auth component) */
+    publicKeyCommitment: Uint8Array;
+    /** Account type */
+    accountType: SignerAccountType;
+    /** Storage mode (public/private/network) */
+    storageMode: AccountStorageMode;
+    /** Optional seed for deterministic account ID */
+    accountSeed?: Uint8Array;
+    /** Optional custom account components to include in the account (e.g. from a compiled .masp package) */
+    customComponents?: AccountComponent[];
+    /**
+     * Optional existing account ID to import instead of building from scratch.
+     * When provided, skips AccountBuilder and imports the account by ID from the chain.
+     * Useful for wallets that create accounts externally (e.g., via a vault).
+     */
+    importAccountId?: string;
+}
+/**
+ * Context value provided by signer providers (Para, Turnkey, MidenFi, etc.).
+ * Includes everything needed for MidenProvider to create an external keystore client
+ * and for apps to show connect/disconnect UI.
+ */
+interface SignerContextValue {
+    /** Sign callback for external keystore */
+    signCb: SignCallback;
+    /** Optional get-key callback for external keystore (retrieves secret key by public key) */
+    getKeyCb?: GetKeyCallback;
+    /** Optional insert-key callback for external keystore (persists newly-generated key pair) */
+    insertKeyCb?: InsertKeyCallback;
+    /** Account config for initialization (only valid when connected) */
+    accountConfig: SignerAccountConfig;
+    /** Store name suffix for IndexedDB isolation (e.g., "para_walletId") */
+    storeName: string;
+    /** Display name for UI (e.g., "Para", "Turnkey", "MidenFi") */
+    name: string;
+    /** Whether the signer is connected and ready */
+    isConnected: boolean;
+    /** Connect to the signer (triggers auth flow) */
+    connect: () => Promise<void>;
+    /** Disconnect from the signer */
+    disconnect: () => Promise<void>;
+}
+/**
+ * React context for signer - null when no signer provider is present.
+ * Signer providers (ParaSignerProvider, TurnkeySignerProvider, etc.) populate this context.
+ */
+declare const SignerContext: react.Context<SignerContextValue | null>;
+/**
+ * Hook for apps and MidenProvider to interact with the current signer.
+ * Returns null if no signer provider is present (local keystore mode).
+ *
+ * @example
+ * ```tsx
+ * function ConnectButton() {
+ *   const signer = useSigner();
+ *   if (!signer) return null; // Local keystore mode
+ *
+ *   const { isConnected, connect, disconnect, name } = signer;
+ *   return isConnected
+ *     ? <button onClick={disconnect}>Disconnect {name}</button>
+ *     : <button onClick={connect}>Connect with {name}</button>;
+ * }
+ * ```
+ */
+declare function useSigner(): SignerContextValue | null;
+
+type RpcUrlConfig = string | "devnet" | "testnet" | "localhost" | "local";
+/** Single prover target — a well-known name, custom URL, or object with URL + timeout. */
+type ProverTarget = "local" | "localhost" | "devnet" | "testnet" | string | {
+    url: string;
+    timeoutMs?: number | bigint;
+};
+type ProverConfig = ProverTarget | {
+    /** Primary prover to try first */
+    primary: ProverTarget;
+    /** Fallback prover if primary fails (e.g. "local") */
+    fallback?: ProverTarget;
+    /** Return true to skip the fallback (e.g. on mobile where local proving is too slow) */
+    disableFallback?: () => boolean;
+    /** Called when the primary prover fails and the fallback is used */
+    onFallback?: () => void;
+};
+type ProverUrls = {
+    devnet?: string;
+    testnet?: string;
+};
+interface MidenConfig {
+    /** RPC node URL or network name (devnet/testnet/localhost). Defaults to testnet. */
+    rpcUrl?: RpcUrlConfig;
+    /** Note transport URL for streaming notes. */
+    noteTransportUrl?: string;
+    /** Auto-sync interval in milliseconds. Set to 0 to disable. Default: 15000ms */
+    autoSyncInterval?: number;
+    /** Initial seed for deterministic RNG (must be 32 bytes if provided) */
+    seed?: Uint8Array;
+    /** Transaction prover selection (local/devnet/testnet or a remote URL). */
+    prover?: ProverConfig;
+    /** Optional override URLs for network provers. */
+    proverUrls?: ProverUrls;
+    /** Default timeout for remote prover requests in milliseconds. */
+    proverTimeoutMs?: number | bigint;
+}
+interface MidenState {
+    client: WasmWebClient | null;
+    isReady: boolean;
+    isInitializing: boolean;
+    error: Error | null;
+}
+type TransactionStage = "idle" | "executing" | "proving" | "submitting" | "complete";
+interface QueryResult<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface MutationResult<TData, TVariables> {
+    mutate: (variables: TVariables) => Promise<TData>;
+    data: TData | null;
+    isLoading: boolean;
+    stage: TransactionStage;
+    error: Error | null;
+    reset: () => void;
+}
+interface SyncState {
+    syncHeight: number;
+    isSyncing: boolean;
+    lastSyncTime: number | null;
+    error: Error | null;
+}
+interface AccountsResult {
+    accounts: AccountHeader[];
+    wallets: AccountHeader[];
+    faucets: AccountHeader[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface AccountResult {
+    account: Account | null;
+    assets: AssetBalance[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    getBalance: (assetId: string) => bigint;
+}
+interface AssetBalance {
+    assetId: string;
+    amount: bigint;
+    symbol?: string;
+    decimals?: number;
+}
+interface NotesFilter {
+    status?: "all" | "consumed" | "committed" | "expected" | "processing";
+    accountId?: AccountRef;
+    /** Only notes from this sender (any format, normalized internally) */
+    sender?: string;
+    /** Exclude these note IDs */
+    excludeIds?: string[];
+}
+interface NotesResult {
+    notes: InputNoteRecord[];
+    consumableNotes: ConsumableNoteRecord[];
+    noteSummaries: NoteSummary[];
+    consumableNoteSummaries: NoteSummary[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+type TransactionStatus = "pending" | "committed" | "discarded";
+interface TransactionHistoryOptions {
+    /** Single transaction ID to look up. */
+    id?: string | TransactionId;
+    /** List of transaction IDs to look up. */
+    ids?: Array<string | TransactionId>;
+    /** Custom transaction filter (overrides id/ids). */
+    filter?: TransactionFilter;
+    /** Refresh after provider syncs. Default: true */
+    refreshOnSync?: boolean;
+}
+interface TransactionHistoryResult {
+    records: TransactionRecord[];
+    /** Convenience record when a single ID is provided. */
+    record: TransactionRecord | null;
+    /** Convenience status when a single ID is provided. */
+    status: TransactionStatus | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface AssetMetadata {
+    assetId: string;
+    symbol?: string;
+    decimals?: number;
+}
+interface NoteAsset {
+    assetId: string;
+    amount: bigint;
+    symbol?: string;
+    decimals?: number;
+}
+interface NoteSummary {
+    id: string;
+    assets: NoteAsset[];
+    sender?: string;
+}
+interface CreateWalletOptions {
+    /** Storage mode. Default: private */
+    storageMode?: StorageMode;
+    /** Whether code can be updated. Default: true */
+    mutable?: boolean;
+    /** Auth scheme. Default: AuthScheme.AuthRpoFalcon512 */
+    authScheme?: AuthScheme;
+    /** Initial seed for deterministic account ID */
+    initSeed?: Uint8Array;
+}
+interface CreateFaucetOptions {
+    /** Token symbol (e.g., "TEST") */
+    tokenSymbol: string;
+    /** Number of decimals. Default: 8 */
+    decimals?: number;
+    /** Maximum supply */
+    maxSupply: bigint | number;
+    /** Storage mode. Default: private */
+    storageMode?: StorageMode;
+    /** Auth scheme. Default: AuthScheme.AuthRpoFalcon512 */
+    authScheme?: AuthScheme;
+}
+type ImportAccountOptions = {
+    type: "file";
+    file: AccountFile | Uint8Array | ArrayBuffer;
+} | {
+    type: "id";
+    accountId: AccountRef;
+} | {
+    type: "seed";
+    seed: Uint8Array;
+    mutable?: boolean;
+    authScheme?: AuthScheme;
+};
+interface SendOptions {
+    /** Sender account ID */
+    from: AccountRef;
+    /** Recipient account ID */
+    to: AccountRef;
+    /** Asset ID to send (token id) */
+    assetId: AccountRef;
+    /** Amount to send (ignored when sendAll is true) */
+    amount?: bigint | number;
+    /** Note type. Default: private */
+    noteType?: NoteVisibility;
+    /** Block height after which sender can reclaim note */
+    recallHeight?: number;
+    /** Block height after which recipient can consume note */
+    timelockHeight?: number;
+    /** Arbitrary data payload attached to the note */
+    attachment?: bigint[] | Uint8Array | number[];
+    /** Skip auto-sync before send. Default: false */
+    skipSync?: boolean;
+    /** Send the full balance of this asset. When true, amount is ignored. */
+    sendAll?: boolean;
+    /** true = build note in JS and return the Note object (e.g. for out-of-band delivery). Default: false */
+    returnNote?: boolean;
+}
+interface SendResult {
+    txId: string;
+    note: Note | null;
+}
+interface MultiSendRecipient {
+    /** Recipient account ID */
+    to: AccountRef;
+    /** Amount to send */
+    amount: bigint | number;
+    /** Per-recipient note type override */
+    noteType?: "private" | "public";
+    /** Per-recipient attachment */
+    attachment?: bigint[] | Uint8Array | number[];
+}
+interface MultiSendOptions {
+    /** Sender account ID */
+    from: AccountRef;
+    /** Asset ID to send (token id) */
+    assetId: AccountRef;
+    /** Recipient list */
+    recipients: MultiSendRecipient[];
+    /** Default note type for all recipients. Default: private */
+    noteType?: NoteVisibility;
+    /** Skip auto-sync before send. Default: false */
+    skipSync?: boolean;
+}
+interface WaitForCommitOptions {
+    /** Timeout in milliseconds. Default: 10000 */
+    timeoutMs?: number;
+    /** Polling interval in milliseconds. Default: 1000 */
+    intervalMs?: number;
+}
+interface WaitForNotesOptions {
+    /** Account ID to check for consumable notes */
+    accountId: AccountRef;
+    /** Minimum number of notes to wait for. Default: 1 */
+    minCount?: number;
+    /** Timeout in milliseconds. Default: 10000 */
+    timeoutMs?: number;
+    /** Polling interval in milliseconds. Default: 1000 */
+    intervalMs?: number;
+}
+interface MintOptions {
+    /** Target account to receive minted tokens */
+    targetAccountId: AccountRef;
+    /** Faucet account to mint from */
+    faucetId: AccountRef;
+    /** Amount to mint */
+    amount: bigint | number;
+    /** Note type. Default: private */
+    noteType?: NoteVisibility;
+}
+interface ConsumeOptions {
+    /** Account ID that will consume the notes */
+    accountId: string;
+    /** Notes to consume — accepts note IDs (hex strings), NoteId objects, InputNoteRecord, or Note objects */
+    notes: (string | NoteId | InputNoteRecord | Note)[];
+}
+interface SwapOptions {
+    /** Account initiating the swap */
+    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;
+    /** Note type for swap note. Default: private */
+    noteType?: NoteVisibility;
+    /** Note type for payback note. Default: private */
+    paybackNoteType?: NoteVisibility;
+}
+interface ExecuteTransactionOptions {
+    /** Account ID the transaction applies to */
+    accountId: AccountRef;
+    /** Transaction request or builder */
+    request: TransactionRequest | ((client: WasmWebClient) => TransactionRequest | Promise<TransactionRequest>);
+    /** Skip auto-sync before transaction. Default: false */
+    skipSync?: boolean;
+    /**
+     * When set, private output notes from this transaction are delivered to the
+     * given target account after the transaction is committed. Accepts any
+     * AccountRef form (hex string, bech32, AccountId, Account, AccountHeader).
+     */
+    privateNoteTarget?: AccountRef;
+}
+interface TransactionResult {
+    transactionId: string;
+}
+interface ExecuteProgramOptions {
+    /** Account to execute the program against */
+    accountId: string | AccountId;
+    /** Compiled TransactionScript */
+    script: TransactionScript;
+    /** Advice inputs (defaults to empty) */
+    adviceInputs?: AdviceInputs;
+    /** Foreign accounts referenced by the script */
+    foreignAccounts?: (string | AccountId | {
+        id: string | AccountId;
+        storage?: AccountStorageRequirements;
+    })[];
+    /** Skip auto-sync before execution. Default: false */
+    skipSync?: boolean;
+}
+interface ExecuteProgramResult {
+    /** The 16-element stack output as bigint array */
+    stack: bigint[];
+}
+interface StreamedNote {
+    /** Note ID (hex string) */
+    id: string;
+    /** Sender account ID (bech32 if available) */
+    sender: string;
+    /** First fungible asset amount (convenience; 0n if no fungible assets) */
+    amount: bigint;
+    /** All assets on the note */
+    assets: NoteAsset[];
+    /** The underlying InputNoteRecord for escape-hatch access */
+    record: InputNoteRecord;
+    /** Timestamp (ms) when this note was first observed by the SDK */
+    firstSeenAt: number;
+    /** Pre-decoded attachment values, or null if no attachment */
+    attachment: bigint[] | null;
+}
+interface UseNoteStreamOptions {
+    /** Note status filter. Default: "committed" */
+    status?: "all" | "consumed" | "committed" | "expected" | "processing";
+    /** Only notes from this sender (any format, normalized internally) */
+    sender?: string | null;
+    /** Only notes first seen after this timestamp */
+    since?: number;
+    /** Exclude these note IDs (for cross-phase stale filtering) */
+    excludeIds?: Set<string> | string[];
+    /** Filter by primary asset amount */
+    amountFilter?: (amount: bigint) => boolean;
+}
+interface UseNoteStreamReturn {
+    /** Notes matching all filter criteria */
+    notes: StreamedNote[];
+    /** Most recent note (convenience) */
+    latest: StreamedNote | null;
+    /** Mark a note as handled (excluded from future renders) */
+    markHandled: (noteId: string) => void;
+    /** Mark all current notes as handled */
+    markAllHandled: () => void;
+    /** Snapshot current state for passing to next phase */
+    snapshot: () => {
+        ids: Set<string>;
+        timestamp: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+}
+interface UseSessionAccountOptions {
+    /** Callback to fund the session wallet. Receives the session wallet ID. */
+    fund: (sessionAccountId: string) => Promise<void>;
+    /** Asset ID of the funding token (reserved for future filtering of consumable notes) */
+    assetId?: string;
+    /** Wallet creation options */
+    walletOptions?: {
+        storageMode?: "private" | "public";
+        mutable?: boolean;
+        authScheme?: AuthScheme;
+    };
+    /** Polling interval for funding note detection (ms). Default: 3000 */
+    pollIntervalMs?: number;
+    /** Maximum time to wait for funding note (ms). Default: 60000 */
+    maxWaitMs?: number;
+    /** localStorage key prefix for persistence. Default: "miden-session" */
+    storagePrefix?: string;
+}
+type SessionAccountStep = "idle" | "creating" | "funding" | "consuming" | "ready";
+interface UseSessionAccountReturn {
+    /** Start the create->fund->consume flow */
+    initialize: () => Promise<void>;
+    /** Session wallet ID (bech32), or null if not yet created */
+    sessionAccountId: string | null;
+    /** Whether the session wallet is funded and ready */
+    isReady: boolean;
+    /** Current step */
+    step: SessionAccountStep;
+    /** Error from any step */
+    error: Error | null;
+    /** Clear all session data and reset */
+    reset: () => void;
+}
+declare const DEFAULTS: {
+    readonly RPC_URL: undefined;
+    readonly AUTO_SYNC_INTERVAL: 15000;
+    readonly STORAGE_MODE: "private";
+    readonly WALLET_MUTABLE: true;
+    readonly AUTH_SCHEME: AuthScheme.AuthRpoFalcon512;
+    readonly NOTE_TYPE: "private";
+    readonly FAUCET_DECIMALS: 8;
+};
+
+type ProverConfigSubset = Pick<MidenConfig, "prover" | "proverUrls" | "proverTimeoutMs">;
+declare function resolveTransactionProver(config: ProverConfigSubset): TransactionProver | null;
+
+interface MidenContextValue {
+    client: WasmWebClient | null;
+    isReady: boolean;
+    isInitializing: boolean;
+    error: Error | null;
+    sync: () => Promise<void>;
+    runExclusive: <T>(fn: () => Promise<T>) => Promise<T>;
+    prover: ReturnType<typeof resolveTransactionProver>;
+    /** Account ID from signer (only set when using external signer) */
+    signerAccountId: string | null;
+    /** Whether the external signer is connected (null = no signer provider) */
+    signerConnected: boolean | null;
+}
+interface MidenProviderProps {
+    children: ReactNode;
+    config?: MidenConfig;
+    /** Custom loading component shown during WASM initialization */
+    loadingComponent?: ReactNode;
+    /** Custom error component shown if initialization fails */
+    errorComponent?: ReactNode | ((error: Error) => ReactNode);
+}
+declare function MidenProvider({ children, config, loadingComponent, errorComponent, }: MidenProviderProps): react_jsx_runtime.JSX.Element;
+declare function useMiden(): MidenContextValue;
+declare function useMidenClient(): WasmWebClient;
+
+interface MultiSignerContextValue {
+    /** All registered signer providers */
+    signers: SignerContextValue[];
+    /** The currently active signer (null if none selected) */
+    activeSigner: SignerContextValue | null;
+    /** Switch to a signer by name and call its connect() */
+    connectSigner: (name: string) => Promise<void>;
+    /** Disconnect the active signer and revert to local keystore mode */
+    disconnectSigner: () => Promise<void>;
+}
+declare function MultiSignerProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Render-less component that registers the nearest ancestor's SignerContext value
+ * into the MultiSignerProvider registry.
+ *
+ * Place one `<SignerSlot />` inside each signer provider:
+ * ```tsx
+ * <ParaSignerProvider>
+ *   <SignerSlot />
+ * </ParaSignerProvider>
+ * ```
+ */
+declare function SignerSlot(): null;
+/**
+ * Access the multi-signer context for listing signers, connecting, and disconnecting.
+ * Returns null when used outside a `MultiSignerProvider`.
+ */
+declare function useMultiSigner(): MultiSignerContextValue | null;
+
+/**
+ * Hook to list all accounts in the client.
+ *
+ * @example
+ * ```tsx
+ * function AccountList() {
+ *   const { accounts, wallets, faucets, isLoading } = useAccounts();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h2>Wallets ({wallets.length})</h2>
+ *       {wallets.map(w => <div key={w.id().toString()}>{w.id().toString()}</div>)}
+ *
+ *       <h2>Faucets ({faucets.length})</h2>
+ *       {faucets.map(f => <div key={f.id().toString()}>{f.id().toString()}</div>)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAccounts(): AccountsResult;
+
+/**
+ * Hook to get details for a single account.
+ *
+ * @param accountId - The account ID string or AccountId object
+ *
+ * @example
+ * ```tsx
+ * function AccountDetails({ accountId }: { accountId: string }) {
+ *   const { account, assets, getBalance, isLoading } = useAccount(accountId);
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (!account) return <div>Account not found</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h2>Account: {account.id().toString()}</h2>
+ *       <p>Nonce: {account.nonce().toString()}</p>
+ *       <h3>Assets</h3>
+ *       {assets.map(a => (
+ *         <div key={a.assetId}>
+ *           {a.assetId}: {a.amount.toString()}
+ *         </div>
+ *       ))}
+ *       <p>USDC Balance: {getBalance('0x...').toString()}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAccount(accountId: AccountRef | undefined): AccountResult;
+
+/**
+ * Hook to list notes.
+ *
+ * @param options - Optional filter options
+ *
+ * @example
+ * ```tsx
+ * function NotesList() {
+ *   const { notes, consumableNotes, isLoading, refetch } = useNotes();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h2>All Notes ({notes.length})</h2>
+ *       {notes.map(n => (
+ *         <div key={n.id().toString()}>
+ *           Note: {n.id().toString()} - {n.isConsumed() ? 'Consumed' : 'Pending'}
+ *         </div>
+ *       ))}
+ *
+ *       <h2>Consumable Notes ({consumableNotes.length})</h2>
+ *       {consumableNotes.map(n => (
+ *         <div key={n.inputNoteRecord().id().toString()}>
+ *           {n.inputNoteRecord().id().toString()}
+ *         </div>
+ *       ))}
+ *
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useNotes(options?: NotesFilter): NotesResult;
+
+/**
+ * Hook for temporal note tracking with a unified model.
+ *
+ * Replaces the common pattern of `handledNoteIds` refs, deferred baselines,
+ * and dual-track note decoding. Returns `StreamedNote` objects that merge
+ * summary data with the underlying record and pre-decode attachments.
+ *
+ * @example
+ * ```tsx
+ * function IncomingNotes({ opponentId }: { opponentId: string }) {
+ *   const { notes, latest, markHandled, snapshot } = useNoteStream({
+ *     sender: opponentId,
+ *     status: "committed",
+ *   });
+ *
+ *   useEffect(() => {
+ *     if (latest) {
+ *       console.log("New note!", latest.attachment);
+ *       markHandled(latest.id);
+ *     }
+ *   }, [latest, markHandled]);
+ *
+ *   return <div>{notes.length} unhandled notes</div>;
+ * }
+ * ```
+ */
+declare function useNoteStream(options?: UseNoteStreamOptions): UseNoteStreamReturn;
+
+/**
+ * Hook to query transaction history and track transaction state.
+ *
+ * @param options - Optional filter options
+ *
+ * @example
+ * ```tsx
+ * function HistoryList() {
+ *   const { records, isLoading } = useTransactionHistory();
+ *   if (isLoading) return <div>Loading...</div>;
+ *   return (
+ *     <ul>
+ *       {records.map((record) => (
+ *         <li key={record.id().toHex()}>{record.id().toHex()}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useTransactionHistory(options?: TransactionHistoryOptions): TransactionHistoryResult;
+type UseTransactionHistoryResult = TransactionHistoryResult;
+
+interface UseSyncStateResult extends SyncState {
+    /** Trigger a manual sync */
+    sync: () => Promise<void>;
+}
+/**
+ * Hook to access sync state and trigger manual syncs.
+ *
+ * @example
+ * ```tsx
+ * function SyncStatus() {
+ *   const { syncHeight, isSyncing, sync } = useSyncState();
+ *
+ *   return (
+ *     <div>
+ *       <p>Block height: {syncHeight}</p>
+ *       <button onClick={sync} disabled={isSyncing}>
+ *         {isSyncing ? 'Syncing...' : 'Sync'}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncState(): UseSyncStateResult;
+
+declare function useAssetMetadata(assetIds?: string[]): {
+    assetMetadata: Map<string, AssetMetadata>;
+};
+
+interface UseCreateWalletResult {
+    /** Create a new wallet with optional configuration */
+    createWallet: (options?: CreateWalletOptions) => Promise<Account>;
+    /** The created wallet account */
+    wallet: Account | null;
+    /** Whether wallet creation is in progress */
+    isCreating: boolean;
+    /** Error if creation failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to create a new wallet account.
+ *
+ * @example
+ * ```tsx
+ * function CreateWalletButton() {
+ *   const { createWallet, wallet, isCreating, error } = useCreateWallet();
+ *
+ *   const handleCreate = async () => {
+ *     const newWallet = await createWallet({
+ *       storageMode: 'private',
+ *       mutable: true,
+ *     });
+ *     console.log('Created wallet:', newWallet.id().toString());
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreate} disabled={isCreating}>
+ *         {isCreating ? 'Creating...' : 'Create Wallet'}
+ *       </button>
+ *       {wallet && <p>Created: {wallet.id().toString()}</p>}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreateWallet(): UseCreateWalletResult;
+
+interface UseCreateFaucetResult {
+    /** Create a new faucet with the specified options */
+    createFaucet: (options: CreateFaucetOptions) => Promise<Account>;
+    /** The created faucet account */
+    faucet: Account | null;
+    /** Whether faucet creation is in progress */
+    isCreating: boolean;
+    /** Error if creation failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to create a new faucet account.
+ *
+ * @example
+ * ```tsx
+ * function CreateFaucetButton() {
+ *   const { createFaucet, faucet, isCreating, error } = useCreateFaucet();
+ *
+ *   const handleCreate = async () => {
+ *     const newFaucet = await createFaucet({
+ *       tokenSymbol: 'TEST',
+ *       decimals: 8,
+ *       maxSupply: 1000000n * 10n ** 8n, // 1M tokens
+ *     });
+ *     console.log('Created faucet:', newFaucet.id().toString());
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreate} disabled={isCreating}>
+ *         {isCreating ? 'Creating...' : 'Create Faucet'}
+ *       </button>
+ *       {faucet && <p>Created: {faucet.id().toString()}</p>}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreateFaucet(): UseCreateFaucetResult;
+
+interface UseImportAccountResult {
+    /** Import an existing account into the client */
+    importAccount: (options: ImportAccountOptions) => Promise<Account>;
+    /** The imported account */
+    account: Account | null;
+    /** Whether an import is in progress */
+    isImporting: boolean;
+    /** Error if import failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to import existing accounts into the client.
+ *
+ * @example
+ * ```tsx
+ * function ImportAccountButton({ accountId }: { accountId: string }) {
+ *   const { importAccount, isImporting } = useImportAccount();
+ *
+ *   const handleImport = async () => {
+ *     const account = await importAccount({
+ *       type: "id",
+ *       accountId,
+ *     });
+ *     console.log("Imported:", account.id().toString());
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleImport} disabled={isImporting}>
+ *       {isImporting ? "Importing..." : "Import Account"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useImportAccount(): UseImportAccountResult;
+
+interface UseSendResult {
+    /** Send tokens from one account to another */
+    send: (options: SendOptions) => Promise<SendResult>;
+    /** The transaction result */
+    result: SendResult | 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 send tokens between accounts.
+ *
+ * @example
+ * ```tsx
+ * function SendButton({ from, to, assetId }: Props) {
+ *   const { send, isLoading, stage, error } = useSend();
+ *
+ *   const handleSend = async () => {
+ *     try {
+ *       const result = await send({
+ *         from,
+ *         to,
+ *         assetId,
+ *         amount: 100n,
+ *       });
+ *       console.log('Transaction ID:', result.transactionId);
+ *     } catch (err) {
+ *       console.error('Send failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSend} disabled={isLoading}>
+ *       {isLoading ? stage : 'Send'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSend(): UseSendResult;
+
+interface UseMultiSendResult {
+    /** Create multiple P2ID output notes in one transaction */
+    sendMany: (options: MultiSendOptions) => 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 multi-send transaction (multiple P2ID notes).
+ *
+ * @example
+ * ```tsx
+ * function MultiSendButton() {
+ *   const { sendMany, isLoading, stage } = useMultiSend();
+ *
+ *   const handleSend = async () => {
+ *     await sendMany({
+ *       from: "mtst1...",
+ *       assetId: "0x...",
+ *       recipients: [
+ *         { to: "mtst1...", amount: 100n },
+ *         { to: "0x...", amount: 250n },
+ *       ],
+ *       noteType: "public",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSend} disabled={isLoading}>
+ *       {isLoading ? stage : "Multi-send"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useMultiSend(): UseMultiSendResult;
+
+interface UseWaitForCommitResult {
+    /** Wait for a transaction to be committed on-chain */
+    waitForCommit: (txId: string | TransactionId, options?: WaitForCommitOptions) => Promise<void>;
+}
+declare function useWaitForCommit(): UseWaitForCommitResult;
+
+interface UseWaitForNotesResult {
+    /** Wait until an account has consumable notes */
+    waitForConsumableNotes: (options: WaitForNotesOptions) => Promise<ConsumableNoteRecord[]>;
+}
+declare function useWaitForNotes(): UseWaitForNotesResult;
+
+interface UseMintResult {
+    /** Mint tokens from a faucet to a target account */
+    mint: (options: MintOptions) => 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 mint tokens from a faucet.
+ *
+ * @example
+ * ```tsx
+ * function MintButton({ faucetId, targetAccountId }: Props) {
+ *   const { mint, isLoading, stage, error } = useMint();
+ *
+ *   const handleMint = async () => {
+ *     try {
+ *       const result = await mint({
+ *         faucetId,
+ *         targetAccountId,
+ *         amount: 1000n,
+ *       });
+ *       console.log('Minted! TX:', result.transactionId);
+ *     } catch (err) {
+ *       console.error('Mint failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleMint} disabled={isLoading}>
+ *       {isLoading ? stage : 'Mint Tokens'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useMint(): UseMintResult;
+
+interface UseConsumeResult {
+    /** Consume one or more notes */
+    consume: (options: ConsumeOptions) => 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 notes and claim their assets.
+ *
+ * @example
+ * ```tsx
+ * function ConsumeNotesButton({ accountId, notes }: Props) {
+ *   const { consume, isLoading, stage, error } = useConsume();
+ *
+ *   const handleConsume = async () => {
+ *     try {
+ *       const result = await consume({
+ *         accountId,
+ *         notes,
+ *       });
+ *       console.log('Consumed! TX:', result.transactionId);
+ *     } catch (err) {
+ *       console.error('Consume failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleConsume} disabled={isLoading}>
+ *       {isLoading ? stage : 'Claim Notes'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useConsume(): UseConsumeResult;
+
+interface UseSwapResult {
+    /** Create an atomic swap offer */
+    swap: (options: SwapOptions) => 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 atomic swap transactions.
+ *
+ * @example
+ * ```tsx
+ * function SwapButton({ accountId }: { accountId: string }) {
+ *   const { swap, isLoading, stage, error } = useSwap();
+ *
+ *   const handleSwap = async () => {
+ *     try {
+ *       const result = await swap({
+ *         accountId,
+ *         offeredFaucetId: '0x...', // Token A
+ *         offeredAmount: 100n,
+ *         requestedFaucetId: '0x...', // Token B
+ *         requestedAmount: 50n,
+ *       });
+ *       console.log('Swap created! TX:', result.transactionId);
+ *     } catch (err) {
+ *       console.error('Swap failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSwap} disabled={isLoading}>
+ *       {isLoading ? stage : 'Create Swap'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSwap(): UseSwapResult;
+
+interface UseTransactionResult {
+    /** Execute a transaction request end-to-end */
+    execute: (options: ExecuteTransactionOptions) => 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 execute arbitrary transaction requests.
+ *
+ * Always uses the 4-step pipeline (execute → prove → submit → apply)
+ * with prover fallback support. When `privateNoteTarget` is set,
+ * additionally waits for commit and delivers private output notes.
+ *
+ * @example
+ * ```tsx
+ * function CustomTransactionButton({ accountId }: { accountId: string }) {
+ *   const { execute, isLoading, stage } = useTransaction();
+ *
+ *   const handleClick = async () => {
+ *     await execute({
+ *       accountId,
+ *       request: (client) =>
+ *         client.newSwapTransactionRequest(
+ *           AccountId.fromHex(accountId),
+ *           AccountId.fromHex("0x..."),
+ *           10n,
+ *           AccountId.fromHex("0x..."),
+ *           5n,
+ *           NoteType.Private,
+ *           NoteType.Private
+ *         ),
+ *       privateNoteTarget: "0xrecipient...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={isLoading}>
+ *       {isLoading ? stage : "Run Transaction"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useTransaction(): UseTransactionResult;
+
+interface UseExecuteProgramResult {
+    /** Execute a program (view call) and return the stack output */
+    execute: (options: ExecuteProgramOptions) => Promise<ExecuteProgramResult>;
+    /** The most recent result */
+    result: ExecuteProgramResult | null;
+    /** Whether execution is in progress */
+    isLoading: boolean;
+    /** Error if execution failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+declare function useExecuteProgram(): UseExecuteProgramResult;
+
+interface UseCompileResult {
+    /** Compile MASM source into an AccountComponent. */
+    component: (options: CompileComponentOptions) => Promise<AccountComponent>;
+    /** Compile MASM source into a TransactionScript. */
+    txScript: (options: CompileTxScriptOptions) => Promise<TransactionScript>;
+    /** Compile MASM source into a NoteScript. */
+    noteScript: (options: CompileNoteScriptOptions) => Promise<NoteScript>;
+    /** Whether the underlying client is ready to compile. */
+    isReady: boolean;
+}
+/**
+ * Hook for compiling MASM source into `AccountComponent`, `TransactionScript`,
+ * or `NoteScript`. Wraps `CompilerResource` from `@miden-sdk/miden-sdk` so the
+ * shape is identical to `MidenClient.compile`.
+ *
+ * @example
+ * ```tsx
+ * const { noteScript, isReady } = useCompile();
+ *
+ * const script = await noteScript({
+ *   code: noteSource,
+ *   libraries: [{ namespace: "my_lib", code: libSource, linking: Linking.Dynamic }],
+ * });
+ * ```
+ */
+declare function useCompile(): UseCompileResult;
+
+/**
+ * Hook to manage a session wallet lifecycle: create -> fund -> consume.
+ *
+ * Replaces the common 300+ line pattern of creating a temporary wallet,
+ * waiting for funding, and consuming the funding note.
+ *
+ * @example
+ * ```tsx
+ * function SessionWallet() {
+ *   const { initialize, sessionAccountId, isReady, step, error, reset } =
+ *     useSessionAccount({
+ *       fund: async (sessionId) => {
+ *         // Send tokens from main wallet to session wallet
+ *         await send({ from: mainWalletId, to: sessionId, assetId, amount: 100n });
+ *       },
+ *       assetId: "0x...",
+ *     });
+ *
+ *   if (error) return <div>Error: {error.message} <button onClick={reset}>Retry</button></div>;
+ *   if (isReady) return <div>Session ready: {sessionAccountId}</div>;
+ *
+ *   return (
+ *     <button onClick={initialize} disabled={step !== "idle"}>
+ *       {step === "idle" ? "Start Session" : step}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSessionAccount(options: UseSessionAccountOptions): UseSessionAccountReturn;
+
+interface UseExportStoreResult {
+    /** Export the IndexedDB store as a JSON string */
+    exportStore: () => Promise<string>;
+    /** Whether the export is in progress */
+    isExporting: boolean;
+    /** Error if export failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to export the IndexedDB store for backup/restore.
+ *
+ * @example
+ * ```tsx
+ * function BackupButton() {
+ *   const { exportStore, isExporting, error } = useExportStore();
+ *
+ *   const handleBackup = async () => {
+ *     const snapshot = await exportStore();
+ *     // Save snapshot to file, encrypted storage, etc.
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleBackup} disabled={isExporting}>
+ *       {isExporting ? 'Exporting...' : 'Backup Wallet'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useExportStore(): UseExportStoreResult;
+
+interface ImportStoreOptions {
+    /** Skip auto-sync after import. Default: false */
+    skipSync?: boolean;
+}
+interface UseImportStoreResult {
+    /** Import a previously exported store dump */
+    importStore: (storeDump: string, storeName: string, options?: ImportStoreOptions) => Promise<void>;
+    /** Whether the import is in progress */
+    isImporting: boolean;
+    /** Error if import failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to import a previously exported IndexedDB store for restore.
+ *
+ * @example
+ * ```tsx
+ * function RestoreButton({ snapshot }: { snapshot: string }) {
+ *   const { importStore, isImporting, error } = useImportStore();
+ *
+ *   const handleRestore = async () => {
+ *     await importStore(snapshot, 'RestoredStore');
+ *     // Store has been restored — sync or reload
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleRestore} disabled={isImporting}>
+ *       {isImporting ? 'Restoring...' : 'Restore Wallet'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useImportStore(): UseImportStoreResult;
+
+interface UseImportNoteResult {
+    /** Import a note from serialized bytes (e.g. from QR code or dApp request) */
+    importNote: (noteBytes: Uint8Array) => Promise<string>;
+    /** Whether the import is in progress */
+    isImporting: boolean;
+    /** Error if import failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to import a note from serialized NoteFile bytes.
+ *
+ * @example
+ * ```tsx
+ * function ImportNoteButton({ noteBytes }: { noteBytes: Uint8Array }) {
+ *   const { importNote, isImporting, error } = useImportNote();
+ *
+ *   const handleImport = async () => {
+ *     const noteId = await importNote(noteBytes);
+ *     console.log('Imported note:', noteId);
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleImport} disabled={isImporting}>
+ *       {isImporting ? 'Importing...' : 'Import Note'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useImportNote(): UseImportNoteResult;
+
+interface UseExportNoteResult {
+    /** Export a note as serialized bytes */
+    exportNote: (noteId: string) => Promise<Uint8Array>;
+    /** Whether the export is in progress */
+    isExporting: boolean;
+    /** Error if export failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to export a note as serialized NoteFile bytes.
+ *
+ * @example
+ * ```tsx
+ * function ExportNoteButton({ noteId }: { noteId: string }) {
+ *   const { exportNote, isExporting, error } = useExportNote();
+ *
+ *   const handleExport = async () => {
+ *     const bytes = await exportNote(noteId);
+ *     // Share bytes via QR code, file download, etc.
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleExport} disabled={isExporting}>
+ *       {isExporting ? 'Exporting...' : 'Export Note'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useExportNote(): UseExportNoteResult;
+
+interface UseSyncControlResult {
+    /** Pause auto-sync. Manual sync via useSyncState().sync() still works. */
+    pauseSync: () => void;
+    /** Resume auto-sync. */
+    resumeSync: () => void;
+    /** Whether auto-sync is currently paused. */
+    isPaused: boolean;
+}
+/**
+ * Hook to pause and resume the automatic background sync.
+ *
+ * Useful during long-running operations (e.g. transaction proving) where
+ * sync would compete for the WASM lock, or when the app is in the background.
+ *
+ * @example
+ * ```tsx
+ * function SyncToggle() {
+ *   const { pauseSync, resumeSync, isPaused } = useSyncControl();
+ *
+ *   return (
+ *     <button onClick={isPaused ? resumeSync : pauseSync}>
+ *       {isPaused ? 'Resume Sync' : 'Pause Sync'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncControl(): UseSyncControlResult;
+
+declare const toBech32AccountId: (accountId: string) => string;
+
+declare const formatAssetAmount: (amount: bigint | number, decimals?: number) => string;
+declare const parseAssetAmount: (input: string, decimals?: number) => bigint;
+
+declare const getNoteSummary: (note: ConsumableNoteRecord | InputNoteRecord, getAssetMetadata?: (assetId: string) => AssetMetadata | undefined) => NoteSummary | null;
+declare const formatNoteSummary: (summary: NoteSummary, formatAsset?: (asset: NoteAsset) => string) => string;
+
+/**
+ * Normalize any account ID format (hex, bech32, 0x-prefixed) to bech32.
+ * Returns the original string if conversion fails.
+ */
+declare function normalizeAccountId(id: string): string;
+/**
+ * Compare two account IDs for equality regardless of format (hex vs bech32).
+ * Parses both to AccountId objects and compares their hex representations.
+ */
+declare function accountIdsEqual(a: string, b: string): boolean;
+
+interface NoteAttachmentData {
+    values: bigint[];
+    kind: "word" | "array";
+}
+/**
+ * Decode a note's attachment. Returns null if no attachment.
+ */
+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.
+ */
+declare function createNoteAttachment(values: bigint[] | Uint8Array | number[]): NoteAttachment;
+
+declare function bytesToBigInt(bytes: Uint8Array): bigint;
+declare function bigIntToBytes(value: bigint, length: number): Uint8Array;
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+
+type MidenErrorCode = "WASM_CLASS_MISMATCH" | "WASM_POINTER_CONSUMED" | "WASM_NOT_INITIALIZED" | "WASM_SYNC_REQUIRED" | "SEND_BUSY" | "OPERATION_BUSY" | "UNKNOWN";
+declare class MidenError extends Error {
+    readonly code: MidenErrorCode;
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        code?: MidenErrorCode;
+    });
+}
+declare function wrapWasmError(e: unknown): Error;
+
+/** Minimal adapter shape (duck-typed, no dependency on wallet-adapter-base) */
+interface WalletAdapterLike {
+    readyState: string;
+    on(event: "readyStateChange", cb: (state: string) => void): void;
+    off(event: "readyStateChange", cb: (state: string) => void): void;
+}
+/**
+ * Wait for a wallet adapter to reach "Installed" readyState.
+ * Returns immediately if already installed. Otherwise listens
+ * for readyStateChange events with a timeout.
+ *
+ * @example
+ * ```ts
+ * const adapter = wallets[0].adapter;
+ * await waitForWalletDetection(adapter);        // default 5s timeout
+ * await waitForWalletDetection(adapter, 10000); // 10s timeout
+ * ```
+ */
+declare function waitForWalletDetection(adapter: WalletAdapterLike, timeoutMs?: number): Promise<void>;
+
+interface MigrateStorageOptions {
+    /** Current version string to compare against stored version */
+    version: string;
+    /** localStorage key for version tracking. Default: "miden:storageVersion" */
+    versionKey?: string;
+    /** Callback before clearing storage (e.g., to save data) */
+    onBeforeClear?: () => void | Promise<void>;
+    /** Reload page after clearing. Default: true */
+    reloadOnClear?: boolean;
+}
+/**
+ * Check if stored version matches current version. If not, clear Miden IndexedDB
+ * databases and localStorage, then optionally reload.
+ * Returns true if migration was triggered.
+ */
+declare function migrateStorage(options: MigrateStorageOptions): Promise<boolean>;
+/**
+ * Clear all Miden-related IndexedDB databases.
+ */
+declare function clearMidenStorage(): Promise<void>;
+/**
+ * Create a namespaced localStorage helper for app state persistence.
+ */
+declare function createMidenStorage(prefix: string): {
+    get<T>(key: string): T | null;
+    set<T>(key: string, value: T): void;
+    remove(key: string): void;
+    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, formatAssetAmount, formatNoteSummary, getNoteSummary, 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 };