@miden-sdk/react 0.13.3 → 0.14.0

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { AccountStorageMode, AccountComponent, Account, AccountHeader, AccountId, TransactionRequest, WebClient, AccountFile, InputNoteRecord, ConsumableNoteRecord, TransactionId, TransactionFilter, TransactionRecord, TransactionProver, NoteAttachment } from '@miden-sdk/miden-sdk';
-export { Account, AccountFile, AccountHeader, AccountId, AccountStorageMode, ConsumableNoteRecord, InputNoteRecord, NoteType, TransactionFilter, TransactionId, TransactionRecord, TransactionRequest, 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, TransactionId, TransactionFilter, TransactionRecord, TransactionProver, 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 {
@@ -11,6 +11,9 @@ declare module "@miden-sdk/miden-sdk" {
     }
 }
 
+/** 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.
@@ -20,6 +23,22 @@ declare module "@miden-sdk/miden-sdk" {
  * @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.
@@ -40,6 +59,12 @@ interface SignerAccountConfig {
     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.).
@@ -49,6 +74,10 @@ interface SignerAccountConfig {
 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") */
@@ -87,10 +116,21 @@ declare const SignerContext: react.Context<SignerContextValue | null>;
 declare function useSigner(): SignerContextValue | null;
 
 type RpcUrlConfig = string | "devnet" | "testnet" | "localhost" | "local";
-type ProverConfig = "local" | "devnet" | "testnet" | string | {
+/** 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;
@@ -112,7 +152,7 @@ interface MidenConfig {
     proverTimeoutMs?: number | bigint;
 }
 interface MidenState {
-    client: WebClient | null;
+    client: WasmWebClient | null;
     isReady: boolean;
     isInitializing: boolean;
     error: Error | null;
@@ -162,7 +202,7 @@ interface AssetBalance {
 }
 interface NotesFilter {
     status?: "all" | "consumed" | "committed" | "expected" | "processing";
-    accountId?: string;
+    accountId?: AccountRef;
     /** Only notes from this sender (any format, normalized internally) */
     sender?: string;
     /** Exclude these note IDs */
@@ -216,11 +256,11 @@ interface NoteSummary {
 }
 interface CreateWalletOptions {
     /** Storage mode. Default: private */
-    storageMode?: "private" | "public" | "network";
+    storageMode?: StorageMode;
     /** Whether code can be updated. Default: true */
     mutable?: boolean;
-    /** Auth scheme: 0 = RpoFalcon512, 1 = EcdsaK256Keccak. Default: 0 */
-    authScheme?: 0 | 1;
+    /** Auth scheme. Default: AuthScheme.AuthRpoFalcon512 */
+    authScheme?: AuthScheme;
     /** Initial seed for deterministic account ID */
     initSeed?: Uint8Array;
 }
@@ -230,35 +270,35 @@ interface CreateFaucetOptions {
     /** Number of decimals. Default: 8 */
     decimals?: number;
     /** Maximum supply */
-    maxSupply: bigint;
+    maxSupply: bigint | number;
     /** Storage mode. Default: private */
-    storageMode?: "private" | "public" | "network";
-    /** Auth scheme: 0 = RpoFalcon512, 1 = EcdsaK256Keccak. Default: 0 */
-    authScheme?: 0 | 1;
+    storageMode?: StorageMode;
+    /** Auth scheme. Default: AuthScheme.AuthRpoFalcon512 */
+    authScheme?: AuthScheme;
 }
 type ImportAccountOptions = {
     type: "file";
     file: AccountFile | Uint8Array | ArrayBuffer;
 } | {
     type: "id";
-    accountId: string | AccountId;
+    accountId: AccountRef;
 } | {
     type: "seed";
     seed: Uint8Array;
     mutable?: boolean;
-    authScheme?: 0 | 1;
+    authScheme?: AuthScheme;
 };
 interface SendOptions {
     /** Sender account ID */
-    from: string;
+    from: AccountRef;
     /** Recipient account ID */
-    to: string;
+    to: AccountRef;
     /** Asset ID to send (token id) */
-    assetId: string;
+    assetId: AccountRef;
     /** Amount to send (ignored when sendAll is true) */
-    amount?: bigint;
+    amount?: bigint | number;
     /** Note type. Default: private */
-    noteType?: "private" | "public";
+    noteType?: NoteVisibility;
     /** Block height after which sender can reclaim note */
     recallHeight?: number;
     /** Block height after which recipient can consume note */
@@ -269,12 +309,18 @@ interface SendOptions {
     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: string;
+    to: AccountRef;
     /** Amount to send */
-    amount: bigint;
+    amount: bigint | number;
     /** Per-recipient note type override */
     noteType?: "private" | "public";
     /** Per-recipient attachment */
@@ -282,45 +328,16 @@ interface MultiSendRecipient {
 }
 interface MultiSendOptions {
     /** Sender account ID */
-    from: string;
+    from: AccountRef;
     /** Asset ID to send (token id) */
-    assetId: string;
+    assetId: AccountRef;
     /** Recipient list */
     recipients: MultiSendRecipient[];
     /** Default note type for all recipients. Default: private */
-    noteType?: "private" | "public";
+    noteType?: NoteVisibility;
     /** Skip auto-sync before send. Default: false */
     skipSync?: boolean;
 }
-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";
-}
-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";
-}
-interface InternalTransferResult {
-    createTransactionId: string;
-    consumeTransactionId: string;
-    noteId: string;
-}
 interface WaitForCommitOptions {
     /** Timeout in milliseconds. Default: 10000 */
     timeoutMs?: number;
@@ -329,7 +346,7 @@ interface WaitForCommitOptions {
 }
 interface WaitForNotesOptions {
     /** Account ID to check for consumable notes */
-    accountId: string;
+    accountId: AccountRef;
     /** Minimum number of notes to wait for. Default: 1 */
     minCount?: number;
     /** Timeout in milliseconds. Default: 10000 */
@@ -339,47 +356,72 @@ interface WaitForNotesOptions {
 }
 interface MintOptions {
     /** Target account to receive minted tokens */
-    targetAccountId: string;
+    targetAccountId: AccountRef;
     /** Faucet account to mint from */
-    faucetId: string;
+    faucetId: AccountRef;
     /** Amount to mint */
-    amount: bigint;
+    amount: bigint | number;
     /** Note type. Default: private */
-    noteType?: "private" | "public";
+    noteType?: NoteVisibility;
 }
 interface ConsumeOptions {
     /** Account ID that will consume the notes */
     accountId: string;
-    /** List of note IDs to consume */
-    noteIds: 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: string;
+    accountId: AccountRef;
     /** Faucet ID of the offered asset */
-    offeredFaucetId: string;
+    offeredFaucetId: AccountRef;
     /** Amount being offered */
-    offeredAmount: bigint;
+    offeredAmount: bigint | number;
     /** Faucet ID of the requested asset */
-    requestedFaucetId: string;
+    requestedFaucetId: AccountRef;
     /** Amount being requested */
-    requestedAmount: bigint;
+    requestedAmount: bigint | number;
     /** Note type for swap note. Default: private */
-    noteType?: "private" | "public";
+    noteType?: NoteVisibility;
     /** Note type for payback note. Default: private */
-    paybackNoteType?: "private" | "public";
+    paybackNoteType?: NoteVisibility;
 }
 interface ExecuteTransactionOptions {
     /** Account ID the transaction applies to */
-    accountId: string | AccountId;
+    accountId: AccountRef;
     /** Transaction request or builder */
-    request: TransactionRequest | ((client: WebClient) => TransactionRequest | Promise<TransactionRequest>);
+    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;
@@ -434,7 +476,7 @@ interface UseSessionAccountOptions {
     walletOptions?: {
         storageMode?: "private" | "public";
         mutable?: boolean;
-        authScheme?: 0 | 1;
+        authScheme?: AuthScheme;
     };
     /** Polling interval for funding note detection (ms). Default: 3000 */
     pollIntervalMs?: number;
@@ -463,7 +505,7 @@ declare const DEFAULTS: {
     readonly AUTO_SYNC_INTERVAL: 15000;
     readonly STORAGE_MODE: "private";
     readonly WALLET_MUTABLE: true;
-    readonly AUTH_SCHEME: 0;
+    readonly AUTH_SCHEME: AuthScheme.AuthRpoFalcon512;
     readonly NOTE_TYPE: "private";
     readonly FAUCET_DECIMALS: 8;
 };
@@ -472,7 +514,7 @@ type ProverConfigSubset = Pick<MidenConfig, "prover" | "proverUrls" | "proverTim
 declare function resolveTransactionProver(config: ProverConfigSubset): TransactionProver | null;
 
 interface MidenContextValue {
-    client: WebClient | null;
+    client: WasmWebClient | null;
     isReady: boolean;
     isInitializing: boolean;
     error: Error | null;
@@ -481,6 +523,8 @@ interface MidenContextValue {
     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;
@@ -492,7 +536,38 @@ interface MidenProviderProps {
 }
 declare function MidenProvider({ children, config, loadingComponent, errorComponent, }: MidenProviderProps): react_jsx_runtime.JSX.Element;
 declare function useMiden(): MidenContextValue;
-declare function useMidenClient(): WebClient;
+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.
@@ -547,7 +622,7 @@ declare function useAccounts(): AccountsResult;
  * }
  * ```
  */
-declare function useAccount(accountId: string | AccountId | undefined): AccountResult;
+declare function useAccount(accountId: AccountRef | undefined): AccountResult;
 
 /**
  * Hook to list notes.
@@ -790,9 +865,9 @@ declare function useImportAccount(): UseImportAccountResult;
 
 interface UseSendResult {
     /** Send tokens from one account to another */
-    send: (options: SendOptions) => Promise<TransactionResult>;
+    send: (options: SendOptions) => Promise<SendResult>;
     /** The transaction result */
-    result: TransactionResult | null;
+    result: SendResult | null;
     /** Whether the transaction is in progress */
     isLoading: boolean;
     /** Current stage of the transaction */
@@ -878,50 +953,6 @@ interface UseMultiSendResult {
  */
 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>;
@@ -998,14 +1029,14 @@ interface UseConsumeResult {
  *
  * @example
  * ```tsx
- * function ConsumeNotesButton({ accountId, noteIds }: Props) {
+ * function ConsumeNotesButton({ accountId, notes }: Props) {
  *   const { consume, isLoading, stage, error } = useConsume();
  *
  *   const handleConsume = async () => {
  *     try {
  *       const result = await consume({
  *         accountId,
- *         noteIds,
+ *         notes,
  *       });
  *       console.log('Consumed! TX:', result.transactionId);
  *     } catch (err) {
@@ -1087,6 +1118,10 @@ interface UseTransactionResult {
 /**
  * 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 }) {
@@ -1105,6 +1140,7 @@ interface UseTransactionResult {
  *           NoteType.Private,
  *           NoteType.Private
  *         ),
+ *       privateNoteTarget: "0xrecipient...",
  *     });
  *   };
  *
@@ -1118,6 +1154,20 @@ interface UseTransactionResult {
  */
 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;
+
 /**
  * Hook to manage a session wallet lifecycle: create -> fund -> consume.
  *
@@ -1149,9 +1199,174 @@ declare function useTransaction(): UseTransactionResult;
  */
 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, decimals?: number) => 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;
@@ -1252,4 +1467,4 @@ declare function createMidenStorage(prefix: string): {
     clear(): void;
 };
 
-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, MidenError, type MidenErrorCode, MidenProvider, type MidenState, type MigrateStorageOptions, type MintOptions, type MultiSendOptions, type MultiSendRecipient, type MutationResult, type NoteAsset, type NoteAttachmentData, type NoteSummary, type NotesFilter, type NotesResult, type ProverConfig, type ProverUrls, type QueryResult, type RpcUrlConfig, type SendOptions, type SessionAccountStep, type SignCallback, type SignerAccountConfig, type SignerAccountType, SignerContext, type SignerContextValue, type StreamedNote, 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 UseNoteStreamOptions, type UseNoteStreamReturn, type UseSendResult, type UseSessionAccountOptions, type UseSessionAccountReturn, type UseSwapResult, 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, useConsume, useCreateFaucet, useCreateWallet, useImportAccount, useInternalTransfer, useMiden, useMidenClient, useMint, useMultiSend, useNoteStream, useNotes, useSend, useSessionAccount, useSigner, useSwap, 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 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 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, 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 };