@chipi-stack/chipi-react 14.7.0 → 14.9.0

package/dist/index-B8e6TdyG.d.mts

@@ -0,0 +1,2743 @@
+import { CreateWalletParams, CreateWalletResponse, GetWalletParams, GetWalletResponse, ChainToken, GetTokenBalanceResponse, WalletType, WalletData, SessionKeyData, SessionDataResponse, CreateSessionKeyParams, SessionConfig, Call as Call$1, SpendingPolicyConfig, SpendingPolicyData, MigrateWalletToPasskeyParams, UpdateWalletEncryptionParams, UpdateWalletEncryptionResponse, TransferHookInput, ApproveHookInput, GetTransactionListQuery, PaginatedResponse, Transaction, TransactionStatusResponse, SyncOnChainTransfersParams, SyncOnChainTransfersResponse, CreateSkuPurchaseParams, GetSkuListQuery, Sku, CallAnyContractParams, SignTypedDataParams, RecordSendTransactionParams, GetTokenBalanceParams, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, ExecuteWithSessionParams, PaymentRequirement, PaymentPayload } from '@chipi-stack/types';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { MigrateChipiWalletToShhhParams, MigrationOutcome, Eip191Pubkey, WebAuthnPubkey, JwtAppleSubPubkey, NewOwnerInput, buildProposeAddOwnerCall, TIMELOCK_SECONDS, DEFAULT_OP_EXPIRY_SECONDS, ROLE_OWNER, ROLE_GUARDIAN, OP_ADD_OWNER, OP_REMOVE_OWNER, OP_ROTATE_OWNER, OP_SET_THRESHOLD, ShhhSignerKind, MIN_THRESHOLD_OWNERS } from '@chipi-stack/backend';
+import { Call as Call$2 } from 'starknet';
+import { TypedData, AccountDeploymentData } from '@starknet-io/types-js';
+
+type CreateWalletInput = {
+    params: CreateWalletParams;
+    bearerToken: string;
+};
+/**
+ * Hook for creating a new wallet.
+ *
+ * Supports dual-key wrapping: when `usePasskey: true` AND `encryptKey` (PIN) provided,
+ * the private key is encrypted twice — once with the passkey-derived key (primary) and
+ * once with the PIN (backup). If passkey fails later, PIN recovers the wallet.
+ *
+ * @example
+ * ```tsx
+ * // Passkey + PIN (recommended)
+ * await createWalletAsync({
+ *   params: {
+ *     encryptKey: pin,        // PIN backup
+ *     externalUserId: userId,
+ *     chain: Chain.STARKNET,
+ *     usePasskey: true,       // Creates passkey + dual encryption
+ *   },
+ *   bearerToken,
+ * });
+ *
+ * // PIN only (backward compatible)
+ * await createWalletAsync({
+ *   params: {
+ *     encryptKey: pin,
+ *     externalUserId: userId,
+ *     chain: Chain.STARKNET,
+ *   },
+ *   bearerToken,
+ * });
+ * ```
+ */
+declare function useCreateWallet(): {
+    createWallet: (input: CreateWalletInput) => void;
+    createWalletAsync: (input: CreateWalletInput) => Promise<CreateWalletResponse>;
+    data: CreateWalletResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type GetWalletInput = {
+    params?: GetWalletParams;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<GetWalletResponse | null, Error>, "queryKey" | "queryFn">;
+};
+declare function useGetWallet(input?: GetWalletInput): {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+} | {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+} | {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+} | {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+} | {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+} | {
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetWalletResponse | null>;
+};
+
+/**
+ * Configuration for useChipiWallet hook
+ */
+interface UseChipiWalletConfig {
+    /** External user ID (e.g., from Clerk, Firebase, etc.) */
+    externalUserId: string | null | undefined;
+    /** Function to get the bearer token for API calls */
+    getBearerToken: () => Promise<string | null | undefined>;
+    /** Default token for balance display (defaults to USDC) */
+    defaultToken?: ChainToken;
+    /** Whether to automatically fetch wallet on mount */
+    enabled?: boolean;
+}
+/**
+ * Extended wallet response with additional computed properties
+ */
+interface ChipiWalletData extends GetWalletResponse {
+    /** Whether this wallet supports session keys */
+    supportsSessionKeys: boolean;
+    /** Formatted short address for display */
+    shortAddress: string;
+}
+/**
+ * Return type for useChipiWallet hook
+ */
+interface UseChipiWalletReturn {
+    /** The user's wallet data, null if not found, undefined if loading */
+    wallet: ChipiWalletData | null | undefined;
+    /** Whether the user has a wallet */
+    hasWallet: boolean;
+    /** Whether the wallet is currently being fetched */
+    isLoadingWallet: boolean;
+    /** Error from fetching wallet */
+    walletError: Error | null;
+    /** The wallet's balance for the default token */
+    balance: GetTokenBalanceResponse | undefined;
+    /** Formatted balance string (e.g., "100.50") */
+    formattedBalance: string;
+    /** Whether balance is loading */
+    isLoadingBalance: boolean;
+    /** Create a new wallet */
+    createWallet: (params: {
+        encryptKey: string;
+        walletType?: WalletType;
+    }) => Promise<CreateWalletResponse>;
+    /** Whether wallet creation is in progress */
+    isCreating: boolean;
+    /** Data from the last wallet creation */
+    createdWallet: CreateWalletResponse | undefined;
+    /** Refetch the wallet data */
+    refetchWallet: () => Promise<void>;
+    /** Refetch the balance */
+    refetchBalance: () => Promise<void>;
+    /** Refetch both wallet and balance */
+    refetchAll: () => Promise<void>;
+}
+/**
+ * All-in-one wallet hook for Chipi SDK.
+ *
+ * Combines wallet fetching, creation, and balance checking into a single hook
+ * for simplified wallet management.
+ *
+ * @example
+ * ```tsx
+ * import { useAuth } from "@clerk/nextjs";
+ * import { useChipiWallet } from "@chipi-stack/nextjs";
+ *
+ * function WalletComponent() {
+ *   const { userId, getToken } = useAuth();
+ *   const {
+ *     wallet,
+ *     hasWallet,
+ *     balance,
+ *     formattedBalance,
+ *     createWallet,
+ *     isCreating,
+ *     isLoadingWallet,
+ *   } = useChipiWallet({
+ *     externalUserId: userId,
+ *     getBearerToken: getToken,
+ *   });
+ *
+ *   if (isLoadingWallet) return <div>Loading...</div>;
+ *
+ *   if (!hasWallet) {
+ *     return (
+ *       <button
+ *         onClick={() => createWallet({ encryptKey: "1234" })}
+ *         disabled={isCreating}
+ *       >
+ *         {isCreating ? "Creating..." : "Create Wallet"}
+ *       </button>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Address: {wallet?.shortAddress}</p>
+ *       <p>Balance: ${formattedBalance} USDC</p>
+ *       <p>Session Keys: {wallet?.supportsSessionKeys ? "Yes" : "No"}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useChipiWallet(config: UseChipiWalletConfig): UseChipiWalletReturn;
+
+/**
+ * Wallet data with optional wallet type for session operations
+ */
+interface SessionWallet extends WalletData {
+    walletType?: WalletType;
+}
+/**
+ * Configuration for useChipiSession hook
+ */
+interface UseChipiSessionConfig {
+    /** Wallet data (must be a CHIPI wallet for session support) */
+    wallet: SessionWallet | null | undefined;
+    /** Encryption key (user's PIN) for signing operations */
+    encryptKey: string;
+    /** Function to get the bearer token for API calls */
+    getBearerToken: () => Promise<string | null | undefined>;
+    /** Previously stored session data (from Clerk metadata, database, etc.) */
+    storedSession?: SessionKeyData | null;
+    /** Callback fired when a new session is created (for persistence) */
+    onSessionCreated?: (session: SessionKeyData) => void | Promise<void>;
+    /** Session duration in seconds (default: 6 hours) */
+    defaultDurationSeconds?: number;
+    /** Default max calls for session registration (default: 1000) */
+    defaultMaxCalls?: number;
+    /** Whether to auto-check session status on mount */
+    autoCheckStatus?: boolean;
+}
+/**
+ * Session lifecycle state
+ */
+type SessionState = "none" | "created" | "active" | "expired" | "revoked";
+/**
+ * Return type for useChipiSession hook
+ */
+interface UseChipiSessionReturn {
+    /** Current session key data */
+    session: SessionKeyData | null;
+    /** On-chain session status (from contract query) */
+    sessionStatus: SessionDataResponse | undefined;
+    /** Current session lifecycle state */
+    sessionState: SessionState;
+    /** Whether there is an active, usable session */
+    hasActiveSession: boolean;
+    /** Whether the session has expired */
+    isSessionExpired: boolean;
+    /** Remaining calls available for the session */
+    remainingCalls: number | undefined;
+    /** Whether the wallet supports sessions (CHIPI wallet) */
+    supportsSession: boolean;
+    /** Create a new session keypair locally (does NOT register on-chain) */
+    createSession: (config?: Partial<CreateSessionKeyParams>) => Promise<SessionKeyData>;
+    /** Register the current session on the blockchain */
+    registerSession: (config?: Partial<SessionConfig>) => Promise<string>;
+    /** Revoke the current session from the blockchain */
+    revokeSession: () => Promise<string>;
+    /** Execute calls using the session key (no owner signature needed) */
+    executeWithSession: (calls: Call$1[]) => Promise<string>;
+    /** Clear the current session from local state */
+    clearSession: () => void;
+    /** Refresh the on-chain session status */
+    refetchStatus: () => Promise<void>;
+    /** Set a spending policy for the current session + token pair */
+    setSpendingPolicy: (config: Omit<SpendingPolicyConfig, "sessionPublicKey">) => Promise<string>;
+    /** Query the spending policy for a token (read-only, no gas) */
+    getSpendingPolicy: (token: string) => Promise<SpendingPolicyData>;
+    /** Remove a spending policy for a token */
+    removeSpendingPolicy: (token: string) => Promise<string>;
+    isCreating: boolean;
+    isRegistering: boolean;
+    isRevoking: boolean;
+    isExecuting: boolean;
+    isLoadingStatus: boolean;
+    isSettingSpendingPolicy: boolean;
+    isRemovingSpendingPolicy: boolean;
+    error: Error | null;
+}
+/**
+ * All-in-one session management hook for Chipi SDK.
+ *
+ * Combines session creation, registration, execution, and revocation
+ * into a single unified API. Session keys enable gasless transactions
+ * without requiring the owner's private key for each operation.
+ *
+ * **Important:** Sessions only work with CHIPI wallets. ARGENT wallets
+ * do not support session keys.
+ *
+ * @example
+ * ```tsx
+ * import { useAuth } from "@clerk/nextjs";
+ * import { useChipiWallet, useChipiSession } from "@chipi-stack/nextjs";
+ *
+ * function SessionComponent() {
+ *   const { userId, getToken } = useAuth();
+ *   const [pin, setPin] = useState("");
+ *   const { wallet } = useChipiWallet({ externalUserId: userId, getBearerToken: getToken });
+ *
+ *   const {
+ *     session,
+ *     hasActiveSession,
+ *     sessionState,
+ *     createSession,
+ *     registerSession,
+ *     executeWithSession,
+ *     isCreating,
+ *     isRegistering,
+ *   } = useChipiSession({
+ *     wallet,
+ *     encryptKey: pin,
+ *     getBearerToken: getToken,
+ *     onSessionCreated: async (newSession) => {
+ *       // Persist to Clerk metadata or database
+ *       await saveSessionToClerk(newSession);
+ *     },
+ *   });
+ *
+ *   const handleSetupSession = async () => {
+ *     // Step 1: Create session locally
+ *     await createSession();
+ *     // Step 2: Register on-chain
+ *     await registerSession();
+ *   };
+ *
+ *   const handleTransfer = async () => {
+ *     // Execute transfer using session (no PIN needed after setup)
+ *     await executeWithSession([{
+ *       contractAddress: USDC_ADDRESS,
+ *       entrypoint: "transfer",
+ *       calldata: [recipient, amount, "0x0"],
+ *     }]);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Session State: {sessionState}</p>
+ *       {!hasActiveSession ? (
+ *         <button onClick={handleSetupSession} disabled={isCreating || isRegistering}>
+ *           Setup Session
+ *         </button>
+ *       ) : (
+ *         <button onClick={handleTransfer}>
+ *           Transfer (Gasless)
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useChipiSession(config: UseChipiSessionConfig): UseChipiSessionReturn;
+
+type MigrateWalletToPasskeyInput = MigrateWalletToPasskeyParams & {
+    bearerToken: string;
+};
+interface MigrateWalletToPasskeyResult {
+    success: boolean;
+    wallet: WalletData;
+    credentialId: string;
+}
+/**
+ * Hook for migrating a wallet from encryptKey (PIN) to passkey authentication
+ */
+declare function useMigrateWalletToPasskey(): {
+    migrateWalletToPasskey: (input: MigrateWalletToPasskeyInput) => void;
+    migrateWalletToPasskeyAsync: (input: MigrateWalletToPasskeyInput) => Promise<MigrateWalletToPasskeyResult>;
+    data: MigrateWalletToPasskeyResult | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type UpdateWalletEncryptionInput = UpdateWalletEncryptionParams & {
+    bearerToken: string;
+};
+/**
+ * Hook for updating a wallet's encrypted private key.
+ * Use when the user changes their passkey or PIN; the client re-encrypts the private key
+ * and sends the new ciphertext here.
+ */
+declare function useUpdateWalletEncryption(): {
+    updateWalletEncryption: (input: UpdateWalletEncryptionInput) => void;
+    updateWalletEncryptionAsync: (input: UpdateWalletEncryptionInput) => Promise<UpdateWalletEncryptionResponse>;
+    data: UpdateWalletEncryptionResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * Input for the migration mutation.
+ *
+ * Drops `client` and `bearerToken` from the SDK-level params (the
+ * hook reads them from context + the input below) and treats the
+ * rest the same as the SDK call. The hook does NOT touch passkey /
+ * PIN orchestration — callers are responsible for handing in the
+ * already-resolved `encryptKey`. For the dashboard flow this means
+ * showing the PIN/passkey prompt yourself and passing the result
+ * here.
+ */
+type MigrateInput = Omit<MigrateChipiWalletToShhhParams, "client" | "bearerToken"> & {
+    bearerToken: string;
+};
+/**
+ * Hook for migrating a CHIPI v29 wallet to SHHH V8.4.
+ *
+ * Wraps the `migrateChipiWalletToShhh` backend SDK function (which
+ * itself composes chipi-back's prepare + execute endpoints with
+ * client-side V8.4 OE signing). The PIN/passkey unwrap step happens
+ * before this hook is called; the migration multicall is signed
+ * locally with the resulting STARK key and the cleartext key never
+ * leaves the device.
+ *
+ * Two terminal outcomes the consumer must handle:
+ *   - `{ kind: "MIGRATED", transactionHash, ... }` — happy path,
+ *     on-chain tx landed and DB row is patched. If `partial: true`,
+ *     the on-chain tx succeeded but the chipi-back DB patch failed;
+ *     the operator runbook's reconciler cron (task #30) will catch
+ *     up automatically. Dashboard should surface "wallet upgraded;
+ *     refresh in a moment" copy in both sub-cases.
+ *   - `{ kind: "ALREADY_MIGRATED", primaryKind, ... }` — chipi-back
+ *     detected the wallet was already SHHH on chain and patched the
+ *     DB row on the way out. No on-chain tx fired. Dashboard should
+ *     surface "this wallet is already on V8.4" and refresh the
+ *     wallet shape.
+ *
+ * Throws (surfaces via `error`) on:
+ *   - STRANDED-state recovery (different signing flow, not in PR A)
+ *   - UNDEPLOYED wallets (caller should redirect to createWallet)
+ *   - DEFERRED legacy versions (v28/v33; not yet supported)
+ *   - Mismatched encryptKey (decryption fails)
+ *   - chipi-back kill switch off (`CHIPI_MIGRATION_ENABLED` not set)
+ *
+ * @example
+ * ```tsx
+ * const { migrateAsync, isLoading, error } = useMigrateWalletToShhh();
+ *
+ * async function onClickMigrate() {
+ *   const encryptKey = await promptForPin();   // or passkey unlock
+ *   const outcome = await migrateAsync({
+ *     walletId: wallet.id,
+ *     externalUserId: user.id,
+ *     wallet: { publicKey: wallet.publicKey, encryptedPrivateKey: wallet.encryptedPrivateKey },
+ *     encryptKey,
+ *     bearerToken,
+ *   });
+ *   if (outcome.kind === "MIGRATED") {
+ *     showToast(`Wallet upgraded — tx ${outcome.transactionHash}`);
+ *   } else {
+ *     showToast(`Wallet was already on V8.4 (${outcome.primaryKind})`);
+ *   }
+ * }
+ * ```
+ */
+declare function useMigrateWalletToShhh(): {
+    migrate: (input: MigrateInput) => void;
+    migrateAsync: (input: MigrateInput) => Promise<MigrationOutcome>;
+    data: MigrationOutcome | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type TransferInput = {
+    params: TransferHookInput;
+    bearerToken: string;
+};
+/**
+ * Configuration for useTransfer hook.
+ */
+interface UseTransferConfig {
+    /**
+     * Callback to prompt user for PIN when passkey fails.
+     * Should show a PIN input dialog and return the PIN, or null to cancel.
+     * Only called when usePasskey: true and passkey auth fails.
+     */
+    onPinRequired?: () => Promise<string | null>;
+}
+/**
+ * Hook for transferring tokens.
+ *
+ * When `usePasskey: true`:
+ * 1. Tries passkey authentication first
+ * 2. If passkey fails and wallet has `encryptedPrivateKeyBackup`:
+ *    calls `onPinRequired` to get PIN, uses PIN to decrypt backup
+ * 3. If no backup or no `onPinRequired`, throws
+ *
+ * @example
+ * ```tsx
+ * const { transferAsync } = useTransfer({
+ *   onPinRequired: async () => {
+ *     // Show PIN dialog, return PIN or null to cancel
+ *     return await showPinDialog();
+ *   },
+ * });
+ * ```
+ */
+declare function useTransfer(config?: UseTransferConfig): {
+    transfer: (input: TransferInput) => void;
+    transferAsync: (input: TransferInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type ApproveInput = {
+    params: ApproveHookInput;
+    bearerToken: string;
+};
+/**
+ * Hook for approving token spending
+ */
+declare function useApprove(): {
+    approve: (params: ApproveInput) => void;
+    approveAsync: (params: ApproveInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type TransactionListInput = {
+    query: GetTransactionListQuery;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<PaginatedResponse<Transaction>, Error>, "queryKey" | "queryFn">;
+};
+type FetchTransactionListInput = {
+    query: GetTransactionListQuery;
+    getBearerToken: () => Promise<string | null | undefined>;
+};
+declare function useGetTransactionList(input?: TransactionListInput): {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: PaginatedResponse<Transaction>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+} | {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: PaginatedResponse<Transaction>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+} | {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+} | {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+} | {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+} | {
+    fetchTransactionList: (newInput: FetchTransactionListInput) => Promise<PaginatedResponse<Transaction>>;
+    data: PaginatedResponse<Transaction>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Transaction>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Transaction>>;
+};
+
+type GetTransactionInput = {
+    hashOrId?: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<Transaction, Error>, "queryKey" | "queryFn">;
+};
+type FetchTransactionInput = {
+    hashOrId: string;
+    getBearerToken: () => Promise<string | null | undefined>;
+};
+declare function useGetTransaction(input?: GetTransactionInput): {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: Transaction;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: Transaction;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchTransaction: (newInput: FetchTransactionInput) => Promise<Transaction>;
+    data: Transaction;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+};
+
+type GetTransactionStatusInput = {
+    hash?: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    /** Polling interval in ms. Defaults to 3000. Set to false to disable polling. */
+    refetchInterval?: number | false;
+    queryOptions?: Omit<UseQueryOptions<TransactionStatusResponse, Error>, "queryKey" | "queryFn" | "refetchInterval">;
+};
+type FetchTransactionStatusInput = {
+    hash: string;
+    getBearerToken: () => Promise<string | null | undefined>;
+};
+declare function useGetTransactionStatus(input?: GetTransactionStatusInput): {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: TransactionStatusResponse;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+} | {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: TransactionStatusResponse;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+} | {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+} | {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+} | {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+} | {
+    fetchTransactionStatus: (newInput: FetchTransactionStatusInput) => Promise<TransactionStatusResponse>;
+    data: TransactionStatusResponse;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TransactionStatusResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<TransactionStatusResponse>;
+};
+
+type SyncOnChainInput = SyncOnChainTransfersParams & {
+    bearerToken: string;
+};
+/**
+ * Hook for syncing on-chain transfers from Voyager into the DB.
+ *
+ * Discovers transactions not made through the SDK (e.g., external USDC receives
+ * from Argent X or other wallets). After sync, useGetTransactionList returns
+ * the newly discovered transactions automatically.
+ *
+ * @example
+ * ```tsx
+ * const { syncTransfers, data, isLoading } = useSyncOnChainTransfers();
+ *
+ * // Sync on-chain transfers for a wallet
+ * const result = await syncTransfersAsync({
+ *   walletAddress: wallet.publicKey,
+ *   bearerToken: await getToken(),
+ * });
+ * console.log(`Synced ${result.synced} new transfers`);
+ * ```
+ */
+declare function useSyncOnChainTransfers(): {
+    syncTransfers: (input: SyncOnChainInput) => void;
+    syncTransfersAsync: (input: SyncOnChainInput) => Promise<SyncOnChainTransfersResponse>;
+    data: SyncOnChainTransfersResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type PurchaseSkuInput = {
+    params: CreateSkuPurchaseParams;
+    bearerToken: string;
+};
+/**
+ * Hook for purchasing SKUs
+ */
+declare function usePurchaseSku(): {
+    purchaseSku: (input: PurchaseSkuInput) => void;
+    purchaseSkuAsync: (input: PurchaseSkuInput) => Promise<Transaction>;
+    data: Transaction | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type GetSkuPurchaseInput = {
+    id: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<Transaction, Error>, "queryKey" | "queryFn">;
+};
+declare function useGetSkuPurchase(input?: GetSkuPurchaseInput): {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: Transaction;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: Transaction;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+} | {
+    fetchSkuPurchase: (newInput: GetSkuPurchaseInput) => Promise<Transaction>;
+    data: Transaction;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Transaction, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Transaction>;
+};
+
+type SkuListInput = {
+    query: GetSkuListQuery;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<PaginatedResponse<Sku>, Error>, "queryKey" | "queryFn">;
+};
+declare function useGetSkuList(input?: SkuListInput): {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: PaginatedResponse<Sku>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+} | {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: PaginatedResponse<Sku>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+} | {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+} | {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+} | {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+} | {
+    fetchSkuList: (newInput: SkuListInput) => Promise<PaginatedResponse<Sku>>;
+    data: PaginatedResponse<Sku>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<PaginatedResponse<Sku>>;
+};
+
+type GetSkuInput = {
+    id: string;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<Sku, Error>, "queryKey" | "queryFn">;
+};
+declare function useGetSku(input?: GetSkuInput): {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: Sku;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+} | {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: Sku;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+} | {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+} | {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+} | {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+} | {
+    fetchSku: (input: GetSkuInput) => Promise<Sku>;
+    data: Sku;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Sku, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Sku>;
+};
+
+type CallAnyContractInput = {
+    params: CallAnyContractParams;
+    bearerToken: string;
+};
+/**
+ * Hook for calling any contract method
+ */
+declare function useCallAnyContract(): {
+    callAnyContract: (params: CallAnyContractInput) => void;
+    callAnyContractAsync: (params: CallAnyContractInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * Sign SNIP-12 typed data and get the full signature span (felt strings) —
+ * the shape a dApp's `wallet_signTypedData` expects. Wallet-type aware: SHHH
+ * returns the V2_SNIP12 owner envelope, standard accounts return `[r, s]`.
+ * Purely local (decrypt + sign) — no API call.
+ */
+declare function useSignTypedData(): {
+    signTypedData: (params: SignTypedDataParams) => void;
+    signTypedDataAsync: (params: SignTypedDataParams) => Promise<string[]>;
+    data: string[] | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * An approval the host (walletv2, the hosted web-wallet, or a harness) must
+ * resolve before the SWO performs a sensitive action. Returning `false`
+ * surfaces a USER_REFUSED_OP error to the dApp. The host renders the UI;
+ * the SWO core stays framework-agnostic.
+ */
+type ChipiApprovalRequest = {
+    type: "connect";
+} | {
+    type: "execute";
+    calls: Call$2[];
+} | {
+    type: "signTypedData";
+    typedData: TypedData;
+} | {
+    /** dApp-proposed session policy shown at connect time (approve once). */
+    type: "session";
+    policy: ChipiSessionPolicy;
+};
+/**
+ * A dApp-proposed session policy. Mirrors the SNIP-163 sessions component the
+ * SHHH/CHIPI accounts enforce on-chain via the 4-felt session signature
+ * `[session_pubkey, r, s, valid_until]`.
+ */
+interface ChipiSessionPolicy {
+    /** Allowed (contractAddress, entrypoint) pairs the session may call. */
+    allowedCalls: Array<{
+        contractAddress: string;
+        entrypoint: string;
+    }>;
+    /** Unix seconds after which the session is invalid. */
+    validUntil: number;
+    /** Optional per-token spend caps, by token address. */
+    spendCaps?: Array<{
+        token: string;
+        amount: string;
+    }>;
+}
+/**
+ * Everything the framework-agnostic SWO needs, supplied by the host layer
+ * (`@chipi-stack/react`'s `useChipiWalletObject`, the hosted web-wallet, etc.).
+ * Keeping these as injected functions is what lets the SWO live in `core`
+ * (depends only on `types`/`starknet`) instead of hard-importing `backend`.
+ */
+interface ChipiWindowObjectDeps {
+    /** Stable wallet id — MUST be `"chipi"` so the injected key, get-starknet
+     * discovery entry, and starknetkit preset all agree. */
+    id?: string;
+    name?: string;
+    version?: string;
+    icon?: string;
+    /** Starknet chain id felt (e.g. SN_MAIN). */
+    chainId: string;
+    /** Resolve the connected account address(es); `[]` when locked/disconnected. */
+    getAccounts: () => Promise<string[]>;
+    /**
+     * Execute the dApp's calls and return the tx hash. The host implements
+     * session-first routing here: in-policy → 4-felt session sig (silent);
+     * out-of-policy/sensitive → owner envelope (passkey prompt). Both gasless.
+     */
+    executeCalls: (calls: Call$2[]) => Promise<string>;
+    /** Sign SNIP-12 typed data → signature felts (envelope-aware for SHHH). */
+    signTypedData: (typedData: TypedData) => Promise<string[]>;
+    /** Counterfactual deployment data for an undeployed account. */
+    getDeploymentData: () => Promise<AccountDeploymentData>;
+    /** Optional: establish a session from a dApp-proposed policy (approve once). */
+    createSession?: (policy: ChipiSessionPolicy) => Promise<void>;
+    /** Host approval gate. Defaults to auto-approve (harness) when omitted. */
+    requestApproval?: (req: ChipiApprovalRequest) => Promise<boolean>;
+}
+
+interface UseChipiWalletObjectConfig {
+    /** The connected Chipi wallet (null when locked / not yet created). */
+    wallet: WalletData | null | undefined;
+    /** Resolve the paymaster bearer token for execution. */
+    getBearerToken: () => Promise<string>;
+    /** Resolve the encryptKey (PIN / passkey-derived). Owner path may prompt;
+     * the host is responsible for any caching that keeps the session path silent. */
+    getEncryptKey: () => Promise<string>;
+    /** Active session (host-managed) — enables session-first routing. */
+    session?: SessionKeyData | null;
+    /** The policy that `session` was registered with — used to decide, client
+     * side, whether a dApp's calls are in-policy (so we don't send a doomed tx). */
+    sessionPolicy?: ChipiSessionPolicy | null;
+    /** Chain id felt; defaults to SN_MAIN. */
+    chainId?: string;
+    /** Host approval gate (connect / execute / signTypedData / session). */
+    requestApproval?: (req: ChipiApprovalRequest) => Promise<boolean>;
+}
+/**
+ * Compose the deps for a Chipi `StarknetWindowObject` from the existing SDK
+ * hooks, with **session-first execution routing**:
+ *  - an in-policy, unexpired session → `useExecuteWithSession` (4-felt session
+ *    sig, no per-tx passkey),
+ *  - otherwise the owner path → `useCallAnyContract` (passkey).
+ * Both gasless via the paymaster. Pass `deps` to `createChipiWindowObject` /
+ * `injectChipiWallet`. `createSession(policy)` establishes a session on-chain
+ * from a dApp-proposed policy (the "approve once" flow); the host stores the
+ * returned SessionKeyData and feeds it back via `config.session`.
+ */
+declare function useChipiWalletObject(config: UseChipiWalletObjectConfig): {
+    deps: ChipiWindowObjectDeps;
+    createSession: (policy: ChipiSessionPolicy) => Promise<SessionKeyData>;
+};
+
+type RecordSendTransactionInput = {
+    params: RecordSendTransactionParams;
+    bearerToken: string;
+};
+declare function useRecordSendTransaction(): {
+    recordSendTransaction: (input: RecordSendTransactionInput) => void;
+    recordSendTransactionAsync: (input: RecordSendTransactionInput) => Promise<Transaction>;
+    data: Transaction | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type GetTokenBalanceInput = {
+    params?: GetTokenBalanceParams;
+    getBearerToken?: () => Promise<string | null | undefined>;
+    queryOptions?: Omit<UseQueryOptions<GetTokenBalanceResponse, Error>, "queryKey" | "queryFn">;
+};
+declare function useGetTokenBalance(input?: GetTokenBalanceInput): {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: GetTokenBalanceResponse;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+} | {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: GetTokenBalanceResponse;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+} | {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+} | {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+} | {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+} | {
+    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
+    data: GetTokenBalanceResponse;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<GetTokenBalanceResponse>;
+};
+
+/**
+ * Hook for creating a session keypair locally.
+ *
+ * This generates session keys but does NOT register them on-chain.
+ * The returned SessionKeyData should be stored by the developer externally
+ * (e.g., in Clerk metadata, database, etc.) - the SDK does NOT persist this.
+ *
+ * After generating, call `useAddSessionKeyToContract` to register the session on-chain.
+ *
+ * @example
+ * ```typescript
+ * const { createSessionKey, data: session } = useCreateSessionKey();
+ *
+ * // Generate session keypair
+ * createSessionKey({
+ *   encryptKey: userEncryptKey,
+ *   durationSeconds: 21600 // 6 hours (optional, default)
+ * });
+ *
+ * // Store session externally after creation
+ * if (session) {
+ *   await saveToClerk(session);
+ * }
+ * ```
+ */
+declare function useCreateSessionKey(): {
+    createSessionKey: (params: CreateSessionKeyParams) => void;
+    createSessionKeyAsync: (params: CreateSessionKeyParams) => Promise<SessionKeyData>;
+    data: SessionKeyData | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type AddSessionKeyInput = {
+    params: AddSessionKeyParams;
+    bearerToken: string;
+};
+/**
+ * Hook for registering a session key on the smart contract.
+ *
+ * This executes a sponsored transaction (using owner signature) to call
+ * `add_or_update_session_key` on the CHIPI wallet contract.
+ *
+ * The session must be registered before it can be used for transactions.
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { addSessionKeyToContract, isLoading } = useAddSessionKeyToContract();
+ *
+ * // Register session on-chain
+ * addSessionKeyToContract({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     sessionConfig: {
+ *       sessionPublicKey: session.publicKey,
+ *       validUntil: session.validUntil,
+ *       maxCalls: 1000,
+ *       allowedEntrypoints: [] // empty = all allowed
+ *     }
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useAddSessionKeyToContract(): {
+    addSessionKeyToContract: (input: AddSessionKeyInput) => void;
+    addSessionKeyToContractAsync: (input: AddSessionKeyInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type RevokeSessionKeyInput = {
+    params: RevokeSessionKeyParams;
+    bearerToken: string;
+};
+/**
+ * Hook for revoking a session key from the smart contract.
+ *
+ * This executes a sponsored transaction (using owner signature) to call
+ * `revoke_session_key` on the CHIPI wallet contract.
+ *
+ * After revocation, the session key can no longer be used for transactions.
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { revokeSessionKey, isLoading } = useRevokeSessionKey();
+ *
+ * // Revoke a session
+ * revokeSessionKey({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     sessionPublicKey: session.publicKey
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useRevokeSessionKey(): {
+    revokeSessionKey: (input: RevokeSessionKeyInput) => void;
+    revokeSessionKeyAsync: (input: RevokeSessionKeyInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * Hook for querying session data from the smart contract.
+ *
+ * This is a read-only call that does not require signing or gas.
+ * Returns the on-chain state of a session key including:
+ * - Whether it's active
+ * - When it expires
+ * - Remaining calls
+ * - Allowed entrypoints
+ *
+ * @example
+ * ```typescript
+ * const { data: sessionData, isLoading } = useGetSessionData({
+ *   walletAddress: userWallet.publicKey,
+ *   sessionPublicKey: session.publicKey
+ * });
+ *
+ * if (sessionData?.isActive) {
+ *   console.log(`Session has ${sessionData.remainingCalls} calls remaining`);
+ * }
+ * ```
+ */
+declare function useGetSessionData(params: GetSessionDataParams | null, options?: {
+    enabled?: boolean;
+}): {
+    data: SessionDataResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    refetch: UseQueryResult<SessionDataResponse, Error>["refetch"];
+};
+
+type ExecuteWithSessionInput = {
+    params: ExecuteWithSessionParams;
+    bearerToken: string;
+};
+/**
+ * Hook for executing a gasless transaction using a session key.
+ *
+ * This uses the 4-element session signature format instead of owner signature.
+ * The session must be:
+ * 1. Generated via `useCreateSessionKey`
+ * 2. Registered on-chain via `useAddSessionKeyToContract`
+ *
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { executeWithSession, isLoading } = useExecuteWithSession();
+ *
+ * // Execute a transfer using session key (no owner key needed)
+ * executeWithSession({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     session: sessionKeyData,
+ *     calls: [{
+ *       contractAddress: USDC_ADDRESS,
+ *       entrypoint: 'transfer',
+ *       calldata: [recipient, amount, '0x0']
+ *     }]
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useExecuteWithSession(): {
+    executeWithSession: (input: ExecuteWithSessionInput) => void;
+    executeWithSessionAsync: (input: ExecuteWithSessionInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * Configuration for useX402Payment hook
+ */
+interface UseX402PaymentConfig {
+    /** Wallet data */
+    wallet: WalletData | null | undefined;
+    /** Encryption key for signing */
+    encryptKey: string;
+    /** Function to get the bearer token for API calls */
+    getBearerToken?: () => Promise<string | null | undefined>;
+    /** Static bearer token string (alternative to getBearerToken) */
+    bearerToken?: string;
+    /** Max amount per payment (USDC, human-readable e.g. "1.00") */
+    maxPaymentAmount?: string;
+    /** Alias for maxPaymentAmount */
+    maxAmount?: string;
+    /** Allowed recipient addresses (whitelist). Empty = allow all. */
+    allowedRecipients?: string[];
+    /** Active session for automatic payments (optional) */
+    session?: SessionKeyData | null;
+    /** Callback on successful payment */
+    onPaymentComplete?: (txHash: string, amount: string) => void | Promise<void>;
+}
+/**
+ * Last payment info returned by the hook
+ */
+interface LastPaymentInfo {
+    txHash: string | null;
+    amount: string | null;
+    timestamp: number;
+}
+/**
+ * Return type for useX402Payment hook
+ */
+interface UseX402PaymentReturn {
+    /** Fetch wrapper that auto-handles 402 payments */
+    x402Fetch: (url: string, init?: Record<string, any>) => Promise<Response>;
+    /** Alias for x402Fetch */
+    payFetch: (url: string, init?: Record<string, any>) => Promise<Response>;
+    /** Manual payment signing (for custom flows) */
+    signPayment: (requirement: PaymentRequirement) => Promise<PaymentPayload>;
+    /** Whether a payment is in progress */
+    isPaying: boolean;
+    /** Last payment transaction hash */
+    lastTxHash: string | null;
+    /** Last payment amount (human-readable USDC) */
+    lastAmount: string | null;
+    /** Last payment info (txHash + amount + timestamp) */
+    lastPayment: LastPaymentInfo | null;
+    /** Total USDC spent in this session (human-readable) */
+    totalSpent: string;
+    /** Error from last payment attempt */
+    error: Error | null;
+    /** Total payments made in this session */
+    paymentCount: number;
+}
+/**
+ * React hook for x402 payment protocol support.
+ *
+ * Wraps fetch calls with automatic HTTP 402 payment handling.
+ * When a server returns 402, the hook:
+ * 1. Parses the payment requirement
+ * 2. Validates against configured limits
+ * 3. Signs using the wallet (or session key for automatic payments)
+ * 4. Retries with the X-PAYMENT header
+ *
+ * @example
+ * ```tsx
+ * const { x402Fetch, isPaying, lastTxHash, paymentCount } = useX402Payment({
+ *   wallet,
+ *   encryptKey: pin,
+ *   getBearerToken: getToken,
+ *   maxPaymentAmount: "1.00",
+ *   onPaymentComplete: (txHash, amount) => {
+ *     console.log(`Paid ${amount} USDC, tx: ${txHash}`);
+ *   },
+ * });
+ *
+ * // Automatic 402 handling
+ * const response = await x402Fetch("https://api.example.com/premium");
+ * const data = await response.json();
+ * ```
+ */
+declare function useX402Payment(config: UseX402PaymentConfig): UseX402PaymentReturn;
+
+/**
+ * SHHH V8.4 envelope builders surfaced as a single hook for React
+ * integrators. Each helper returns the `signature: felt252[]` span
+ * ready to pass to `paymaster_executeSponsoredRaw.calldata`.
+ *
+ * Most helpers take the OE `messageHash` plus kind-specific inputs.
+ * `signWithMetaMask` is the exception: the `messageHash` is already
+ * baked into the user-signed payload upstream, so it takes only the
+ * 65-byte `personal_sign` signature and the registered pubkey.
+ *
+ * The hook is intentionally a thin facade over the
+ * `@chipi-stack/backend` builders: it adds semantic names that map
+ * to the user-facing wallet (`signWithMetaMask` = EIP-191,
+ * `signWithPhantom` = Ed25519, `signWithPasskey` = WebAuthn P-256)
+ * and stable React refs, but does NOT do browser-glue (no
+ * `window.ethereum`, `window.solana`, or `navigator.credentials.get`
+ * calls). Integrators retain full control of the user-prompt step:
+ *
+ * 1. Integrator calls their wallet adapter to get the raw signature
+ *    (or assertion / id_token).
+ * 2. Integrator passes that into the matching helper to wrap it into
+ *    the V2_SNIP12 envelope.
+ *
+ * Pair with `useGuardianRecovery` or `useThresholdSign` (B6/B7) for
+ * on-chain execution flows that need the recovery/governance builders.
+ */
+interface UseShhhSignerReturn {
+    /**
+     * STARK ECDSA signer (legacy CHIPI v29 keys, fastest path).
+     * Pure-local: no wallet prompt.
+     */
+    signWithStark: (params: {
+        privateKey: bigint | string;
+        messageHash: bigint;
+    }) => bigint[];
+    /**
+     * Phantom-shape Ed25519 signer (Solana users importing to Starknet).
+     * The 32-byte private key is the Solana keypair's secret material;
+     * the public key is recovered inside the builder.
+     */
+    signWithPhantom: (params: {
+        privateKey: Uint8Array;
+        messageHash: bigint;
+    }) => Promise<bigint[]>;
+    /**
+     * MetaMask-shape EIP-191 (`personal_sign`) signer. The signature
+     * MUST come from a `personal_sign` over the 32-byte big-endian
+     * messageHash; the pubkey was registered at wallet creation time.
+     */
+    signWithMetaMask: (params: {
+        signatureHex: string;
+        pubkey: Eip191Pubkey;
+    }) => bigint[];
+    /**
+     * WebAuthn P-256 signer (passkey). Takes a completed
+     * `navigator.credentials.get()` assertion split into its three
+     * fields (authenticatorData, clientDataJSON, signature DER) plus
+     * the pubkey registered at credential creation time.
+     */
+    signWithPasskey: (params: {
+        authenticatorData: Uint8Array;
+        clientDataJSON: Uint8Array;
+        signatureDer: Uint8Array;
+        pubkey: WebAuthnPubkey;
+        messageHash: bigint;
+        yParity?: 0n | 1n;
+    }) => bigint[];
+    /**
+     * Apple Sign In signer (`JWT_ES256_APPLE_SUB`). Takes the
+     * `id_token` from Apple's OAuth response. The nonce claim MUST
+     * encode `messageHash` (see `messageHashToNonceB64url`).
+     */
+    signWithAppleIdToken: (params: {
+        idToken: string;
+        pubkey: JwtAppleSubPubkey;
+        messageHash: bigint;
+    }) => bigint[];
+}
+declare function useShhhSigner(): UseShhhSignerReturn;
+
+type Call = ReturnType<typeof buildProposeAddOwnerCall>;
+/**
+ * SHHH V8.4 multi-owner governance + guardian-recovery builders
+ * surfaced as a single React hook. Each helper returns a Starknet
+ * `Call` object (NOT a signature envelope); callers compose those
+ * calls into an OutsideExecution and submit them via the paymaster
+ * adapter, signing the OE with `useShhhSigner`.
+ *
+ * Two top-level flows are intended:
+ *
+ *   1. ADD DEVICE (user has wallet access, wants a second owner)
+ *      a. `proposeAddOwner` (owner-signed OE)
+ *      b. wait 48h timelock
+ *      c. `executeAddOwner` (owner-signed OE, with the opId from 1a)
+ *
+ *   2. RECOVER VIA GUARDIAN (user lost key)
+ *      a. `initiateRecovery` (guardian-signed OE)
+ *      b. wait 7 days
+ *      c. `finalizeRecovery` (anyone can submit, no signature required
+ *         beyond Cairo-side state checks)
+ *
+ * Read-only timelock helpers (`isReady`, `secondsRemaining`) take a
+ * `validAfter` timestamp pulled from chain state and a clock reading;
+ * they don't query the chain themselves. Pair this hook with whatever
+ * mechanism your app already uses for on-chain state reads
+ * (`useGetWallet`, RPC, multicall, etc.).
+ *
+ * The full controlled-component `<Recover />` route that wires this
+ * hook into a state machine + UI ships as B6.2.
+ */
+interface UseGuardianRecoveryReturn {
+    buildProposeAddOwner: (args: {
+        walletAddress: bigint | string;
+        proposer: number;
+        newOwner: NewOwnerInput;
+    }) => Call;
+    buildExecuteAddOwner: (args: {
+        walletAddress: bigint | string;
+        opId: bigint | string;
+        newOwner: NewOwnerInput;
+    }) => Call;
+    buildProposeRemoveOwner: (args: {
+        walletAddress: bigint | string;
+        proposer: number;
+        ownerId: number;
+    }) => Call;
+    buildExecuteRemoveOwner: (args: {
+        walletAddress: bigint | string;
+        opId: bigint | string;
+        ownerId: number;
+    }) => Call;
+    buildProposeRotateOwner: (args: {
+        walletAddress: bigint | string;
+        proposer: number;
+        ownerId: number;
+        newPubkeyBytes: bigint[];
+    }) => Call;
+    buildExecuteRotateOwner: (args: {
+        walletAddress: bigint | string;
+        opId: bigint | string;
+        ownerId: number;
+        newPubkeyBytes: bigint[];
+    }) => Call;
+    buildProposeSetThreshold: (args: {
+        walletAddress: bigint | string;
+        proposer: number;
+        newThreshold: number;
+    }) => Call;
+    buildExecuteSetThreshold: (args: {
+        walletAddress: bigint | string;
+        opId: bigint | string;
+        newThreshold: number;
+    }) => Call;
+    buildCancelPendingOp: (args: {
+        walletAddress: bigint | string;
+        opId: bigint | string;
+    }) => Call;
+    buildInitiateRecovery: (args: {
+        walletAddress: bigint | string;
+        /** owner_id of the guardian that's signing the initiation OE */
+        proposer: number;
+        newOwner: NewOwnerInput;
+    }) => Call;
+    buildCancelRecovery: (args: {
+        walletAddress: bigint | string;
+        ownerId: number;
+    }) => Call;
+    buildFinalizeRecovery: (args: {
+        walletAddress: bigint | string;
+        newOwner: NewOwnerInput;
+    }) => Call;
+    isReady: (validAfterSecs: number | bigint, nowSecs?: number) => boolean;
+    secondsRemaining: (validAfterSecs: number | bigint, nowSecs?: number) => number;
+    TIMELOCK_SECONDS: typeof TIMELOCK_SECONDS;
+    DEFAULT_OP_EXPIRY_SECONDS: typeof DEFAULT_OP_EXPIRY_SECONDS;
+    ROLE_OWNER: typeof ROLE_OWNER;
+    ROLE_GUARDIAN: typeof ROLE_GUARDIAN;
+    OP_ADD_OWNER: typeof OP_ADD_OWNER;
+    OP_REMOVE_OWNER: typeof OP_REMOVE_OWNER;
+    OP_ROTATE_OWNER: typeof OP_ROTATE_OWNER;
+    OP_SET_THRESHOLD: typeof OP_SET_THRESHOLD;
+}
+declare function useGuardianRecovery(): UseGuardianRecoveryReturn;
+
+/**
+ * SHHH V8.4 N-of-M threshold sign coordinator surfaced as a React
+ * hook. Two complementary surfaces:
+ *
+ *   1. **Stateless helpers** — `assemble`, `parse`, and
+ *      `estimateGasOverhead` are pure facades over the matching
+ *      `@chipi-stack/backend` builders. Use them when you already
+ *      have all the inner envelopes in one render and just want to
+ *      ship the final V2_THRESHOLD span.
+ *
+ *   2. **Stateful collector** — for UI flows where N owners sign
+ *      asynchronously (passkey on phone → MetaMask on laptop, agent
+ *      auto-co-signing while a human reviews, etc.) the hook keeps
+ *      a queue of collected inner envelopes, exposes a "X of N
+ *      signed" state for UI display, validates each new envelope at
+ *      add-time (duplicate owner_id detection, structural shape),
+ *      and assembles the final span once the threshold is met via
+ *      `finalize()`.
+ *
+ * The collector validates each envelope inline using
+ * `assertValidV2Snip12Envelope` from the backend — the same check the
+ * `buildThresholdEnvelope` builder runs at assembly time. That way an
+ * integrator's UI can show "owner 3 envelope rejected: duplicate
+ * owner_id" before submitting the V2_THRESHOLD span on chain, instead
+ * of after the paymaster reverts.
+ *
+ * Threshold governance (`propose_set_threshold` / `execute_set_threshold`)
+ * lives in `useGuardianRecovery` because the multi-owner signing
+ * here and the threshold-change proposals there share the same
+ * Cairo SHHH wallet but are operationally separate flows.
+ */
+interface UseThresholdSignReturn {
+    /**
+     * Assemble an N-of-M V2_THRESHOLD envelope from a pre-collected
+     * list of inner V2_SNIP12 envelopes. Pure; no internal state used.
+     * Throws on duplicate owner_id, structural mismatch, or negative
+     * felts — same validation the on-chain dispatch would apply.
+     */
+    assemble: (args: {
+        innerEnvelopes: bigint[][];
+    }) => bigint[];
+    /**
+     * Inverse of `assemble`. Re-derives the constituent inner envelopes
+     * from a V2_THRESHOLD span. Useful for UI flows showing "owners X,
+     * Y, Z signed" from a stored envelope without re-walking the
+     * collection state.
+     */
+    parse: (args: {
+        envelope: bigint[];
+    }) => {
+        innerEnvelopes: bigint[][];
+    };
+    /**
+     * Sum the per-kind paymaster gas overhead across the owners that
+     * will participate. Use this to surface "this 2-of-3 mixed-kind
+     * tx will cost X l2_gas to verify" copy in a UI.
+     *
+     * Per [services/gasless/signer-kinds#gas-overhead], a STARK +
+     * EIP-191 pair budgets 2M + 10M = 12M l2_gas for verification on
+     * top of the call's own cost.
+     */
+    estimateGasOverhead: (args: {
+        owners: Array<{
+            signerKind: ShhhSignerKind;
+        }>;
+    }) => number;
+    /**
+     * Live state machine. Re-renders the consuming component when an
+     * envelope is added, removed, or the collection is reset.
+     */
+    state: ThresholdSignState;
+    /**
+     * Add one owner's inner V2_SNIP12 envelope to the collection.
+     * Validates structurally + checks duplicate owner_id against
+     * already-collected envelopes.
+     *
+     * Returns `true` on success, `false` on rejection. On rejection
+     * the failure reason lands on `state.error` for inline UI display;
+     * the collection is NOT mutated. A subsequent successful add
+     * clears `state.error`.
+     *
+     * Idempotent in the sense that a second add of an already-rejected
+     * envelope produces the same error; an already-collected envelope
+     * (same owner_id) is treated as a duplicate.
+     */
+    addEnvelope: (envelope: bigint[]) => boolean;
+    /**
+     * Drop a previously-added envelope by its owner_id. Useful when
+     * an owner signs but the integrator's review UI rejects their
+     * specific tx and needs to ask them to re-sign with corrected
+     * payload.
+     */
+    removeEnvelope: (ownerId: bigint) => void;
+    /** Clear the entire collection (cancel + restart the sign flow). */
+    reset: () => void;
+    /**
+     * Assemble the final V2_THRESHOLD envelope from collected inner
+     * envelopes. Throws if fewer than `threshold` have been collected
+     * (with a clear error so the caller's UI knows to keep prompting).
+     */
+    finalize: () => bigint[];
+    MIN_THRESHOLD_OWNERS: typeof MIN_THRESHOLD_OWNERS;
+}
+interface ThresholdSignState {
+    /** Threshold N this flow is collecting toward. */
+    threshold: number;
+    /** Inner envelopes collected so far, in arrival order. */
+    collected: bigint[][];
+    /**
+     * Owner ids that have signed, in arrival order. Pre-derived from
+     * `collected` so the UI doesn't have to re-parse each envelope.
+     */
+    signedOwnerIds: bigint[];
+    /** Has the threshold been met? `collected.length >= threshold`. */
+    isReady: boolean;
+    /**
+     * The most recent validation error from `addEnvelope`, if any.
+     * Cleared on successful add or `reset()`. Use for inline UI error
+     * display ("Owner X already signed", "envelope is malformed").
+     */
+    error: Error | null;
+}
+interface UseThresholdSignOptions {
+    /**
+     * Threshold N this flow targets. Must be at least
+     * `MIN_THRESHOLD_OWNERS` (2). Changes to this value after first
+     * render are honored — `isReady` re-evaluates against the new N
+     * without dropping already-collected envelopes (use `reset` if
+     * you need to start over).
+     */
+    threshold: number;
+}
+/**
+ * SHHH V8.4 threshold sign coordinator.
+ *
+ * @example Pure assembly (all envelopes ready in one render)
+ *
+ * ```tsx
+ * const t = useThresholdSign({ threshold: 2 });
+ * const envelope = t.assemble({
+ *   innerEnvelopes: [starkInner, eip191Inner],
+ * });
+ * await submitThroughPaymaster(envelope);
+ * ```
+ *
+ * @example Async sign flow (owners sign one at a time)
+ *
+ * ```tsx
+ * const t = useThresholdSign({ threshold: 2 });
+ *
+ * // After owner 1 signs:
+ * t.addEnvelope(owner1Envelope);
+ *
+ * // After owner 2 signs:
+ * t.addEnvelope(owner2Envelope);
+ *
+ * // UI shows "Signed by: owner_id_1, owner_id_2" via t.state.signedOwnerIds.
+ * // When t.state.isReady is true, submit:
+ * if (t.state.isReady) {
+ *   const envelope = t.finalize();
+ *   await submitThroughPaymaster(envelope);
+ * }
+ * ```
+ */
+declare function useThresholdSign(opts: UseThresholdSignOptions): UseThresholdSignReturn;
+
+export { useCallAnyContract as A, useSignTypedData as B, type ChipiWindowObjectDeps as C, useChipiWalletObject as D, useRecordSendTransaction as E, useGetTokenBalance as F, useCreateSessionKey as G, useAddSessionKeyToContract as H, useRevokeSessionKey as I, useGetSessionData as J, useExecuteWithSession as K, useX402Payment as L, type UseX402PaymentConfig as M, type UseX402PaymentReturn as N, useShhhSigner as O, type UseShhhSignerReturn as P, useGuardianRecovery as Q, type UseGuardianRecoveryReturn as R, type SessionState as S, useThresholdSign as T, type UseChipiWalletObjectConfig as U, type UseThresholdSignReturn as V, type UseThresholdSignOptions as W, type ThresholdSignState as X, type ChipiApprovalRequest as a, type ChipiSessionPolicy as b, useGetWallet as c, useChipiWallet as d, type UseChipiWalletConfig as e, type UseChipiWalletReturn as f, type ChipiWalletData as g, useChipiSession as h, type UseChipiSessionConfig as i, type UseChipiSessionReturn as j, type SessionWallet as k, useMigrateWalletToPasskey as l, useUpdateWalletEncryption as m, useMigrateWalletToShhh as n, useTransfer as o, type UseTransferConfig as p, useApprove as q, useGetTransactionList as r, useGetTransaction as s, useGetTransactionStatus as t, useCreateWallet as u, useSyncOnChainTransfers as v, usePurchaseSku as w, useGetSkuPurchase as x, useGetSkuList as y, useGetSku as z };