@miden-sdk/react 0.13.0

package/dist/index.d.ts

@@ -0,0 +1,927 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { Account, AccountHeader, AccountId, TransactionRequest, WebClient, AccountFile, InputNoteRecord, ConsumableNoteRecord, TransactionId, TransactionFilter, TransactionRecord, TransactionProver } from '@miden-sdk/miden-sdk';
+export { Account, AccountFile, AccountHeader, AccountId, AccountStorageMode, ConsumableNoteRecord, InputNoteRecord, NoteType, TransactionFilter, TransactionId, TransactionRecord, TransactionRequest, WebClient } from '@miden-sdk/miden-sdk';
+
+declare module "@miden-sdk/miden-sdk" {
+    interface Account {
+        /** Returns the bech32-encoded account id using the configured network. */
+        bech32id(): string;
+    }
+}
+
+type RpcUrlConfig = string | "devnet" | "testnet" | "localhost" | "local";
+type ProverConfig = "local" | "devnet" | "testnet" | string | {
+    url: string;
+    timeoutMs?: number | bigint;
+};
+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: WebClient | 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?: 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?: "private" | "public" | "network";
+    /** Whether code can be updated. Default: true */
+    mutable?: boolean;
+    /** Auth scheme: 0 = RpoFalcon512, 1 = EcdsaK256Keccak. Default: 0 */
+    authScheme?: 0 | 1;
+    /** 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;
+    /** Storage mode. Default: private */
+    storageMode?: "private" | "public" | "network";
+    /** Auth scheme: 0 = RpoFalcon512, 1 = EcdsaK256Keccak. Default: 0 */
+    authScheme?: 0 | 1;
+}
+type ImportAccountOptions = {
+    type: "file";
+    file: AccountFile | Uint8Array | ArrayBuffer;
+} | {
+    type: "id";
+    accountId: string | AccountId;
+} | {
+    type: "seed";
+    seed: Uint8Array;
+    mutable?: boolean;
+    authScheme?: 0 | 1;
+};
+interface SendOptions {
+    /** Sender account ID */
+    from: string;
+    /** Recipient account ID */
+    to: string;
+    /** Asset ID to send (token id) */
+    assetId: string;
+    /** Amount to send */
+    amount: bigint;
+    /** Note type. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+    /** Block height after which sender can reclaim note */
+    recallHeight?: number;
+    /** Block height after which recipient can consume note */
+    timelockHeight?: number;
+}
+interface MultiSendRecipient {
+    /** Recipient account ID */
+    to: string;
+    /** Amount to send */
+    amount: bigint;
+}
+interface MultiSendOptions {
+    /** Sender account ID */
+    from: string;
+    /** Asset ID to send (token id) */
+    assetId: string;
+    /** Recipient list */
+    recipients: MultiSendRecipient[];
+    /** Note type. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+}
+interface InternalTransferOptions {
+    /** Sender account ID */
+    from: string;
+    /** Recipient account ID */
+    to: string;
+    /** Asset ID to send (token id) */
+    assetId: string;
+    /** Amount to transfer */
+    amount: bigint;
+    /** Note type. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+}
+interface InternalTransferChainOptions {
+    /** Initial sender account ID */
+    from: string;
+    /** Ordered list of recipient account IDs */
+    recipients: string[];
+    /** Asset ID to send (token id) */
+    assetId: string;
+    /** Amount to transfer per hop */
+    amount: bigint;
+    /** Note type. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+}
+interface InternalTransferResult {
+    createTransactionId: string;
+    consumeTransactionId: string;
+    noteId: string;
+}
+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: string;
+    /** 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: string;
+    /** Faucet account to mint from */
+    faucetId: string;
+    /** Amount to mint */
+    amount: bigint;
+    /** Note type. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+}
+interface ConsumeOptions {
+    /** Account ID that will consume the notes */
+    accountId: string;
+    /** List of note IDs to consume */
+    noteIds: string[];
+}
+interface SwapOptions {
+    /** Account initiating the swap */
+    accountId: string;
+    /** Faucet ID of the offered asset */
+    offeredFaucetId: string;
+    /** Amount being offered */
+    offeredAmount: bigint;
+    /** Faucet ID of the requested asset */
+    requestedFaucetId: string;
+    /** Amount being requested */
+    requestedAmount: bigint;
+    /** Note type for swap note. Default: private */
+    noteType?: "private" | "public" | "encrypted";
+    /** Note type for payback note. Default: private */
+    paybackNoteType?: "private" | "public" | "encrypted";
+}
+interface ExecuteTransactionOptions {
+    /** Account ID the transaction applies to */
+    accountId: string | AccountId;
+    /** Transaction request or builder */
+    request: TransactionRequest | ((client: WebClient) => TransactionRequest | Promise<TransactionRequest>);
+}
+interface TransactionResult {
+    transactionId: string;
+}
+declare const DEFAULTS: {
+    readonly RPC_URL: undefined;
+    readonly AUTO_SYNC_INTERVAL: 15000;
+    readonly STORAGE_MODE: "private";
+    readonly WALLET_MUTABLE: true;
+    readonly AUTH_SCHEME: 0;
+    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: WebClient | null;
+    isReady: boolean;
+    isInitializing: boolean;
+    error: Error | null;
+    sync: () => Promise<void>;
+    runExclusive: <T>(fn: () => Promise<T>) => Promise<T>;
+    prover: ReturnType<typeof resolveTransactionProver>;
+}
+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(): WebClient;
+
+/**
+ * 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: string | AccountId | 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 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<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 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 UseInternalTransferResult {
+    /** Create a P2ID note and immediately consume it with another account */
+    transfer: (options: InternalTransferOptions) => Promise<InternalTransferResult>;
+    /** Perform a chain of P2ID transfers across multiple accounts */
+    transferChain: (options: InternalTransferChainOptions) => Promise<InternalTransferResult[]>;
+    /** The last transfer result(s) */
+    result: InternalTransferResult | InternalTransferResult[] | null;
+    /** Whether the transfer is in progress */
+    isLoading: boolean;
+    /** Current stage of the transfer */
+    stage: TransactionStage;
+    /** Error if transfer failed */
+    error: Error | null;
+    /** Reset the hook state */
+    reset: () => void;
+}
+/**
+ * Hook to create a P2ID note and immediately consume it.
+ *
+ * @example
+ * ```tsx
+ * function InternalTransferButton() {
+ *   const { transfer, isLoading, stage } = useInternalTransfer();
+ *
+ *   const handleTransfer = async () => {
+ *     await transfer({
+ *       from: "mtst1...",
+ *       to: "0x...",
+ *       assetId: "0x...",
+ *       amount: 50n,
+ *       noteType: "public",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleTransfer} disabled={isLoading}>
+ *       {isLoading ? stage : "Transfer"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useInternalTransfer(): UseInternalTransferResult;
+
+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, noteIds }: Props) {
+ *   const { consume, isLoading, stage, error } = useConsume();
+ *
+ *   const handleConsume = async () => {
+ *     try {
+ *       const result = await consume({
+ *         accountId,
+ *         noteIds,
+ *       });
+ *       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.
+ *
+ * @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
+ *         ),
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={isLoading}>
+ *       {isLoading ? stage : "Run Transaction"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useTransaction(): UseTransactionResult;
+
+declare const toBech32AccountId: (accountId: string) => string;
+
+declare const formatAssetAmount: (amount: bigint, 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;
+
+export { type AccountResult, type AccountsResult, type AssetBalance, type AssetMetadata, type ConsumeOptions, type CreateFaucetOptions, type CreateWalletOptions, DEFAULTS, type ExecuteTransactionOptions, type ImportAccountOptions, type InternalTransferChainOptions, type InternalTransferOptions, type InternalTransferResult, type MidenConfig, MidenProvider, type MidenState, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MutationResult, type NoteAsset, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverUrls, type QueryResult, type RpcUrlConfig, type SendOptions, type SwapOptions, type SyncState, type TransactionHistoryOptions, type TransactionHistoryResult, type TransactionResult, type TransactionStage, type TransactionStatus, type UseConsumeResult, type UseCreateFaucetResult, type UseCreateWalletResult, type UseImportAccountResult, type UseInternalTransferResult, type UseMintResult, type UseMultiSendResult, type UseSendResult, type UseSwapResult, type UseSyncStateResult, type UseTransactionHistoryResult, type UseTransactionResult, type UseWaitForCommitResult, type UseWaitForNotesResult, type WaitForCommitOptions, type WaitForNotesOptions, formatAssetAmount, formatNoteSummary, getNoteSummary, parseAssetAmount, toBech32AccountId, useAccount, useAccounts, useAssetMetadata, useConsume, useCreateFaucet, useCreateWallet, useImportAccount, useInternalTransfer, useMiden, useMidenClient, useMint, useMultiSend, useNotes, useSend, useSwap, useSyncState, useTransaction, useTransactionHistory, useWaitForCommit, useWaitForNotes };