@oasisprotocol/privana-sdk 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1059 @@
+import { WalletClient, Address as Address$1 } from 'viem';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import { ReactNode, ComponentProps, ReactElement } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+var networks = {
+	testnet: {
+		chainId: 23295,
+		name: "Sapphire Testnet",
+		accountingContract: "0xaF8e5de153A584528B57DD4B9B0195956BBDF571",
+		apiUrl: "https://flexvaults-staging.rofl.build"
+	},
+	mainnet: {
+		chainId: 23294,
+		name: "Sapphire Mainnet",
+		accountingContract: "0x0000000000000000000000000000000000000000",
+		apiUrl: ""
+	}
+};
+var config = {
+	networks: networks
+};
+
+type Address = `0x${string}`;
+type Bytes32 = `0x${string}`;
+type HexString = `0x${string}`;
+type IntegerLike = string | number;
+type HostedAuthResponseMode = 'web_message' | 'redirect';
+type Network = keyof typeof config.networks;
+interface NetworkConfig {
+    chainId: number;
+    name: string;
+    accountingContract: Address;
+    apiUrl: string;
+}
+declare const NETWORK_CONFIG: {
+    readonly testnet: {
+        readonly accountingContract: Address;
+        readonly chainId: number;
+        readonly name: string;
+        readonly apiUrl: string;
+    };
+    readonly mainnet: {
+        readonly accountingContract: Address;
+        readonly chainId: number;
+        readonly name: string;
+        readonly apiUrl: string;
+    };
+};
+declare function getChainId(network: Network): number;
+declare function getAccountingContract(network: Network): Address;
+declare function getApiUrl(network: Network): string;
+declare function normalizeHex(value: string): HexString;
+declare function normalizeAddress(value: string): Address;
+
+interface HostedAuthConfig {
+    clientId: string;
+    redirectUri: string;
+}
+interface HostedAuthSession {
+    accessToken: string;
+    refreshToken: string;
+    idToken: string;
+    tokenType: string;
+    address: Address;
+    clientId: string;
+    redirectUri: string;
+    expiresAt: number;
+    refreshExpiresAt: number;
+}
+interface HostedAuthPendingTransaction {
+    codeVerifier: string;
+    state: string;
+}
+interface HostedAuthCallbackSuccess {
+    code: string;
+    state: string | null;
+}
+interface HostedAuthCallbackError {
+    error: string;
+    errorDescription?: string;
+    state: string | null;
+}
+type HostedAuthCallback = HostedAuthCallbackSuccess | HostedAuthCallbackError;
+
+interface TokenConfig {
+    id: Bytes32;
+    symbol: string;
+    decimals: number;
+    contract: Address;
+    name: string;
+    chainId: number;
+}
+
+interface ChainConfig {
+    id: number;
+    name: string;
+    explorerUrl: string;
+}
+declare const SUPPORTED_CHAINS: ChainConfig[];
+declare function getChainById(chainId: number): ChainConfig | undefined;
+declare function getExplorerAddressUrl(chainId: number, address: string): string | undefined;
+
+interface DepositAddressRequest {
+    chain_type?: string;
+    version?: number;
+}
+interface DepositCheckRequest {
+    chain_type?: string;
+    chain_id: number;
+    tx_hash: HexString;
+    amount: IntegerLike;
+    log_index?: number;
+    version?: number;
+}
+interface LockFundsRequest {
+    service_address: Address;
+    token_id: Bytes32;
+    amount: IntegerLike;
+    expiry: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface ModifyLockRequest {
+    lock_id: number;
+    amount: IntegerLike;
+    new_expiry: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface UnlockFundsRequest {
+    user_address: Address;
+    lock_id: number;
+}
+interface UnlockAllExpiredRequest {
+    user_address: Address;
+}
+interface TransferFundsRequest {
+    to_address: Address;
+    token_id: Bytes32;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface TransferLockedFundsRequest {
+    user_address: Address;
+    lock_id: number;
+    to_address: Address;
+    amount: IntegerLike;
+    service_address: Address;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface WithdrawalRequest {
+    token_id: Bytes32;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface WithdrawFromLockRequest {
+    to_address: Address;
+    lock_id: number;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface BatchBalancesRequest {
+    token_ids: Bytes32[];
+}
+interface HistoryRequest {
+    offset?: number;
+    limit?: number;
+}
+interface SiweLoginRequest {
+    siwe_message: string;
+    signature: HexString;
+}
+interface HostedAuthAuthorizeUrlRequest {
+    client_id: string;
+    redirect_uri: string;
+    code_challenge: string;
+    state: string;
+    chain_id: number;
+    response_mode?: HostedAuthResponseMode;
+    code_challenge_method?: 'S256';
+}
+interface HostedAuthTokenExchangeRequest {
+    grant_type?: 'authorization_code';
+    code: string;
+    code_verifier: string;
+    client_id: string;
+    redirect_uri: string;
+}
+interface JwtRefreshRequest {
+    refresh_token: string;
+}
+interface JwtLogoutRequest {
+    refresh_token?: string;
+    revoke_all?: boolean;
+}
+
+interface MinDepositAmounts {
+    native: string;
+    erc20: string;
+}
+interface DepositAddressResponse {
+    deposit_address: Address;
+    chain_type: string;
+    version: number;
+    min_deposit: Record<string, MinDepositAmounts>;
+}
+interface DepositCheckResponse {
+    status: 'credited' | 'pending' | 'error';
+    deposit_id?: string;
+    amount?: string;
+    token_address?: Address;
+    detail?: string;
+}
+interface TransactionSubmissionResponse {
+    status: string;
+    detail?: string;
+}
+interface BalanceResponse {
+    user_address: Address;
+    token_id: Bytes32;
+    balance: string;
+    token_symbol: string;
+    chain_id: string;
+}
+interface TokenBalance {
+    token_id: Bytes32;
+    balance: string;
+    token_symbol: string;
+    chain_id: string;
+}
+interface BatchBalancesResponse {
+    user_address: Address;
+    balances: TokenBalance[];
+}
+type HistoryKind = 'deposit' | 'withdraw' | 'createLock' | 'transferFromLock' | 'transferBalance' | 'unknown';
+interface HistoryEntry {
+    kind: HistoryKind;
+    timestamp: number;
+    token_id?: Bytes32 | null;
+    amount?: string | null;
+    counterparty?: Address | null;
+    deposit_id?: Bytes32 | null;
+    chain_id?: number | null;
+}
+interface HistoryResponse {
+    history: HistoryEntry[];
+    total: number;
+}
+interface TokenInfoResponse {
+    token_id: Bytes32;
+    token_type: number;
+    token_type_name: string;
+    data: string;
+    chain_id: number;
+    chain_name: string;
+    token_address: Address;
+    symbol: string;
+    name: string;
+    decimals: number;
+}
+interface TokenListResponse {
+    tokens: TokenInfoResponse[];
+}
+interface LockInfo {
+    lock_id: number;
+    user_address: Address;
+    service_address: Address;
+    token_id: Bytes32;
+    amount: string;
+    expiry: number;
+    is_expired: boolean;
+}
+interface LockedFundsResponse {
+    user_address: Address;
+    service_address?: Address;
+    locks: LockInfo[];
+    total_locked: string;
+}
+interface ExpiredLocksResponse {
+    user_address: Address;
+    expired_locks: LockInfo[];
+}
+interface TotalLockedBalanceResponse {
+    user_address: Address;
+    token_id: Bytes32;
+    total_locked: string;
+}
+interface WithdrawalInfo {
+    index: number;
+    user_address: Address;
+    to_address: Address;
+    amount: string;
+    block_number: number;
+    token_id: Bytes32;
+    resolved: boolean;
+    tx_identifier: string;
+}
+interface PendingWithdrawalsResponse {
+    user_address: Address;
+    pending_withdrawals: WithdrawalInfo[];
+}
+type WithdrawalInfoResponse = WithdrawalInfo;
+interface TransferNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface WithdrawalNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface LockNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface ModifyLockNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface TransferLockedNonceResponse {
+    service_address: Address;
+    nonce: string;
+}
+interface SiweDomainResponse {
+    domain: string;
+}
+interface SiweNonceResponse {
+    address: Address;
+    nonce: string;
+    expires_in: number;
+}
+interface SiweLoginResponse {
+    siwe_token: HexString;
+    jwt_access_token: string;
+    jwt_refresh_token: string;
+    address: Address;
+    jwt_expires_in: number;
+    jwt_refresh_expires_in: number;
+}
+interface HostedAuthTokenExchangeResponse {
+    access_token: string;
+    id_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_expires_in: number;
+    address: Address;
+}
+interface JwtRefreshResponse {
+    token: string;
+    refresh_token: string;
+    expires_in: number;
+    refresh_expires_in: number;
+}
+interface JwtLogoutResponse {
+    message: string;
+    revoked_tokens: number;
+}
+
+declare const HOSTED_AUTH_CLOCK_SKEW_MS = 30000;
+type StorageLike = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+declare function createPkceVerifier(length?: number): string;
+declare function createPkceChallenge(verifier: string): Promise<string>;
+declare function createHostedAuthState(length?: number): string;
+declare function createHostedAuthStorageKey(apiUrl: string, config: HostedAuthConfig): string;
+declare function createHostedAuthPendingStorageKey(apiUrl: string, config: HostedAuthConfig): string;
+declare function persistHostedAuthPendingTransaction(storage: StorageLike, key: string, transaction: HostedAuthPendingTransaction): void;
+declare function readHostedAuthPendingTransaction(storage: StorageLike, key: string): HostedAuthPendingTransaction | null;
+declare function clearHostedAuthPendingTransaction(storage: StorageLike, key: string): void;
+declare function parseHostedAuthCallback(url: URL, redirectUri: string): HostedAuthCallback | null;
+declare function stripHostedAuthCallbackParams(url: URL): string;
+declare function buildHostedAuthSession(response: HostedAuthTokenExchangeResponse, config: HostedAuthConfig, now?: number): HostedAuthSession;
+declare function applyRefreshResponse(session: HostedAuthSession, response: JwtRefreshResponse, now?: number): HostedAuthSession;
+declare function isHostedAuthSessionActive(session: HostedAuthSession, now?: number, skewMs?: number): boolean;
+declare function isHostedAuthRefreshActive(session: HostedAuthSession, now?: number, skewMs?: number): boolean;
+
+interface HttpClientConfig {
+    baseUrl: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly headers;
+    constructor(config: HttpClientConfig);
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    getBaseUrl(): string;
+    setHeader(name: string, value: string): void;
+    removeHeader(name: string): void;
+    getHeader(name: string): string | undefined;
+    private request;
+}
+
+type PrivanaClientConfig = HttpClientConfig;
+declare class PrivanaClient {
+    private readonly http;
+    constructor(config: PrivanaClientConfig);
+    getBaseUrl(): string;
+    getDepositAddress(request?: DepositAddressRequest): Promise<DepositAddressResponse>;
+    checkDeposit(request: DepositCheckRequest): Promise<DepositCheckResponse>;
+    getDepositStatus(depositId: string): Promise<DepositCheckResponse>;
+    getBalance(tokenId: Bytes32 | string): Promise<BalanceResponse>;
+    getBatchBalances(request: BatchBalancesRequest): Promise<BatchBalancesResponse>;
+    getHistory(request?: HistoryRequest): Promise<HistoryResponse>;
+    listTokens(): Promise<TokenListResponse>;
+    getTokenInfo(tokenId: Bytes32 | string): Promise<TokenInfoResponse>;
+    lockFunds(request: LockFundsRequest): Promise<TransactionSubmissionResponse>;
+    modifyLock(request: ModifyLockRequest): Promise<TransactionSubmissionResponse>;
+    unlockFunds(request: UnlockFundsRequest): Promise<TransactionSubmissionResponse>;
+    unlockAllExpired(request: UnlockAllExpiredRequest): Promise<TransactionSubmissionResponse>;
+    getLockedFunds(serviceAddress?: Address | string): Promise<LockedFundsResponse>;
+    getTotalLockedBalance(tokenId: Bytes32 | string): Promise<TotalLockedBalanceResponse>;
+    getExpiredLocks(): Promise<ExpiredLocksResponse>;
+    transferFunds(request: TransferFundsRequest): Promise<TransactionSubmissionResponse>;
+    getTransferNonce(userAddress: Address | string): Promise<TransferNonceResponse>;
+    getLockNonce(userAddress: Address | string): Promise<LockNonceResponse>;
+    getModifyLockNonce(userAddress: Address | string): Promise<ModifyLockNonceResponse>;
+    transferLockedFunds(request: TransferLockedFundsRequest): Promise<TransactionSubmissionResponse>;
+    withdrawFromLock(request: WithdrawFromLockRequest): Promise<TransactionSubmissionResponse>;
+    requestWithdrawal(request: WithdrawalRequest): Promise<TransactionSubmissionResponse>;
+    getWithdrawalNonce(userAddress: Address | string): Promise<WithdrawalNonceResponse>;
+    getTransferLockedNonce(serviceAddress: Address | string): Promise<TransferLockedNonceResponse>;
+    getPendingWithdrawals(userAddress: Address | string): Promise<PendingWithdrawalsResponse>;
+    getWithdrawalInfo(index: number): Promise<WithdrawalInfoResponse>;
+    getSiweDomain(): Promise<SiweDomainResponse>;
+    getSiweNonce(userAddress: Address | string): Promise<SiweNonceResponse>;
+    loginWithSiwe(request: SiweLoginRequest): Promise<SiweLoginResponse>;
+    getHostedAuthAuthorizeUrl(request: HostedAuthAuthorizeUrlRequest): string;
+    exchangeHostedAuthCode(request: HostedAuthTokenExchangeRequest): Promise<HostedAuthTokenExchangeResponse>;
+    refreshJwtSession(request: JwtRefreshRequest): Promise<JwtRefreshResponse>;
+    logoutJwtSession(request?: JwtLogoutRequest): Promise<JwtLogoutResponse>;
+    setPrivateReadToken(token: string): void;
+    getPrivateReadToken(): string | undefined;
+    clearPrivateReadToken(): void;
+    setBearerToken(token: string): void;
+    clearBearerToken(): void;
+}
+
+declare class AccountingApiError extends Error {
+    readonly statusCode: number;
+    readonly detail?: string | undefined;
+    constructor(message: string, statusCode: number, detail?: string | undefined);
+}
+declare class NetworkError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+declare class ValidationError extends Error {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+declare class HostedAuthError extends Error {
+    constructor(message: string);
+}
+declare class HostedAuthRequiredError extends HostedAuthError {
+    constructor(message?: string);
+}
+declare class HostedAuthStateMismatchError extends HostedAuthError {
+    constructor(message?: string);
+}
+
+interface EIP712Domain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: Address;
+}
+declare function createDomain(chainId: number, verifyingContract: Address): EIP712Domain;
+declare const LOCK_TYPES: {
+    readonly Lock: readonly [{
+        readonly name: "serviceAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+declare const TRANSFER_TYPES: {
+    readonly Transfer: readonly [{
+        readonly name: "toAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+declare const TRANSFER_LOCKED_TYPES: {
+    readonly TransferLocked: readonly [{
+        readonly name: "userAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "toAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "lockId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "serviceAddress";
+        readonly type: "address";
+    }];
+};
+declare const WITHDRAW_TYPES: {
+    readonly Withdraw: readonly [{
+        readonly name: "tokenId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+declare const MODIFY_LOCK_TYPES: {
+    readonly ModifyLock: readonly [{
+        readonly name: "lockId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "newExpiry";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+declare const WITHDRAW_FROM_LOCK_TYPES: {
+    readonly WithdrawFromLock: readonly [{
+        readonly name: "userAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "toAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "lockId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+interface LockMessage {
+    serviceAddress: Address;
+    tokenId: Bytes32;
+    amount: bigint;
+    expiry: bigint;
+    nonce: bigint;
+}
+interface TransferMessage {
+    toAddress: Address;
+    tokenId: Bytes32;
+    amount: bigint;
+    nonce: bigint;
+}
+interface TransferLockedMessage {
+    userAddress: Address;
+    toAddress: Address;
+    lockId: bigint;
+    amount: bigint;
+    nonce: bigint;
+    serviceAddress: Address;
+}
+interface WithdrawMessage {
+    tokenId: Bytes32;
+    amount: bigint;
+    nonce: bigint;
+}
+interface ModifyLockMessage {
+    lockId: bigint;
+    amount: bigint;
+    newExpiry: bigint;
+    nonce: bigint;
+}
+interface WithdrawFromLockMessage {
+    userAddress: Address;
+    toAddress: Address;
+    lockId: bigint;
+    amount: bigint;
+    nonce: bigint;
+}
+
+interface SignLockParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: LockMessage;
+}
+declare function signLockMessage({ walletClient, chainId, verifyingContract, message, }: SignLockParams): Promise<`0x${string}`>;
+declare function createLockExpiry(minutesFromNow?: number): bigint;
+
+interface SignModifyLockParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: ModifyLockMessage;
+}
+declare function signModifyLockMessage({ walletClient, chainId, verifyingContract, message, }: SignModifyLockParams): Promise<`0x${string}`>;
+
+interface SignTransferParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: TransferMessage;
+}
+declare function signTransferMessage({ walletClient, chainId, verifyingContract, message, }: SignTransferParams): Promise<`0x${string}`>;
+
+interface SignTransferLockedParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: TransferLockedMessage;
+}
+declare function signTransferLockedMessage({ walletClient, chainId, verifyingContract, message, }: SignTransferLockedParams): Promise<`0x${string}`>;
+
+interface SignWithdrawParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: WithdrawMessage;
+}
+declare function signWithdrawMessage({ walletClient, chainId, verifyingContract, message, }: SignWithdrawParams): Promise<`0x${string}`>;
+
+interface SignWithdrawFromLockParams {
+    walletClient: WalletClient;
+    chainId: number;
+    verifyingContract: Address;
+    message: WithdrawFromLockMessage;
+}
+declare function signWithdrawFromLockMessage({ walletClient, chainId, verifyingContract, message, }: SignWithdrawFromLockParams): Promise<`0x${string}`>;
+
+type TokensStatus = 'loading' | 'ready' | 'error';
+interface PrivanaContextValue {
+    client: PrivanaClient;
+    networkConfig: NetworkConfig;
+    enabledTokens: TokenConfig[];
+    defaultToken: TokenConfig | undefined;
+    getTokenById: (id: string) => TokenConfig | undefined;
+    getChainById: (id: number) => ChainConfig | undefined;
+    chains: ChainConfig[];
+    tokensStatus: TokensStatus;
+    tokensError?: Error;
+    pollingInterval: number;
+    serviceAddress?: Address;
+    hostedAuthConfig: HostedAuthConfig | null;
+    hostedAuthSession: HostedAuthSession | null;
+    setHostedAuthSession: (session: HostedAuthSession | null) => void;
+    clearHostedAuthSession: () => void;
+    refreshHostedAuthSession: () => Promise<HostedAuthSession>;
+}
+declare function readStoredHostedAuthSession(storage: Pick<Storage, 'getItem' | 'removeItem'>, hostedAuthStorageKey: string, now?: number): HostedAuthSession | null;
+declare function syncHostedAuthSessionToClient(client: Pick<PrivanaClient, 'clearBearerToken' | 'clearPrivateReadToken' | 'setBearerToken'>, hostedAuthConfig: HostedAuthConfig | null, hostedAuthSession: HostedAuthSession | null): void;
+interface PrivanaProviderProps {
+    children: ReactNode;
+    /**
+     * Network configuration including chainId, accountingContract, apiUrl, and name.
+     * Defaults to testnet config. Partial overrides are merged with defaults.
+     */
+    networkConfig?: Partial<NetworkConfig>;
+    /**
+     * Optional list of token IDs to filter from the API response.
+     * When provided, only tokens whose ID matches this list are enabled.
+     * When omitted, all tokens returned by the API are enabled.
+     */
+    tokens?: string[];
+    /**
+     * Chain configurations to use. Defaults to SDK built-in chains from config.json.
+     * Pass custom ChainConfig[] for deployments targeting different chains.
+     */
+    chains?: ChainConfig[];
+    pollingInterval?: number;
+    /**
+     * The service address for lock operations.
+     */
+    serviceAddress?: Address;
+    /**
+     * Optional hosted redirect auth configuration for cross-domain browser apps.
+     */
+    hostedAuth?: HostedAuthConfig;
+}
+declare function PrivanaProvider({ children, networkConfig: networkConfigOverride, tokens, chains, pollingInterval, serviceAddress, hostedAuth, }: PrivanaProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePrivanaContext(): PrivanaContextValue;
+declare function useSafePrivanaContext(): PrivanaContextValue | null;
+
+declare function usePrivanaClient(): PrivanaClient;
+
+interface UseHostedRedirectAuthResult {
+    session: HostedAuthSession | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    login: () => Promise<void>;
+    completeLogin: () => Promise<HostedAuthSession | null>;
+    logout: () => Promise<void>;
+    refresh: () => Promise<HostedAuthSession>;
+}
+declare function useHostedRedirectAuth(): UseHostedRedirectAuthResult;
+
+interface UseBalanceOptions {
+    tokenId?: Bytes32;
+    enabled?: boolean;
+}
+interface UseBalanceResult {
+    balance: string;
+    balanceWei: string;
+    balanceFormatted: string;
+    tokenSymbol: string;
+    chainId: string;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useBalance(options?: UseBalanceOptions): UseBalanceResult;
+
+interface UseBatchBalancesOptions {
+    tokenIds: Bytes32[];
+    enabled?: boolean;
+}
+interface UseBatchBalancesResult {
+    balances: TokenBalance[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useBatchBalances(options: UseBatchBalancesOptions): UseBatchBalancesResult;
+
+interface UseDepositOptions {
+    onDepositAddressReceived?: (response: DepositAddressResponse) => void;
+    onDepositSuccess?: (txHash: string) => void;
+    onCredited?: (txHash: string, response: DepositCheckResponse) => void;
+    /** Called when deposit check polling times out - deposit may still be processing */
+    onCheckTimeout?: (txHash: string) => void;
+    onError?: (error: Error) => void;
+    /** Polling interval in ms for checking deposit status (default: 5000) */
+    pollInterval?: number;
+    /** Max time to wait for deposit to be credited in ms (default: 180000 = 3 minutes) */
+    pollTimeout?: number;
+    /** Number of block confirmations to wait before checking deposit status (default: 15) */
+    confirmations?: number;
+}
+interface DepositParams {
+    tokenId: Bytes32;
+    amount: bigint;
+}
+interface UseDepositResult {
+    depositAddress: DepositAddressResponse | null;
+    txHash: `0x${string}` | undefined;
+    isGettingAddress: boolean;
+    isSwitchingChain: boolean;
+    isSendingTransaction: boolean;
+    isWaitingForConfirmation: boolean;
+    isWaitingForProcessing: boolean;
+    /** True if processing timed out (deposit may still be processing in background) */
+    didTimeout: boolean;
+    /**
+     * True when an on-chain transfer succeeded but the API verification step
+     * (checkDeposit or status polling) failed. The funds have already left the
+     * wallet, so a fresh `deposit()` would cause a double spend. Call
+     * `retryVerification()` to re-run verification against the existing txHash,
+     * or `reset()` to discard local tracking (the deposit may still be credited
+     * in the background).
+     */
+    verificationFailed: boolean;
+    isPending: boolean;
+    error: Error | null;
+    deposit: (params: DepositParams) => Promise<void>;
+    /** Re-run the API verification (sweep trigger + polling) for the existing txHash. */
+    retryVerification: () => Promise<void>;
+    reset: () => void;
+}
+declare function useDeposit(options?: UseDepositOptions): UseDepositResult;
+
+interface UseWithdrawOptions {
+    onSuccess?: (response: TransactionSubmissionResponse) => void;
+    /** Called when withdrawal is submitted to the backend */
+    onSubmitSuccess?: (response: TransactionSubmissionResponse) => void;
+    /** Called when withdrawal is fully processed (broadcast to destination chain) */
+    onProcessingSuccess?: () => void;
+    /** Called when processing times out - withdrawal may still be processing */
+    onProcessingTimeout?: () => void;
+    onError?: (error: Error) => void;
+    /** Polling interval in ms for checking withdrawal status (default: 3000) */
+    pollInterval?: number;
+    /** Max time to wait for withdrawal to be processed in ms (default: 180000 = 3 minutes) */
+    pollTimeout?: number;
+}
+interface WithdrawParams {
+    tokenId: Bytes32;
+    amount: bigint;
+}
+type WithdrawStep = 'idle' | 'switching-chain' | 'signing' | 'submitting' | 'processing';
+interface UseWithdrawResult {
+    withdraw: (params: WithdrawParams) => Promise<TransactionSubmissionResponse | undefined>;
+    isPending: boolean;
+    isSuccess: boolean;
+    currentStep: WithdrawStep;
+    /** True if processing timed out (withdrawal may still be processing in background) */
+    didTimeout: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useWithdraw(options?: UseWithdrawOptions): UseWithdrawResult;
+
+interface UseLockFundsOptions {
+    onSuccess?: (response: TransactionSubmissionResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface LockFundsParams {
+    tokenId: Bytes32;
+    amount: bigint;
+    expiry: bigint;
+}
+interface UseLockFundsResult {
+    lockFunds: (params: LockFundsParams) => Promise<TransactionSubmissionResponse | undefined>;
+    isPending: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useLockFunds(options?: UseLockFundsOptions): UseLockFundsResult;
+
+interface UseUnlockFundsOptions {
+    onSuccess?: (response: TransactionSubmissionResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface UnlockFundsParams {
+    lockId: number;
+}
+interface UseUnlockFundsResult {
+    unlockFunds: (params: UnlockFundsParams) => Promise<TransactionSubmissionResponse | undefined>;
+    unlockAllExpired: () => Promise<TransactionSubmissionResponse | undefined>;
+    isPending: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useUnlockFunds(options?: UseUnlockFundsOptions): UseUnlockFundsResult;
+
+interface UseTransferOptions {
+    onSuccess?: (response: TransactionSubmissionResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface TransferParams {
+    toAddress: Address;
+    tokenId: Bytes32;
+    amount: bigint;
+}
+interface TransferLockedParams {
+    lockId: number;
+    toAddress: Address;
+    amount: bigint;
+}
+interface UseTransferResult {
+    transfer: (params: TransferParams) => Promise<TransactionSubmissionResponse | undefined>;
+    transferLocked: (params: TransferLockedParams) => Promise<TransactionSubmissionResponse | undefined>;
+    isPending: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useTransfer(options?: UseTransferOptions): UseTransferResult;
+
+interface UseLockedFundsOptions {
+    enabled?: boolean;
+}
+interface UseLockedFundsResult {
+    locks: LockInfo[];
+    totalLocked: string;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useLockedFunds(options?: UseLockedFundsOptions): UseLockedFundsResult;
+
+interface UseTotalLockedBalanceOptions {
+    tokenId?: Bytes32;
+    enabled?: boolean;
+}
+interface UseTotalLockedBalanceResult {
+    totalLocked: string;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useTotalLockedBalance(options?: UseTotalLockedBalanceOptions): UseTotalLockedBalanceResult;
+
+interface UseExpiredLocksOptions {
+    enabled?: boolean;
+}
+interface UseExpiredLocksResult {
+    expiredLocks: LockInfo[];
+    hasExpiredLocks: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useExpiredLocks(options?: UseExpiredLocksOptions): UseExpiredLocksResult;
+
+interface UsePendingWithdrawalsOptions {
+    enabled?: boolean;
+}
+interface UsePendingWithdrawalsResult {
+    withdrawals: WithdrawalInfo[];
+    hasPendingWithdrawals: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function usePendingWithdrawals(options?: UsePendingWithdrawalsOptions): UsePendingWithdrawalsResult;
+
+interface UseHistoryOptions {
+    offset?: number;
+    limit?: number;
+    enabled?: boolean;
+}
+interface UseHistoryResult {
+    history: HistoryEntry[];
+    total: number;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useHistory(options?: UseHistoryOptions): UseHistoryResult;
+
+interface SafeAccountResult {
+    address: Address$1 | undefined;
+    isConnected: boolean;
+}
+declare function useSafeAccount(): SafeAccountResult;
+
+interface UseTokenInfoOptions {
+    tokenId?: Bytes32 | string;
+    enabled?: boolean;
+}
+interface UseTokenInfoResult {
+    data: TokenInfoResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useTokenInfo(options?: UseTokenInfoOptions): UseTokenInfoResult;
+
+interface UseTokenListOptions {
+    enabled?: boolean;
+}
+interface UseTokenListResult {
+    tokens: TokenInfoResponse[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+declare function useTokenList(options?: UseTokenListOptions): UseTokenListResult;
+
+interface UseModifyLockOptions {
+    onSuccess?: (response: TransactionSubmissionResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface ModifyLockParams {
+    lockId: number;
+    amount: bigint;
+    newExpiry: bigint;
+}
+interface UseModifyLockResult {
+    modifyLock: (params: ModifyLockParams) => Promise<TransactionSubmissionResponse | undefined>;
+    isPending: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+declare function useModifyLock(options?: UseModifyLockOptions): UseModifyLockResult;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React$1.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+type ButtonVariantProps = VariantProps<typeof buttonVariants>;
+interface PrivanaButtonProps extends Omit<ComponentProps<'button'>, 'children'> {
+    children?: ReactNode;
+    variant?: ButtonVariantProps['variant'];
+    size?: ButtonVariantProps['size'];
+    asChild?: boolean;
+    renderButton?: (props: {
+        onClick: () => void;
+        isOpen: boolean;
+    }) => ReactElement;
+    hideWhenDisconnected?: boolean;
+    showLockedFunds?: boolean;
+    defaultTab?: 'deposit' | 'withdraw';
+    onDepositSuccess?: () => void;
+}
+declare function PrivanaButton({ children, className, variant, size, asChild, renderButton, hideWhenDisconnected, showLockedFunds, defaultTab, onDepositSuccess, ...buttonProps }: PrivanaButtonProps): react_jsx_runtime.JSX.Element | null;
+
+interface PrivanaModalProps {
+    open: boolean;
+    onClose: () => void;
+    showLockedFunds?: boolean;
+    defaultTab?: 'deposit' | 'withdraw';
+    onDepositSuccess?: () => void;
+}
+declare function PrivanaModal({ open, onClose, showLockedFunds, defaultTab, onDepositSuccess, }: PrivanaModalProps): react_jsx_runtime.JSX.Element;
+declare function PrivanaInlineModal({ className, showLockedFunds, defaultTab, onDepositSuccess, }: {
+    className?: string;
+    showLockedFunds?: boolean;
+    defaultTab?: 'deposit' | 'withdraw';
+    onDepositSuccess?: () => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare function getTokenIcon(symbol: string, size?: number): react_jsx_runtime.JSX.Element;
+declare function getChainIcon(chainId: number, size?: number): react_jsx_runtime.JSX.Element;
+
+export { AccountingApiError, type Address, type BalanceResponse, type BatchBalancesRequest, type BatchBalancesResponse, Button, type Bytes32, type ChainConfig, type DepositAddressRequest, type DepositAddressResponse, type DepositCheckRequest, type DepositCheckResponse, type DepositParams, type EIP712Domain, type ExpiredLocksResponse, HOSTED_AUTH_CLOCK_SKEW_MS, type HexString, type HistoryEntry, type HistoryKind, type HistoryRequest, type HistoryResponse, type HostedAuthAuthorizeUrlRequest, type HostedAuthCallback, type HostedAuthCallbackError, type HostedAuthCallbackSuccess, type HostedAuthConfig, HostedAuthError, type HostedAuthPendingTransaction, HostedAuthRequiredError, type HostedAuthResponseMode, type HostedAuthSession, HostedAuthStateMismatchError, type HostedAuthTokenExchangeRequest, type HostedAuthTokenExchangeResponse, HttpClient, type HttpClientConfig, type IntegerLike, type JwtLogoutRequest, type JwtLogoutResponse, type JwtRefreshRequest, type JwtRefreshResponse, LOCK_TYPES, type LockFundsParams, type LockFundsRequest, type LockInfo, type LockMessage, type LockNonceResponse, type LockedFundsResponse, MODIFY_LOCK_TYPES, type MinDepositAmounts, type ModifyLockMessage, type ModifyLockNonceResponse, type ModifyLockParams, type ModifyLockRequest, NETWORK_CONFIG, type Network, type NetworkConfig, NetworkError, type PendingWithdrawalsResponse, PrivanaButton, type PrivanaButtonProps, PrivanaClient, type PrivanaClientConfig, type PrivanaContextValue, PrivanaInlineModal, PrivanaModal, PrivanaProvider, type PrivanaProviderProps, SUPPORTED_CHAINS, type SignLockParams, type SignModifyLockParams, type SignTransferLockedParams, type SignTransferParams, type SignWithdrawFromLockParams, type SignWithdrawParams, type SiweDomainResponse, type SiweLoginRequest, type SiweLoginResponse, type SiweNonceResponse, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, type TokenBalance, type TokenConfig, type TokenInfoResponse, type TokenListResponse, type TokensStatus, type TotalLockedBalanceResponse, type TransactionSubmissionResponse, type TransferFundsRequest, type TransferLockedFundsRequest, type TransferLockedMessage, type TransferLockedNonceResponse, type TransferLockedParams, type TransferMessage, type TransferNonceResponse, type TransferParams, type UnlockAllExpiredRequest, type UnlockFundsParams, type UnlockFundsRequest, type UseBalanceOptions, type UseBalanceResult, type UseBatchBalancesOptions, type UseBatchBalancesResult, type UseDepositOptions, type UseDepositResult, type UseExpiredLocksOptions, type UseExpiredLocksResult, type UseHistoryOptions, type UseHistoryResult, type UseHostedRedirectAuthResult, type UseLockFundsOptions, type UseLockFundsResult, type UseLockedFundsOptions, type UseLockedFundsResult, type UseModifyLockOptions, type UseModifyLockResult, type UsePendingWithdrawalsOptions, type UsePendingWithdrawalsResult, type UseTokenInfoOptions, type UseTokenInfoResult, type UseTokenListOptions, type UseTokenListResult, type UseTotalLockedBalanceOptions, type UseTotalLockedBalanceResult, type UseTransferOptions, type UseTransferResult, type UseUnlockFundsOptions, type UseUnlockFundsResult, type UseWithdrawOptions, type UseWithdrawResult, ValidationError, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, type WithdrawFromLockMessage, type WithdrawFromLockRequest, type WithdrawMessage, type WithdrawParams, type WithdrawStep, type WithdrawalInfo, type WithdrawalInfoResponse, type WithdrawalNonceResponse, type WithdrawalRequest, applyRefreshResponse, buildHostedAuthSession, buttonVariants, clearHostedAuthPendingTransaction, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, getAccountingContract, getApiUrl, getChainById, getChainIcon, getChainId, getExplorerAddressUrl, getTokenIcon, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useBalance, useBatchBalances, useDeposit, useExpiredLocks, useHistory, useHostedRedirectAuth, useLockFunds, useLockedFunds, useModifyLock, usePendingWithdrawals, usePrivanaClient, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useTokenInfo, useTokenList, useTotalLockedBalance, useTransfer, useUnlockFunds, useWithdraw };