@sip-protocol/react 0.1.0 → 0.1.1

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import React, { ReactNode } from 'react';
 import * as _sip_protocol_sdk from '@sip-protocol/sdk';
 import { SIPConfig, SIP } from '@sip-protocol/sdk';
-import { ChainId, Quote, PrivacyLevel, ViewingKey, EncryptedTransaction } from '@sip-protocol/types';
+import { ChainId, Quote, PrivacyLevel as PrivacyLevel$1, ViewingKey as ViewingKey$1, EncryptedTransaction, HexString } from '@sip-protocol/types';
 
 interface SIPProviderProps {
     config: SIPConfig;
@@ -198,8 +198,10 @@ declare function useStealthAddress(chain: ChainId): {
     metaAddress: string | null;
     stealthAddress: string | null;
     isGenerating: boolean;
+    error: Error | null;
     regenerate: () => void;
     copyToClipboard: () => Promise<void>;
+    clearError: () => void;
 };
 
 /**
@@ -221,7 +223,7 @@ interface QuoteParams {
     /** Input amount (as string, in smallest unit) */
     inputAmount: string;
     /** Privacy level (optional) */
-    privacyLevel?: PrivacyLevel;
+    privacyLevel?: PrivacyLevel$1;
     /** Maximum acceptable slippage (0-1, e.g. 0.01 = 1%) */
     maxSlippage?: number;
 }
@@ -242,7 +244,7 @@ interface SwapParams {
         minAmount: bigint;
     };
     /** Privacy level */
-    privacyLevel: PrivacyLevel;
+    privacyLevel: PrivacyLevel$1;
     /** Maximum acceptable slippage (0-1, e.g. 0.01 = 1%) */
     maxSlippage?: number;
 }
@@ -390,15 +392,1231 @@ interface AuditorShare {
  */
 declare function useViewingKey(): {
     /** Current viewing key (null if not generated) */
-    viewingKey: ViewingKey | null;
+    viewingKey: ViewingKey$1 | null;
     /** List of auditors who have been given access */
     sharedWith: AuditorShare[];
     /** Generate a new viewing key */
-    generate: (path?: string) => ViewingKey;
+    generate: (path?: string) => ViewingKey$1;
     /** Decrypt encrypted transaction data */
     decrypt: (encrypted: EncryptedTransaction) => Promise<_sip_protocol_sdk.TransactionData>;
     /** Share viewing key with an auditor */
     share: (auditorId: string) => Promise<void>;
 };
 
-export { SIPProvider, type SIPProviderProps, usePrivateSwap, useSIP, useStealthAddress, useViewingKey };
+/**
+ * Privacy level options
+ */
+type PrivacyLevel = 'off' | 'shielded' | 'compliant';
+/**
+ * Gas estimate for different privacy levels
+ */
+interface GasEstimate {
+    /** Gas in native units (e.g., yoctoNEAR, gwei) */
+    gas: string;
+    /** Formatted cost in native token */
+    cost: string;
+    /** Formatted cost in USD (optional) */
+    costUsd?: string;
+}
+/**
+ * Privacy level metadata
+ */
+interface PrivacyLevelInfo {
+    level: PrivacyLevel;
+    label: string;
+    description: string;
+    icon: React.ReactNode;
+    gasEstimate?: GasEstimate;
+}
+/**
+ * PrivacyToggle component props
+ */
+interface PrivacyToggleProps {
+    /** Current privacy level (controlled mode) */
+    value?: PrivacyLevel;
+    /** Default privacy level (uncontrolled mode) */
+    defaultValue?: PrivacyLevel;
+    /** Callback when privacy level changes */
+    onChange?: (level: PrivacyLevel) => void;
+    /** Whether the toggle is disabled */
+    disabled?: boolean;
+    /** Gas estimates for each level */
+    gasEstimates?: Partial<Record<PrivacyLevel, GasEstimate>>;
+    /** Show gas/fee difference */
+    showGasEstimate?: boolean;
+    /** Show tooltips */
+    showTooltips?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Chain identifier for context */
+    chain?: string;
+    /** Aria label for the toggle group */
+    'aria-label'?: string;
+}
+/**
+ * PrivacyToggle - Toggle component for selecting privacy level
+ *
+ * A three-state toggle for controlling transaction privacy on NEAR and other chains.
+ * Supports controlled and uncontrolled modes, accessibility features, and gas estimates.
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { PrivacyToggle } from '@sip-protocol/react'
+ *
+ * function SendForm() {
+ *   const [privacy, setPrivacy] = useState<PrivacyLevel>('shielded')
+ *
+ *   return (
+ *     <PrivacyToggle
+ *       value={privacy}
+ *       onChange={setPrivacy}
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With gas estimates
+ * ```tsx
+ * <PrivacyToggle
+ *   value={privacy}
+ *   onChange={setPrivacy}
+ *   showGasEstimate
+ *   gasEstimates={{
+ *     off: { gas: '2500000000000', cost: '0.00025 NEAR' },
+ *     shielded: { gas: '30000000000000', cost: '0.003 NEAR' },
+ *     compliant: { gas: '35000000000000', cost: '0.0035 NEAR' },
+ *   }}
+ * />
+ * ```
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * <PrivacyToggle
+ *   defaultValue="shielded"
+ *   onChange={(level) => console.log('Selected:', level)}
+ * />
+ * ```
+ */
+declare function PrivacyToggle({ value, defaultValue, onChange, disabled, gasEstimates, showGasEstimate, showTooltips, className, size, chain, 'aria-label': ariaLabel, }: PrivacyToggleProps): React.JSX.Element;
+/**
+ * Hook to use with PrivacyToggle for managing privacy state
+ */
+declare function usePrivacyToggle(initialValue?: PrivacyLevel): {
+    privacyLevel: PrivacyLevel;
+    setPrivacyLevel: React.Dispatch<React.SetStateAction<PrivacyLevel>>;
+    isPrivate: boolean;
+    isCompliant: boolean;
+    isShielded: boolean;
+    setPublic: () => void;
+    setShielded: () => void;
+    setCompliant: () => void;
+};
+
+/**
+ * Ownership status for stealth addresses
+ */
+type OwnershipStatus = 'yours' | 'others' | 'unknown';
+/**
+ * Network configuration for explorer links
+ */
+interface NetworkConfig {
+    name: string;
+    explorerUrl: string;
+}
+/**
+ * Default NEAR network configurations
+ */
+declare const NEAR_NETWORKS: Record<string, NetworkConfig>;
+/**
+ * StealthAddressDisplay component props
+ */
+interface StealthAddressDisplayProps {
+    /** The stealth address to display (64-char hex or implicit account) */
+    address: string;
+    /** Optional stealth meta-address for QR code (full sip: format) */
+    metaAddress?: string;
+    /** Ownership status of the address */
+    ownership?: OwnershipStatus;
+    /** Whether the address is validated */
+    isValid?: boolean;
+    /** Network for explorer links */
+    network?: 'mainnet' | 'testnet';
+    /** Custom network configuration */
+    networkConfig?: NetworkConfig;
+    /** Whether to show the QR code button */
+    showQrCode?: boolean;
+    /** Whether to show the explorer link */
+    showExplorerLink?: boolean;
+    /** Whether to show the copy button */
+    showCopyButton?: boolean;
+    /** Whether to show the ownership badge */
+    showOwnership?: boolean;
+    /** Whether to show the validation indicator */
+    showValidation?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Callback when address is copied */
+    onCopy?: (address: string) => void;
+    /** Callback when QR code is shown */
+    onShowQr?: (address: string) => void;
+}
+/**
+ * Validates a NEAR stealth address format
+ */
+declare function isValidStealthAddress(address: string): boolean;
+/**
+ * Truncates an address for display
+ */
+declare function truncateAddress(address: string, startChars?: number, endChars?: number): string;
+/**
+ * StealthAddressDisplay - Component for displaying NEAR stealth addresses
+ *
+ * Displays stealth addresses with visual distinction from regular NEAR addresses,
+ * including copy functionality, explorer links, and QR code generation.
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { StealthAddressDisplay } from '@sip-protocol/react'
+ *
+ * function WalletView() {
+ *   return (
+ *     <StealthAddressDisplay
+ *       address="a1b2c3d4e5f6..."
+ *       ownership="yours"
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With meta-address for QR
+ * ```tsx
+ * <StealthAddressDisplay
+ *   address="a1b2c3d4e5f6..."
+ *   metaAddress="sip:near:0x02abc...123:0x03def...456"
+ *   showQrCode
+ *   showExplorerLink
+ *   network="mainnet"
+ * />
+ * ```
+ */
+declare function StealthAddressDisplay({ address, metaAddress, ownership, isValid, network, networkConfig, showQrCode, showExplorerLink, showCopyButton, showOwnership, showValidation, className, size, onCopy, onShowQr, }: StealthAddressDisplayProps): React.JSX.Element;
+/**
+ * Hook to manage stealth address display state
+ */
+declare function useStealthAddressDisplay(address: string, options?: {
+    checkOwnership?: (address: string) => OwnershipStatus;
+    validateAddress?: (address: string) => boolean;
+}): {
+    address: string;
+    truncated: string;
+    ownership: OwnershipStatus;
+    isValid: boolean;
+    isStealth: boolean;
+};
+
+/**
+ * Transaction status types
+ */
+type TransactionStatus = 'pending' | 'processing' | 'confirmed' | 'finalized' | 'failed' | 'cancelled';
+/**
+ * Privacy-specific verification status
+ */
+type PrivacyVerificationStatus = 'pending' | 'verified' | 'failed' | 'not_applicable';
+/**
+ * Transaction action types
+ */
+type TransactionActionType = 'transfer' | 'stealth_transfer' | 'function_call' | 'create_account' | 'stake' | 'unstake';
+/**
+ * Transaction action
+ */
+interface TransactionAction {
+    type: TransactionActionType;
+    receiver: string;
+    amount?: string;
+    methodName?: string;
+    args?: Record<string, unknown>;
+}
+/**
+ * Privacy verification details
+ */
+interface PrivacyVerification {
+    stealthAddressResolved: PrivacyVerificationStatus;
+    commitmentVerified: PrivacyVerificationStatus;
+    viewingKeyGenerated: PrivacyVerificationStatus;
+}
+/**
+ * Transaction details
+ */
+interface PrivacyTransaction {
+    /** Transaction hash */
+    hash: string;
+    /** Transaction status */
+    status: TransactionStatus;
+    /** Block number (null if pending) */
+    blockHeight?: number;
+    /** Number of confirmations */
+    confirmations: number;
+    /** Required confirmations for finality */
+    requiredConfirmations: number;
+    /** Timestamp of transaction (ms) */
+    timestamp: number;
+    /** Sender account */
+    sender: string;
+    /** Receiver account or stealth address */
+    receiver: string;
+    /** Whether receiver is a stealth address */
+    isStealthReceiver: boolean;
+    /** Amount transferred (in native token units) */
+    amount?: string;
+    /** Gas used */
+    gasUsed?: string;
+    /** Transaction fee */
+    fee?: string;
+    /** Transaction actions */
+    actions: TransactionAction[];
+    /** Privacy verification status */
+    privacyVerification?: PrivacyVerification;
+    /** Error message if failed */
+    errorMessage?: string;
+}
+/**
+ * TransactionTracker component props
+ */
+interface TransactionTrackerProps {
+    /** Transaction data */
+    transaction: PrivacyTransaction;
+    /** Callback to refresh transaction status */
+    onRefresh?: () => void;
+    /** Callback to retry failed transaction */
+    onRetry?: () => void;
+    /** Callback to cancel pending transaction */
+    onCancel?: () => void;
+    /** Whether to show expanded details by default */
+    defaultExpanded?: boolean;
+    /** Polling interval in ms (0 to disable) */
+    pollingInterval?: number;
+    /** Network name for display */
+    networkName?: string;
+    /** Explorer URL template (use {hash} placeholder) */
+    explorerUrlTemplate?: string;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether to show privacy verification status */
+    showPrivacyStatus?: boolean;
+}
+/**
+ * TransactionTracker - Component for tracking NEAR privacy transactions
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { TransactionTracker } from '@sip-protocol/react'
+ *
+ * function TransactionView({ txHash }) {
+ *   const [tx, setTx] = useState(null)
+ *
+ *   return (
+ *     <TransactionTracker
+ *       transaction={tx}
+ *       onRefresh={() => fetchTransaction(txHash)}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function TransactionTracker({ transaction, onRefresh, onRetry, onCancel, defaultExpanded, pollingInterval, networkName, explorerUrlTemplate, className, size, showPrivacyStatus, }: TransactionTrackerProps): React.JSX.Element;
+/**
+ * Hook to manage transaction tracking state
+ */
+declare function useTransactionTracker(initialTransaction?: PrivacyTransaction, options?: {
+    pollingInterval?: number;
+    onStatusChange?: (status: TransactionStatus) => void;
+}): {
+    transaction: PrivacyTransaction | null;
+    setTransaction: React.Dispatch<React.SetStateAction<PrivacyTransaction | null>>;
+    updateTransaction: (updates: Partial<PrivacyTransaction>) => void;
+    isPolling: boolean;
+    startPolling: () => void;
+    stopPolling: () => void;
+    isFinal: boolean;
+};
+
+/**
+ * Viewing key status
+ */
+type ViewingKeyStatus = 'active' | 'revoked' | 'expired' | 'pending';
+/**
+ * Key export format
+ */
+type KeyExportFormat = 'encrypted_file' | 'qr_code' | 'plaintext';
+/**
+ * Key import source
+ */
+type KeyImportSource = 'file' | 'qr_code' | 'text';
+/**
+ * Viewing key usage entry
+ */
+interface ViewingKeyUsage {
+    timestamp: number;
+    action: 'created' | 'shared' | 'used' | 'revoked' | 'exported' | 'imported';
+    details?: string;
+    recipient?: string;
+}
+/**
+ * Viewing key data
+ */
+interface ViewingKey {
+    id: string;
+    publicKey: string;
+    privateKey?: string;
+    label?: string;
+    status: ViewingKeyStatus;
+    createdAt: number;
+    expiresAt?: number;
+    usageHistory: ViewingKeyUsage[];
+    sharedWith?: string[];
+}
+/**
+ * ViewingKeyManager component props
+ */
+interface ViewingKeyManagerProps {
+    /** List of viewing keys */
+    keys: ViewingKey[];
+    /** Callback to generate a new key */
+    onGenerateKey?: (label?: string) => Promise<ViewingKey>;
+    /** Callback to export a key */
+    onExportKey?: (keyId: string, format: KeyExportFormat, password?: string) => Promise<string | Blob>;
+    /** Callback to import a key */
+    onImportKey?: (source: KeyImportSource, data: string | File) => Promise<ViewingKey>;
+    /** Callback to share a key */
+    onShareKey?: (keyId: string, recipient: string) => Promise<void>;
+    /** Callback to revoke a key */
+    onRevokeKey?: (keyId: string) => Promise<void>;
+    /** Callback when backup is acknowledged */
+    onBackupAcknowledged?: (keyId: string) => void;
+    /** Whether to show backup reminder */
+    showBackupReminder?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+}
+/**
+ * ViewingKeyManager - Component for managing NEAR viewing keys
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { ViewingKeyManager } from '@sip-protocol/react'
+ *
+ * function KeyManagement() {
+ *   const [keys, setKeys] = useState<ViewingKey[]>([])
+ *
+ *   return (
+ *     <ViewingKeyManager
+ *       keys={keys}
+ *       onGenerateKey={async (label) => {
+ *         const newKey = await generateViewingKey(label)
+ *         setKeys([...keys, newKey])
+ *         return newKey
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function ViewingKeyManager({ keys, onGenerateKey, onExportKey, onImportKey, onShareKey, onRevokeKey, onBackupAcknowledged: _onBackupAcknowledged, showBackupReminder, className, size, }: ViewingKeyManagerProps): React.JSX.Element;
+/**
+ * Hook to manage viewing keys
+ */
+declare function useViewingKeyManager(initialKeys?: ViewingKey[]): {
+    keys: ViewingKey[];
+    setKeys: React.Dispatch<React.SetStateAction<ViewingKey[]>>;
+    addKey: (key: ViewingKey) => void;
+    removeKey: (keyId: string) => void;
+    updateKey: (keyId: string, updates: Partial<ViewingKey>) => void;
+    revokeKey: (keyId: string) => void;
+    activeKeys: ViewingKey[];
+    revokedKeys: ViewingKey[];
+};
+
+/**
+ * Privacy level options for Ethereum
+ */
+type EthereumPrivacyLevel = 'public' | 'stealth' | 'compliant';
+/**
+ * Supported Ethereum networks
+ */
+type EthereumNetworkId = 'mainnet' | 'arbitrum' | 'optimism' | 'base' | 'polygon' | 'sepolia';
+/**
+ * Gas estimate for Ethereum privacy operations
+ */
+interface EthereumGasEstimate {
+    /** Gas units required */
+    gasUnits: bigint;
+    /** Gas price in gwei */
+    gasPriceGwei: number;
+    /** Total cost in ETH */
+    costEth: string;
+    /** Approximate cost in USD */
+    costUsd?: string;
+    /** L1 data cost (for L2s) */
+    l1DataCost?: string;
+}
+/**
+ * Network-specific gas configuration
+ */
+interface NetworkGasConfig {
+    network: EthereumNetworkId;
+    displayName: string;
+    nativeSymbol: string;
+    gasMultiplier: number;
+    isL2: boolean;
+}
+/**
+ * Privacy level metadata for Ethereum
+ */
+interface EthereumPrivacyLevelInfo {
+    level: EthereumPrivacyLevel;
+    label: string;
+    description: string;
+    eipReference?: string;
+    icon: React.ReactNode;
+    gasEstimate?: EthereumGasEstimate;
+}
+/**
+ * EthereumPrivacyToggle component props
+ */
+interface EthereumPrivacyToggleProps {
+    /** Current privacy level (controlled mode) */
+    value?: EthereumPrivacyLevel;
+    /** Default privacy level (uncontrolled mode) */
+    defaultValue?: EthereumPrivacyLevel;
+    /** Callback when privacy level changes */
+    onChange?: (level: EthereumPrivacyLevel) => void;
+    /** Whether the toggle is disabled */
+    disabled?: boolean;
+    /** Network for gas estimates */
+    network?: EthereumNetworkId;
+    /** Custom gas estimates */
+    gasEstimates?: Partial<Record<EthereumPrivacyLevel, EthereumGasEstimate>>;
+    /** Show gas/fee estimates */
+    showGasEstimate?: boolean;
+    /** Show EIP references */
+    showEipReferences?: boolean;
+    /** Show tooltips */
+    showTooltips?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Compact mode (icon only) */
+    compact?: boolean;
+    /** Show L2 savings badge */
+    showL2Savings?: boolean;
+    /** Aria label for the toggle group */
+    'aria-label'?: string;
+}
+/**
+ * EthereumPrivacyToggle - Toggle for selecting Ethereum privacy level
+ *
+ * A three-state toggle for EIP-5564 stealth address privacy on Ethereum and L2s.
+ * Shows gas estimates, L2 savings, and EIP references.
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { EthereumPrivacyToggle } from '@sip-protocol/react'
+ *
+ * function SendForm() {
+ *   const [privacy, setPrivacy] = useState<EthereumPrivacyLevel>('stealth')
+ *
+ *   return (
+ *     <EthereumPrivacyToggle
+ *       value={privacy}
+ *       onChange={setPrivacy}
+ *       network="base"
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With gas estimates and L2 savings
+ * ```tsx
+ * <EthereumPrivacyToggle
+ *   value={privacy}
+ *   onChange={setPrivacy}
+ *   network="arbitrum"
+ *   showGasEstimate
+ *   showL2Savings
+ * />
+ * ```
+ *
+ * @example Compact mode for toolbars
+ * ```tsx
+ * <EthereumPrivacyToggle
+ *   value={privacy}
+ *   onChange={setPrivacy}
+ *   compact
+ *   size="sm"
+ * />
+ * ```
+ */
+declare function EthereumPrivacyToggle({ value, defaultValue, onChange, disabled, network, gasEstimates, showGasEstimate, showEipReferences, showTooltips, className, size, compact, showL2Savings, 'aria-label': ariaLabel, }: EthereumPrivacyToggleProps): React.JSX.Element;
+/**
+ * Hook to use with EthereumPrivacyToggle for managing privacy state
+ */
+declare function useEthereumPrivacyToggle(initialValue?: EthereumPrivacyLevel): {
+    privacyLevel: EthereumPrivacyLevel;
+    setPrivacyLevel: React.Dispatch<React.SetStateAction<EthereumPrivacyLevel>>;
+    isPrivate: boolean;
+    isCompliant: boolean;
+    isStealth: boolean;
+    setPublic: () => void;
+    setStealth: () => void;
+    setCompliant: () => void;
+    eipStandard: string | null;
+};
+
+/**
+ * Ethereum Transaction Tracker
+ *
+ * Preset configuration for tracking Ethereum privacy transactions.
+ *
+ * @module components/ethereum/transaction-tracker
+ */
+
+/**
+ * Ethereum network configuration
+ */
+interface EthereumNetwork {
+    name: string;
+    chainId: number;
+    explorerUrl: string;
+    /** Average block time in seconds */
+    blockTime: number;
+    /** Confirmations required for finality */
+    requiredConfirmations: number;
+}
+/**
+ * Predefined Ethereum networks
+ */
+declare const ETHEREUM_NETWORKS: Record<string, EthereumNetwork>;
+/**
+ * Get network by chain ID
+ */
+declare function getNetworkByChainId(chainId: number): EthereumNetwork | undefined;
+/**
+ * EthereumTransactionTracker props
+ */
+interface EthereumTransactionTrackerProps extends Omit<TransactionTrackerProps, 'networkName' | 'explorerUrlTemplate'> {
+    /** Network name or chain ID */
+    network?: string | number;
+    /** Custom network configuration */
+    customNetwork?: EthereumNetwork;
+}
+/**
+ * EthereumTransactionTracker - Ethereum-configured transaction tracker
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { EthereumTransactionTracker } from '@sip-protocol/react'
+ *
+ * function TransactionView({ tx }) {
+ *   return (
+ *     <EthereumTransactionTracker
+ *       transaction={tx}
+ *       network="mainnet"
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With L2 network
+ * ```tsx
+ * <EthereumTransactionTracker
+ *   transaction={tx}
+ *   network="arbitrum"
+ *   showPrivacyStatus
+ * />
+ * ```
+ */
+declare function EthereumTransactionTracker({ network, customNetwork, transaction, ...props }: EthereumTransactionTrackerProps): React.JSX.Element;
+/**
+ * Hook for managing Ethereum transaction tracking
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   transaction,
+ *   updateTransaction,
+ *   startPolling,
+ *   stopPolling,
+ *   estimatedTimeToFinality,
+ * } = useEthereumTransactionTracker(tx, {
+ *   network: 'mainnet',
+ *   pollingInterval: 3000,
+ *   onConfirmed: (tx) => console.log('Confirmed!', tx),
+ * })
+ * ```
+ */
+declare function useEthereumTransactionTracker(initialTransaction?: PrivacyTransaction, options?: {
+    network?: string | number;
+    pollingInterval?: number;
+    onStatusChange?: (status: TransactionStatus) => void;
+    onConfirmed?: (tx: PrivacyTransaction) => void;
+    onFinalized?: (tx: PrivacyTransaction) => void;
+    onFailed?: (tx: PrivacyTransaction) => void;
+}): {
+    networkConfig: EthereumNetwork;
+    estimatedTimeToFinality: number | null;
+    formattedTimeToFinality: string | null;
+    explorerUrl: string | null;
+    transaction: PrivacyTransaction | null;
+    setTransaction: React.Dispatch<React.SetStateAction<PrivacyTransaction | null>>;
+    updateTransaction: (updates: Partial<PrivacyTransaction>) => void;
+    isPolling: boolean;
+    startPolling: () => void;
+    stopPolling: () => void;
+    isFinal: boolean;
+};
+
+/**
+ * Ethereum Viewing Key Manager
+ *
+ * Preset configuration for managing Ethereum viewing keys.
+ *
+ * @module components/ethereum/viewing-key-manager
+ */
+
+/**
+ * Ethereum-specific viewing key data
+ */
+interface EthereumViewingKey extends ViewingKey {
+    /** Chain ID the key is associated with */
+    chainId?: number;
+    /** Stealth meta-address associated with this key */
+    stealthMetaAddress?: string;
+}
+/**
+ * EthereumViewingKeyManager props
+ */
+interface EthereumViewingKeyManagerProps extends Omit<ViewingKeyManagerProps, 'keys' | 'onGenerateKey' | 'onExportKey' | 'onImportKey' | 'onShareKey' | 'onRevokeKey'> {
+    /** List of Ethereum viewing keys */
+    keys: EthereumViewingKey[];
+    /** Callback to generate a new key */
+    onGenerateKey?: (label?: string, chainId?: number) => Promise<EthereumViewingKey>;
+    /** Callback to export a key */
+    onExportKey?: (keyId: string, format: KeyExportFormat, password?: string) => Promise<string | Blob>;
+    /** Callback to import a key */
+    onImportKey?: (source: KeyImportSource, data: string | File) => Promise<EthereumViewingKey>;
+    /** Callback to share a key */
+    onShareKey?: (keyId: string, recipient: string) => Promise<void>;
+    /** Callback to revoke a key */
+    onRevokeKey?: (keyId: string) => Promise<void>;
+    /** Default chain ID for new keys */
+    defaultChainId?: number;
+}
+/**
+ * EthereumViewingKeyManager - Ethereum-configured viewing key manager
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { EthereumViewingKeyManager } from '@sip-protocol/react'
+ *
+ * function KeyManagement() {
+ *   const [keys, setKeys] = useState<EthereumViewingKey[]>([])
+ *
+ *   return (
+ *     <EthereumViewingKeyManager
+ *       keys={keys}
+ *       onGenerateKey={async (label, chainId) => {
+ *         const key = await generateEthereumViewingKey(label, chainId)
+ *         setKeys([...keys, key])
+ *         return key
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function EthereumViewingKeyManager({ keys, onGenerateKey, onExportKey, onImportKey, onShareKey, onRevokeKey, defaultChainId, ...props }: EthereumViewingKeyManagerProps): React.JSX.Element;
+/**
+ * Hook for managing Ethereum viewing keys
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   keys,
+ *   activeKeys,
+ *   generateKey,
+ *   exportKey,
+ *   revokeKey,
+ * } = useEthereumViewingKey({
+ *   chainId: 1,
+ *   onKeyGenerated: (key) => console.log('Generated:', key),
+ * })
+ * ```
+ */
+declare function useEthereumViewingKey(options?: {
+    chainId?: number;
+    initialKeys?: EthereumViewingKey[];
+    onKeyGenerated?: (key: EthereumViewingKey) => void;
+    onKeyRevoked?: (keyId: string) => void;
+}): {
+    keys: EthereumViewingKey[];
+    activeKeys: EthereumViewingKey[];
+    revokedKeys: EthereumViewingKey[];
+    generateKey: (label?: string) => Promise<EthereumViewingKey>;
+    revokeKey: (keyId: string) => void;
+    keysForChain: (targetChainId: number) => EthereumViewingKey[];
+    formatViewingKeyAddress: (key: EthereumViewingKey) => string;
+    currentChainId: number;
+    setKeys: React.Dispatch<React.SetStateAction<ViewingKey[]>>;
+    addKey: (key: ViewingKey) => void;
+    removeKey: (keyId: string) => void;
+    updateKey: (keyId: string, updates: Partial<ViewingKey>) => void;
+};
+
+/**
+ * EthereumStealthAddressDisplay Component
+ *
+ * Displays EIP-5564 stealth addresses with Ethereum-specific features including
+ * network support for mainnet and L2s, Etherscan integration, and EIP-5564 validation.
+ *
+ * @module components/ethereum/stealth-address-display
+ */
+/**
+ * Ownership status for stealth addresses
+ */
+type EthereumOwnershipStatus = 'yours' | 'others' | 'unknown';
+/**
+ * Ethereum network IDs
+ */
+type EthereumStealthNetworkId = 'mainnet' | 'arbitrum' | 'optimism' | 'base' | 'polygon' | 'sepolia';
+/**
+ * Network configuration for explorer links
+ */
+interface EthereumStealthNetworkConfig {
+    name: string;
+    chainId: number;
+    explorerUrl: string;
+    explorerName: string;
+    isL2: boolean;
+    color: string;
+}
+/**
+ * Default Ethereum network configurations
+ */
+declare const ETHEREUM_STEALTH_NETWORKS: Record<EthereumStealthNetworkId, EthereumStealthNetworkConfig>;
+/**
+ * EthereumStealthAddressDisplay component props
+ */
+interface EthereumStealthAddressDisplayProps {
+    /** The stealth address to display (0x prefixed, 42 chars) */
+    address: string;
+    /** Optional stealth meta-address for QR code (full sip: format) */
+    metaAddress?: string;
+    /** Optional ephemeral public key (EIP-5564) */
+    ephemeralPublicKey?: string;
+    /** View tag for the stealth address (EIP-5564) */
+    viewTag?: number;
+    /** Ownership status of the address */
+    ownership?: EthereumOwnershipStatus;
+    /** Whether the address is validated */
+    isValid?: boolean;
+    /** Network for explorer links */
+    network?: EthereumStealthNetworkId;
+    /** Custom network configuration */
+    networkConfig?: EthereumStealthNetworkConfig;
+    /** Whether to show the QR code button */
+    showQrCode?: boolean;
+    /** Whether to show the explorer link */
+    showExplorerLink?: boolean;
+    /** Whether to show the copy button */
+    showCopyButton?: boolean;
+    /** Whether to show the ownership badge */
+    showOwnership?: boolean;
+    /** Whether to show the validation indicator */
+    showValidation?: boolean;
+    /** Whether to show the network badge */
+    showNetworkBadge?: boolean;
+    /** Whether to show the EIP-5564 badge */
+    showEipBadge?: boolean;
+    /** Whether to show the view tag */
+    showViewTag?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Callback when address is copied */
+    onCopy?: (address: string) => void;
+    /** Callback when QR code is shown */
+    onShowQr?: (address: string) => void;
+    /** Callback when ephemeral key is copied */
+    onCopyEphemeralKey?: (key: string) => void;
+}
+/**
+ * Validates an Ethereum address format
+ */
+declare function isValidEthereumAddress(address: string): boolean;
+/**
+ * Validates an EIP-5564 stealth address
+ * Stealth addresses are valid Ethereum addresses generated from EIP-5564
+ */
+declare function isValidEthereumStealthAddress(address: string): boolean;
+/**
+ * Validates an ephemeral public key (compressed secp256k1)
+ */
+declare function isValidEphemeralPublicKey(key: string): boolean;
+/**
+ * Truncates an address for display
+ */
+declare function truncateEthereumAddress(address: string, startChars?: number, endChars?: number): string;
+/**
+ * EthereumStealthAddressDisplay - Component for displaying EIP-5564 stealth addresses
+ *
+ * Displays stealth addresses with Ethereum-specific visual styling,
+ * including network support, Etherscan links, and EIP-5564 metadata.
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { EthereumStealthAddressDisplay } from '@sip-protocol/react'
+ *
+ * function WalletView() {
+ *   return (
+ *     <EthereumStealthAddressDisplay
+ *       address="0x742d35Cc6634C0532925a3b844Bc9e7595f2..."
+ *       ownership="yours"
+ *     />
+ *   )
+ * }
+ * ```
+ *
+ * @example With EIP-5564 metadata
+ * ```tsx
+ * <EthereumStealthAddressDisplay
+ *   address="0x742d35Cc6634C0532925a3b844Bc9e7595f2..."
+ *   ephemeralPublicKey="0x02abc...123"
+ *   viewTag={42}
+ *   network="arbitrum"
+ *   showEipBadge
+ *   showViewTag
+ * />
+ * ```
+ */
+declare function EthereumStealthAddressDisplay({ address, metaAddress, ephemeralPublicKey, viewTag, ownership, isValid, network, networkConfig, showQrCode, showExplorerLink, showCopyButton, showOwnership, showValidation, showNetworkBadge, showEipBadge, showViewTag, className, size, onCopy, onShowQr, onCopyEphemeralKey, }: EthereumStealthAddressDisplayProps): React.JSX.Element;
+/**
+ * Hook to manage Ethereum stealth address display state
+ */
+declare function useEthereumStealthAddressDisplay(address: string, options?: {
+    checkOwnership?: (address: string) => EthereumOwnershipStatus;
+    validateAddress?: (address: string) => boolean;
+    network?: EthereumStealthNetworkId;
+}): {
+    address: string;
+    truncated: string;
+    ownership: EthereumOwnershipStatus;
+    isValid: boolean;
+    isStealth: boolean;
+    network: EthereumStealthNetworkId;
+    networkConfig: EthereumStealthNetworkConfig;
+    explorerUrl: string;
+    isL2: boolean;
+};
+
+/**
+ * Ethereum Privacy Transaction History
+ *
+ * Component for displaying history of Ethereum privacy transactions.
+ *
+ * @module components/ethereum/transaction-history
+ */
+
+/**
+ * Transaction direction
+ */
+type TransactionDirection = 'sent' | 'received' | 'claimed';
+/**
+ * Transaction type
+ */
+type TransactionType = 'stealth_transfer' | 'standard_transfer' | 'claim';
+/**
+ * Privacy transaction history item
+ */
+interface PrivacyTransactionHistoryItem {
+    /** Transaction hash */
+    hash: string;
+    /** Transaction direction */
+    direction: TransactionDirection;
+    /** Transaction type */
+    type: TransactionType;
+    /** Timestamp in milliseconds */
+    timestamp: number;
+    /** Block number */
+    blockNumber?: number;
+    /** From address */
+    from: string;
+    /** To address (may be stealth address) */
+    to: string;
+    /** Whether to address is stealth */
+    isStealthAddress: boolean;
+    /** Amount in token units (string for precision) */
+    amount: string;
+    /** Token symbol */
+    tokenSymbol: string;
+    /** Token decimals */
+    tokenDecimals: number;
+    /** USD value at time of transaction */
+    usdValue?: string;
+    /** Current USD value */
+    currentUsdValue?: string;
+    /** Gas used */
+    gasUsed?: string;
+    /** Gas price in gwei */
+    gasPrice?: string;
+    /** Transaction fee in ETH */
+    fee?: string;
+    /** Status */
+    status: 'pending' | 'confirmed' | 'failed';
+    /** Ephemeral public key for stealth transactions */
+    ephemeralPublicKey?: string;
+    /** View tag for efficient scanning */
+    viewTag?: number;
+    /** Claim key (only for received/claimed) */
+    claimKey?: string;
+}
+/**
+ * Filter options for transaction history
+ */
+interface TransactionHistoryFilter {
+    direction?: TransactionDirection | 'all';
+    type?: TransactionType | 'all';
+    status?: 'pending' | 'confirmed' | 'failed' | 'all';
+    tokenSymbol?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    minAmount?: string;
+    maxAmount?: string;
+}
+/**
+ * Sort options for transaction history
+ */
+interface TransactionHistorySort {
+    field: 'timestamp' | 'amount' | 'usdValue';
+    direction: 'asc' | 'desc';
+}
+/**
+ * TransactionHistory component props
+ */
+interface TransactionHistoryProps {
+    /** List of transactions */
+    transactions: PrivacyTransactionHistoryItem[];
+    /** Loading state */
+    isLoading?: boolean;
+    /** Error message */
+    error?: string | null;
+    /** Filter options */
+    filter?: TransactionHistoryFilter;
+    /** Sort options */
+    sort?: TransactionHistorySort;
+    /** Callback when filter changes */
+    onFilterChange?: (filter: TransactionHistoryFilter) => void;
+    /** Callback when sort changes */
+    onSortChange?: (sort: TransactionHistorySort) => void;
+    /** Callback to load more transactions */
+    onLoadMore?: () => void;
+    /** Whether more transactions are available */
+    hasMore?: boolean;
+    /** Callback to export transactions */
+    onExport?: (format: 'csv' | 'json') => void;
+    /** Callback when transaction is selected */
+    onTransactionSelect?: (tx: PrivacyTransactionHistoryItem) => void;
+    /** Network configuration */
+    network?: string | EthereumNetwork;
+    /** Items per page for pagination */
+    pageSize?: number;
+    /** Custom class name */
+    className?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Show USD values */
+    showUsdValues?: boolean;
+    /** Show filters */
+    showFilters?: boolean;
+    /** Show export button */
+    showExport?: boolean;
+}
+/**
+ * TransactionHistory - Display privacy transaction history
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { TransactionHistory } from '@sip-protocol/react'
+ *
+ * function HistoryView() {
+ *   const [transactions, setTransactions] = useState([])
+ *
+ *   return (
+ *     <TransactionHistory
+ *       transactions={transactions}
+ *       onTransactionSelect={(tx) => console.log('Selected:', tx)}
+ *       network="mainnet"
+ *       showFilters
+ *       showExport
+ *     />
+ *   )
+ * }
+ * ```
+ */
+declare function TransactionHistory({ transactions, isLoading, error, filter, sort, onFilterChange, onSortChange, onLoadMore, hasMore, onExport, onTransactionSelect, network, pageSize, className, size, showUsdValues, showFilters, showExport, }: TransactionHistoryProps): React.JSX.Element;
+/**
+ * Hook for managing transaction history
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   transactions,
+ *   isLoading,
+ *   filter,
+ *   setFilter,
+ *   loadMore,
+ *   refresh,
+ *   exportHistory,
+ * } = useTransactionHistory({
+ *   viewingPrivateKey,
+ *   spendingPublicKey,
+ *   network: 'mainnet',
+ * })
+ * ```
+ */
+declare function useTransactionHistory(options?: {
+    initialTransactions?: PrivacyTransactionHistoryItem[];
+    fetchTransactions?: () => Promise<PrivacyTransactionHistoryItem[]>;
+    pageSize?: number;
+}): {
+    transactions: PrivacyTransactionHistoryItem[];
+    setTransactions: React.Dispatch<React.SetStateAction<PrivacyTransactionHistoryItem[]>>;
+    isLoading: boolean;
+    error: string | null;
+    filter: TransactionHistoryFilter;
+    setFilter: React.Dispatch<React.SetStateAction<TransactionHistoryFilter>>;
+    sort: TransactionHistorySort;
+    setSort: React.Dispatch<React.SetStateAction<TransactionHistorySort>>;
+    hasMore: boolean;
+    setHasMore: React.Dispatch<React.SetStateAction<boolean>>;
+    loadTransactions: () => Promise<void>;
+    addTransaction: (tx: PrivacyTransactionHistoryItem) => void;
+    updateTransaction: (hash: string, updates: Partial<PrivacyTransactionHistoryItem>) => void;
+    exportHistory: (format: "csv" | "json") => void;
+    summary: {
+        total: number;
+        sent: number;
+        received: number;
+        claimed: number;
+        stealthCount: number;
+        stealthPercentage: number;
+    };
+};
+
+/**
+ * Transaction type for NEAR privacy operations
+ */
+type NEARTransactionType = 'send' | 'receive' | 'contract_call';
+/**
+ * Export format options
+ */
+type NEARExportFormat = 'csv' | 'json';
+/**
+ * Historical transaction structure
+ */
+interface NEARHistoricalTransaction {
+    hash: string;
+    timestamp: number;
+    blockHeight: number;
+    type: NEARTransactionType;
+    stealthAddress: string;
+    stealthPublicKey: HexString;
+    ephemeralPublicKey: HexString;
+    viewTag: number;
+    amount: string;
+    amountFormatted: string;
+    token: string;
+    tokenContract: string | null;
+    decimals: number;
+    privacyLevel: 'transparent' | 'shielded' | 'compliant';
+    amountRevealed: boolean;
+    sender?: string;
+    receiver?: string;
+    fee?: string;
+    explorerUrl: string;
+    recipientLabel?: string;
+}
+/**
+ * Transaction history view component props
+ */
+interface TransactionHistoryViewProps {
+    /** NEAR RPC URL */
+    rpcUrl: string;
+    /** Viewing private key (hex) */
+    viewingPrivateKey: HexString;
+    /** Spending private key (hex) */
+    spendingPrivateKey: HexString;
+    /** Network type */
+    network?: 'mainnet' | 'testnet';
+    /** Number of transactions per page */
+    pageSize?: number;
+    /** Auto-refresh interval in milliseconds (0 = disabled) */
+    refreshInterval?: number;
+    /** Whether to show filter controls */
+    showFilters?: boolean;
+    /** Whether to show export button */
+    showExport?: boolean;
+    /** Whether to show summary statistics */
+    showSummary?: boolean;
+    /** Whether to show search */
+    showSearch?: boolean;
+    /** Callback when transaction is clicked */
+    onTransactionClick?: (tx: NEARHistoricalTransaction) => void;
+    /** Callback when export is triggered */
+    onExport?: (format: NEARExportFormat, data: string) => void;
+    /** Custom class name */
+    className?: string;
+    /** Theme */
+    theme?: 'light' | 'dark';
+}
+/**
+ * TransactionHistoryView - Display NEAR privacy transaction history
+ *
+ * A comprehensive component for viewing, filtering, and exporting
+ * NEAR privacy transaction history.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <TransactionHistoryView
+ *   rpcUrl="https://rpc.mainnet.near.org"
+ *   viewingPrivateKey="0x..."
+ *   spendingPrivateKey="0x..."
+ * />
+ * ```
+ *
+ * @example With callbacks
+ * ```tsx
+ * <TransactionHistoryView
+ *   rpcUrl="https://rpc.mainnet.near.org"
+ *   viewingPrivateKey="0x..."
+ *   spendingPrivateKey="0x..."
+ *   onTransactionClick={(tx) => openInExplorer(tx.explorerUrl)}
+ *   onExport={(format, data) => downloadFile(`transactions.${format}`, data)}
+ *   showFilters
+ *   showExport
+ *   showSummary
+ * />
+ * ```
+ */
+declare function TransactionHistoryView({ rpcUrl, viewingPrivateKey, spendingPrivateKey, network, pageSize, refreshInterval, showFilters, showExport, showSummary, showSearch, onTransactionClick, onExport, className, theme, }: TransactionHistoryViewProps): React.JSX.Element;
+
+export { ETHEREUM_NETWORKS, ETHEREUM_STEALTH_NETWORKS, type EthereumGasEstimate, type EthereumNetwork, type EthereumNetworkId, type EthereumOwnershipStatus, type EthereumPrivacyLevel, type EthereumPrivacyLevelInfo, EthereumPrivacyToggle, type EthereumPrivacyToggleProps, EthereumStealthAddressDisplay, type EthereumStealthAddressDisplayProps, type EthereumStealthNetworkConfig, type EthereumStealthNetworkId, EthereumTransactionTracker, type EthereumTransactionTrackerProps, type EthereumViewingKey, EthereumViewingKeyManager, type EthereumViewingKeyManagerProps, type GasEstimate, type KeyExportFormat, type KeyImportSource, TransactionHistoryView as NEARTransactionHistoryView, type TransactionHistoryViewProps as NEARTransactionHistoryViewProps, NEAR_NETWORKS, type NetworkConfig, type NetworkGasConfig, type OwnershipStatus, type PrivacyLevel, type PrivacyLevelInfo, PrivacyToggle, type PrivacyToggleProps, type PrivacyTransaction, type PrivacyTransactionHistoryItem, type PrivacyVerification, type PrivacyVerificationStatus, SIPProvider, type SIPProviderProps, StealthAddressDisplay, type StealthAddressDisplayProps, type TransactionAction, type TransactionActionType, TransactionHistory, type TransactionHistoryFilter, type TransactionHistoryProps, type TransactionHistorySort, type TransactionStatus, TransactionTracker, type TransactionTrackerProps, type ViewingKey, ViewingKeyManager, type ViewingKeyManagerProps, type ViewingKeyStatus, type ViewingKeyUsage, getNetworkByChainId, isValidEphemeralPublicKey, isValidEthereumAddress, isValidEthereumStealthAddress, isValidStealthAddress, truncateAddress, truncateEthereumAddress, useEthereumPrivacyToggle, useEthereumStealthAddressDisplay, useTransactionHistory as useEthereumTransactionHistory, useEthereumTransactionTracker, useEthereumViewingKey, usePrivacyToggle, usePrivateSwap, useSIP, useStealthAddress, useStealthAddressDisplay, useTransactionTracker, useViewingKey, useViewingKeyManager };