@thehoneyjar/sigil-dev-toolbar 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1099 @@
+import { Address, Hash, Hex } from 'viem';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Zone hierarchy for physics validation
+ */
+type Zone = 'critical' | 'elevated' | 'standard' | 'local';
+/**
+ * Lens context for User Lens impersonation validation
+ */
+interface LensContext {
+    /** Address being impersonated */
+    impersonatedAddress: string;
+    /** Real user address (for signing) */
+    realAddress?: string;
+    /** Component being validated */
+    component: string;
+    /** Value observed in the UI */
+    observedValue?: string;
+    /** Value from on-chain read */
+    onChainValue?: string;
+    /** Value from indexer (Envio, Subgraph) */
+    indexedValue?: string;
+    /** Data source used by component */
+    dataSource?: 'on-chain' | 'indexed' | 'mixed' | 'unknown';
+}
+/**
+ * Lens validation issue types
+ */
+type LensIssueType = 'data_source_mismatch' | 'stale_indexed_data' | 'lens_financial_check' | 'impersonation_leak';
+/**
+ * Lens validation issue severity
+ */
+type LensIssueSeverity = 'error' | 'warning' | 'info';
+/**
+ * Individual lens validation issue
+ */
+interface LensValidationIssue {
+    /** Issue type */
+    type: LensIssueType;
+    /** Severity */
+    severity: LensIssueSeverity;
+    /** Human-readable message */
+    message: string;
+    /** Component where issue was found */
+    component: string;
+    /** Zone context */
+    zone?: Zone;
+    /** Expected value */
+    expected?: string;
+    /** Actual value */
+    actual?: string;
+    /** Suggested fix */
+    suggestion?: string;
+}
+/**
+ * Lens validation result
+ */
+interface LensValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** List of issues found */
+    issues: LensValidationIssue[];
+    /** Summary message */
+    summary: string;
+}
+/**
+ * User Lens state for address impersonation
+ */
+interface UserLensState {
+    /** Whether impersonation is enabled */
+    enabled: boolean;
+    /** The address being impersonated (for reads) */
+    impersonatedAddress: Address | null;
+    /** Saved addresses for quick selection */
+    savedAddresses: SavedAddress[];
+}
+/**
+ * Saved address entry
+ */
+interface SavedAddress {
+    address: Address;
+    label: string;
+    ens?: string;
+}
+/**
+ * Simulation state for testing scenarios
+ */
+interface SimulationState {
+    /** Whether simulation mode is active */
+    enabled: boolean;
+    /** Current simulation scenario */
+    scenario: SimulationScenario | null;
+}
+/**
+ * Simulation scenario configuration
+ */
+interface SimulationScenario {
+    id: string;
+    name: string;
+    description: string;
+    /** Override values for contract reads */
+    overrides: Record<string, unknown>;
+}
+/**
+ * Comparison state for before/after views
+ */
+interface ComparisonState {
+    /** Whether comparison mode is active */
+    enabled: boolean;
+    /** Captured "before" state */
+    beforeState: Record<string, unknown> | null;
+    /** Current "after" state */
+    afterState: Record<string, unknown> | null;
+}
+/**
+ * Diagnostics state for debugging
+ */
+interface DiagnosticsState {
+    /** Whether diagnostics panel is open */
+    enabled: boolean;
+    /** Recent physics violations */
+    violations: PhysicsViolation[];
+    /** Recent taste signals */
+    tasteSignals: TasteSignal[];
+}
+/**
+ * Physics violation detected by toolbar
+ */
+interface PhysicsViolation {
+    id: string;
+    timestamp: number;
+    type: 'behavioral' | 'animation' | 'material' | 'protected';
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    element?: string;
+    suggestion?: string;
+}
+/**
+ * Taste signal for preference learning
+ */
+interface TasteSignal {
+    id: string;
+    timestamp: number;
+    type: 'ACCEPT' | 'MODIFY' | 'REJECT';
+    component: string;
+    effect: string;
+    change?: {
+        from: string;
+        to: string;
+    };
+}
+/**
+ * Dev toolbar configuration options
+ */
+interface DevToolbarConfig {
+    /** Position of the toolbar */
+    position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Initial collapsed state */
+    defaultCollapsed: boolean;
+    /** Enable User Lens feature */
+    enableUserLens: boolean;
+    /** Enable Simulation feature */
+    enableSimulation: boolean;
+    /** Enable Comparison feature */
+    enableComparison: boolean;
+    /** Enable Diagnostics feature */
+    enableDiagnostics: boolean;
+    /** Keyboard shortcut to toggle toolbar */
+    toggleShortcut: string;
+    /** Callback for Anchor/Lens IPC */
+    onAnchorRequest?: (request: AnchorRequest) => Promise<AnchorResponse>;
+    /** Callback for taste signal logging */
+    onTasteSignal?: (signal: TasteSignal) => void;
+}
+/**
+ * Anchor verification request
+ */
+interface AnchorRequest {
+    type: 'validate' | 'verify' | 'check';
+    context: {
+        address: Address;
+        isImpersonating: boolean;
+        realAddress?: Address;
+    };
+    payload: Record<string, unknown>;
+}
+/**
+ * Anchor verification response
+ */
+interface AnchorResponse {
+    valid: boolean;
+    violations?: PhysicsViolation[];
+    suggestions?: string[];
+}
+/**
+ * Active tab in the toolbar
+ */
+type ToolbarTab = 'lens' | 'simulate' | 'compare' | 'diagnose';
+/**
+ * Complete toolbar state
+ */
+interface DevToolbarState {
+    /** Whether toolbar is visible */
+    visible: boolean;
+    /** Whether toolbar is collapsed */
+    collapsed: boolean;
+    /** Currently active tab */
+    activeTab: ToolbarTab;
+    /** User Lens state */
+    userLens: UserLensState;
+    /** Simulation state */
+    simulation: SimulationState;
+    /** Comparison state */
+    comparison: ComparisonState;
+    /** Diagnostics state */
+    diagnostics: DiagnosticsState;
+}
+/**
+ * Dev toolbar store actions
+ */
+interface DevToolbarActions {
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+    collapse: () => void;
+    expand: () => void;
+    setActiveTab: (tab: ToolbarTab) => void;
+    enableLens: (address: Address) => void;
+    disableLens: () => void;
+    setImpersonatedAddress: (address: Address | null) => void;
+    saveAddress: (entry: SavedAddress) => void;
+    removeAddress: (address: Address) => void;
+    enableSimulation: (scenario: SimulationScenario) => void;
+    disableSimulation: () => void;
+    captureBeforeState: (state: Record<string, unknown>) => void;
+    captureAfterState: (state: Record<string, unknown>) => void;
+    clearComparison: () => void;
+    addViolation: (violation: PhysicsViolation) => void;
+    clearViolations: () => void;
+    addTasteSignal: (signal: TasteSignal) => void;
+    clearTasteSignals: () => void;
+    reset: () => void;
+}
+
+/**
+ * Create the Zustand store with persistence
+ */
+type DevToolbarStore = DevToolbarState & DevToolbarActions;
+/**
+ * Props for DevToolbarProvider
+ */
+interface DevToolbarProviderProps {
+    children: ReactNode;
+    config?: Partial<DevToolbarConfig>;
+}
+/**
+ * Provider component for the dev toolbar
+ */
+declare function DevToolbarProvider({ children, config: userConfig }: DevToolbarProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the dev toolbar store
+ */
+declare function useDevToolbar(): DevToolbarStore;
+/**
+ * Hook to access specific state with selector
+ */
+declare function useDevToolbarSelector<T>(selector: (state: DevToolbarStore) => T): T;
+/**
+ * Hook to access the toolbar config
+ */
+declare function useDevToolbarConfig(): DevToolbarConfig;
+
+/**
+ * Return type for useLensAwareAccount
+ */
+interface LensAwareAccount {
+    /** Address for reads - impersonated if lens enabled, otherwise real */
+    address: Address | undefined;
+    /** The user's real connected address (always available for signing) */
+    realAddress: Address | undefined;
+    /** Whether currently impersonating another address */
+    isImpersonating: boolean;
+    /** The impersonated address (if any) */
+    impersonatedAddress: Address | null;
+    /** Whether the wallet is connected */
+    isConnected: boolean;
+}
+/**
+ * Hook that returns impersonated address for reads, real address for writes.
+ *
+ * Use this hook in place of wagmi's `useAccount` when you want components
+ * to display data for an impersonated address while still being able to
+ * sign transactions with the real connected wallet.
+ *
+ * @example
+ * ```tsx
+ * function WalletInfo() {
+ *   const { address, realAddress, isImpersonating } = useLensAwareAccount()
+ *
+ *   // Use `address` for reading data (respects impersonation)
+ *   const { data: balance } = useBalance({ address })
+ *
+ *   // Use `realAddress` for signing transactions
+ *   const { writeContract } = useWriteContract()
+ *
+ *   return (
+ *     <div>
+ *       <p>Viewing: {address}</p>
+ *       {isImpersonating && <Badge>Lens Active</Badge>}
+ *       <button onClick={() => writeContract({ ... })}>
+ *         Sign with {realAddress}
+ *       </button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useLensAwareAccount(): LensAwareAccount;
+/**
+ * Hook to get just the impersonation status
+ *
+ * @example
+ * ```tsx
+ * function LensBadge() {
+ *   const isImpersonating = useIsImpersonating()
+ *   if (!isImpersonating) return null
+ *   return <Badge variant="warning">Lens Active</Badge>
+ * }
+ * ```
+ */
+declare function useIsImpersonating(): boolean;
+/**
+ * Hook to get the impersonated address (or null if not impersonating)
+ */
+declare function useImpersonatedAddress(): Address | null;
+/**
+ * Hook to get saved addresses for quick selection
+ */
+declare function useSavedAddresses(): {
+    savedAddresses: SavedAddress[];
+    saveAddress: (entry: SavedAddress) => void;
+    removeAddress: (address: `0x${string}`) => void;
+    selectAddress: (address: `0x${string}` | null) => void;
+};
+
+/**
+ * IPC Types for Toolbar <-> Anchor/Lens Communication
+ */
+
+/** IPC Request types */
+type IPCRequestType = 'lens-validate' | 'anchor-validate' | 'lens-verify';
+/** Base IPC Request */
+interface IPCRequest<T = unknown> {
+    /** Unique request ID */
+    id: string;
+    /** Request type */
+    type: IPCRequestType;
+    /** Timestamp */
+    timestamp: number;
+    /** Request payload */
+    payload: T;
+}
+/** Lens validation request payload */
+interface LensValidatePayload {
+    /** Lens context to validate */
+    context: LensContext;
+    /** Zone for validation */
+    zone?: Zone;
+}
+/** Anchor validation request payload */
+interface AnchorValidatePayload {
+    /** Grounding statement */
+    statement?: string;
+    /** Lens context (optional) */
+    lensContext?: LensContext;
+    /** Zone for lens validation */
+    zone?: Zone;
+}
+/** IPC Response status */
+type IPCResponseStatus = 'success' | 'error' | 'timeout';
+/** Base IPC Response */
+interface IPCResponse<T = unknown> {
+    /** Request ID this responds to */
+    requestId: string;
+    /** Response status */
+    status: IPCResponseStatus;
+    /** Timestamp */
+    timestamp: number;
+    /** Response data (if success) */
+    data?: T;
+    /** Error message (if error) */
+    error?: string;
+    /** Exit code from CLI */
+    exitCode?: number;
+}
+/** Lens validation response data */
+interface LensValidateResponse {
+    valid: boolean;
+    issues: LensValidationResult['issues'];
+    summary: string;
+}
+/** Anchor validation response data */
+interface AnchorValidateResponse {
+    status?: 'VALID' | 'DRIFT' | 'DECEPTIVE';
+    checks?: {
+        relevance: {
+            passed: boolean;
+            reason: string;
+        };
+        hierarchy: {
+            passed: boolean;
+            reason: string;
+        };
+        rules: {
+            passed: boolean;
+            reason: string;
+        };
+    };
+    requiredZone?: Zone;
+    citedZone?: Zone | null;
+    correction?: string;
+    lens_validation?: LensValidateResponse;
+}
+/** IPC Client configuration */
+interface IPCClientConfig {
+    /** Base path for IPC files */
+    basePath?: string;
+    /** Timeout for responses (ms) */
+    timeout?: number;
+    /** Polling interval for responses (ms) */
+    pollInterval?: number;
+}
+
+/**
+ * React hook for IPC Client
+ */
+
+interface UseIPCClientReturn {
+    /** Validate lens context */
+    validateLens: (context: LensContext, zone?: Zone) => Promise<LensValidateResponse>;
+    /** Validate with Anchor */
+    validateAnchor: (statement?: string, lensContext?: LensContext, zone?: Zone) => Promise<AnchorValidateResponse>;
+    /** Whether a request is in progress */
+    isLoading: boolean;
+    /** Last error message */
+    error: string | null;
+    /** Clear error */
+    clearError: () => void;
+}
+/**
+ * Hook for using the IPC client in components
+ */
+declare function useIPCClient(): UseIPCClientReturn;
+
+/**
+ * Fork Chain State Service
+ *
+ * Provides integration with Anvil/Tenderly for chain state forking.
+ * Enables transaction simulation without real funds.
+ */
+
+/**
+ * Fork provider type
+ */
+type ForkProvider = 'anvil' | 'tenderly' | 'custom';
+/**
+ * Fork configuration
+ */
+interface ForkConfig {
+    /** Fork provider type */
+    provider: ForkProvider;
+    /** RPC URL to fork from (mainnet, testnet, etc.) */
+    forkUrl: string;
+    /** Block number to fork at (undefined = latest) */
+    forkBlockNumber?: bigint;
+    /** Chain ID for the fork */
+    chainId: number;
+    /** Anvil-specific: port to run on */
+    anvilPort?: number;
+    /** Tenderly-specific: project slug */
+    tenderlyProject?: string;
+    /** Tenderly-specific: API key */
+    tenderlyApiKey?: string;
+    /** Custom fork RPC URL (when provider = 'custom') */
+    customForkRpc?: string;
+}
+/**
+ * Fork state
+ */
+interface ForkState {
+    /** Whether fork is active */
+    active: boolean;
+    /** Fork RPC URL */
+    rpcUrl: string | null;
+    /** Block number fork was created at */
+    blockNumber: bigint | null;
+    /** Chain ID */
+    chainId: number | null;
+    /** Fork creation timestamp */
+    createdAt: number | null;
+    /** Number of snapshots taken */
+    snapshotCount: number;
+    /** Current snapshot ID */
+    currentSnapshotId: string | null;
+}
+/**
+ * Fork snapshot for state restoration
+ */
+interface ForkSnapshot {
+    id: string;
+    blockNumber: bigint;
+    timestamp: number;
+    description?: string;
+}
+/**
+ * Fork service interface
+ */
+interface ForkService {
+    /** Create a new fork */
+    createFork(config: ForkConfig): Promise<ForkState>;
+    /** Get current fork state */
+    getState(): ForkState;
+    /** Take a snapshot of current fork state */
+    snapshot(description?: string): Promise<ForkSnapshot>;
+    /** Revert to a snapshot */
+    revert(snapshotId: string): Promise<boolean>;
+    /** Reset fork to initial state */
+    reset(): Promise<void>;
+    /** Destroy the fork */
+    destroy(): Promise<void>;
+    /** Set account balance (for testing) */
+    setBalance(address: Address, balance: bigint): Promise<void>;
+    /** Impersonate an address (for testing) */
+    impersonateAccount(address: Address): Promise<void>;
+    /** Stop impersonating an address */
+    stopImpersonating(address: Address): Promise<void>;
+    /** Mine a block */
+    mineBlock(blocks?: number): Promise<void>;
+    /** Get fork RPC URL */
+    getRpcUrl(): string | null;
+}
+/**
+ * Create an Anvil-based fork service
+ */
+declare function createAnvilForkService(): ForkService;
+/**
+ * Create a Tenderly-based fork service
+ */
+declare function createTenderlyForkService(): ForkService;
+/**
+ * Create a fork service based on provider type
+ */
+declare function createForkService(provider: ForkProvider): ForkService;
+/**
+ * Get the default fork service
+ */
+declare function getForkService(provider?: ForkProvider): ForkService;
+/**
+ * Reset the default fork service
+ */
+declare function resetForkService(): void;
+
+/**
+ * Hook for managing fork chain state
+ *
+ * Provides React integration for fork service.
+ */
+
+/**
+ * Fork state hook return type
+ */
+interface UseForkStateReturn {
+    /** Current fork state */
+    state: ForkState;
+    /** Whether fork operation is in progress */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Create a new fork */
+    createFork: (config: ForkConfig) => Promise<void>;
+    /** Take a snapshot */
+    snapshot: (description?: string) => Promise<ForkSnapshot | null>;
+    /** Revert to a snapshot */
+    revert: (snapshotId: string) => Promise<boolean>;
+    /** Reset fork to initial state */
+    reset: () => Promise<void>;
+    /** Destroy the fork */
+    destroy: () => Promise<void>;
+    /** Set account balance */
+    setBalance: (address: Address, balance: bigint) => Promise<void>;
+    /** Impersonate an account */
+    impersonateAccount: (address: Address) => Promise<void>;
+    /** Stop impersonating an account */
+    stopImpersonating: (address: Address) => Promise<void>;
+    /** Mine blocks */
+    mineBlock: (blocks?: number) => Promise<void>;
+    /** All snapshots taken */
+    snapshots: ForkSnapshot[];
+}
+/**
+ * Hook for managing fork chain state
+ */
+declare function useForkState(defaultProvider?: ForkProvider): UseForkStateReturn;
+
+/**
+ * Transaction Simulation Service
+ *
+ * Executes transactions against fork and captures results.
+ * Provides dry-run functionality without real funds.
+ */
+
+/**
+ * Transaction request for simulation
+ */
+interface SimulationTransactionRequest {
+    /** Transaction sender */
+    from: Address;
+    /** Transaction recipient */
+    to: Address;
+    /** Transaction value in wei */
+    value?: bigint;
+    /** Transaction data */
+    data?: Hex;
+    /** Gas limit (optional, will be estimated if not provided) */
+    gas?: bigint;
+    /** Gas price (optional) */
+    gasPrice?: bigint;
+    /** Max fee per gas (EIP-1559) */
+    maxFeePerGas?: bigint;
+    /** Max priority fee per gas (EIP-1559) */
+    maxPriorityFeePerGas?: bigint;
+    /** Nonce (optional, will be fetched if not provided) */
+    nonce?: number;
+}
+/**
+ * Balance change from simulation
+ */
+interface BalanceChange {
+    /** Address whose balance changed */
+    address: Address;
+    /** Token address (null for ETH) */
+    token: Address | null;
+    /** Token symbol (if known) */
+    symbol?: string;
+    /** Balance before transaction */
+    before: bigint;
+    /** Balance after transaction */
+    after: bigint;
+    /** Change amount (can be negative) */
+    delta: bigint;
+}
+/**
+ * State change from simulation
+ */
+interface StateChange {
+    /** Contract address */
+    address: Address;
+    /** Storage slot */
+    slot: Hex;
+    /** Value before transaction */
+    before: Hex;
+    /** Value after transaction */
+    after: Hex;
+}
+/**
+ * Event log from simulation
+ */
+interface SimulationLog {
+    /** Contract address that emitted the log */
+    address: Address;
+    /** Log topics */
+    topics: Hex[];
+    /** Log data */
+    data: Hex;
+    /** Decoded event name (if ABI available) */
+    eventName?: string;
+    /** Decoded event args (if ABI available) */
+    decodedArgs?: Record<string, unknown>;
+}
+/**
+ * Simulation result
+ */
+interface SimulationResult {
+    /** Whether transaction succeeded */
+    success: boolean;
+    /** Transaction hash (from simulation) */
+    hash?: Hash;
+    /** Gas used */
+    gasUsed: bigint;
+    /** Gas limit */
+    gasLimit: bigint;
+    /** Effective gas price */
+    effectiveGasPrice: bigint;
+    /** Total cost in wei (gasUsed * effectiveGasPrice + value) */
+    totalCost: bigint;
+    /** Return value (if any) */
+    returnValue?: Hex;
+    /** Revert reason (if failed) */
+    revertReason?: string;
+    /** Balance changes */
+    balanceChanges: BalanceChange[];
+    /** State changes */
+    stateChanges: StateChange[];
+    /** Event logs */
+    logs: SimulationLog[];
+    /** Block number simulation was run at */
+    blockNumber: bigint;
+    /** Timestamp of simulation */
+    timestamp: number;
+}
+/**
+ * Simulation service interface
+ */
+interface SimulationService {
+    /** Simulate a transaction */
+    simulate(tx: SimulationTransactionRequest): Promise<SimulationResult>;
+    /** Estimate gas for a transaction */
+    estimateGas(tx: SimulationTransactionRequest): Promise<bigint>;
+    /** Get current gas price */
+    getGasPrice(): Promise<bigint>;
+    /** Decode revert reason from error data */
+    decodeRevertReason(data: Hex): string | null;
+}
+/**
+ * Create a simulation service using a fork service
+ */
+declare function createSimulationService(forkService: ForkService): SimulationService;
+/**
+ * Get the default simulation service
+ */
+declare function getSimulationService(forkService: ForkService): SimulationService;
+/**
+ * Reset the default simulation service
+ */
+declare function resetSimulationService(): void;
+
+/**
+ * Hook for Transaction Simulation
+ *
+ * Provides easy integration for simulating transactions against a fork.
+ * Manages fork state, simulation service, and result caching.
+ */
+
+/**
+ * Transaction request input for the hook
+ */
+interface TransactionInput {
+    /** Transaction recipient */
+    to: Address;
+    /** Transaction data */
+    data?: Hex;
+    /** Transaction value in wei */
+    value?: bigint;
+    /** Gas limit (optional) */
+    gas?: bigint;
+}
+/**
+ * Hook configuration
+ */
+interface UseTransactionSimulationConfig {
+    /** Fork provider (default: 'anvil') */
+    provider?: ForkProvider;
+    /** Fork RPC URL (for custom provider) */
+    forkUrl?: string;
+    /** Chain ID */
+    chainId?: number;
+    /** Anvil port (default: 8545) */
+    anvilPort?: number;
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** Sender address (will be impersonated) */
+    from?: Address;
+}
+/**
+ * Hook return type
+ */
+interface UseTransactionSimulationReturn {
+    /** Latest simulation result */
+    result: SimulationResult | null;
+    /** Whether simulation is running */
+    isSimulating: boolean;
+    /** Whether fork is connected */
+    isConnected: boolean;
+    /** Whether fork is connecting */
+    isConnecting: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Simulate a transaction */
+    simulate: (tx: TransactionInput) => Promise<SimulationResult | null>;
+    /** Connect to fork */
+    connect: (config?: Partial<ForkConfig>) => Promise<void>;
+    /** Disconnect from fork */
+    disconnect: () => Promise<void>;
+    /** Clear the last result */
+    clearResult: () => void;
+    /** Reset the fork state */
+    reset: () => Promise<void>;
+}
+/**
+ * Hook for transaction simulation
+ *
+ * @example
+ * ```tsx
+ * const { result, isSimulating, error, simulate } = useTransactionSimulation({
+ *   from: '0x...',
+ *   autoConnect: true,
+ * })
+ *
+ * const handleSimulate = async () => {
+ *   await simulate({
+ *     to: '0x...',
+ *     data: '0x...',
+ *     value: 0n,
+ *   })
+ * }
+ * ```
+ */
+declare function useTransactionSimulation(config?: UseTransactionSimulationConfig): UseTransactionSimulationReturn;
+/**
+ * Hook for simulation with automatic fork management
+ *
+ * Simplified version that auto-connects and manages fork lifecycle.
+ *
+ * @example
+ * ```tsx
+ * const { result, isSimulating, simulate } = useSimulation('0x...')
+ *
+ * // Simulate a simple transfer
+ * await simulate({
+ *   to: recipientAddress,
+ *   value: parseEther('1'),
+ * })
+ * ```
+ */
+declare function useSimulation(from: Address, options?: Omit<UseTransactionSimulationConfig, 'from' | 'autoConnect'>): Omit<UseTransactionSimulationReturn, 'connect' | 'disconnect'>;
+
+/**
+ * User Lens panel for address impersonation
+ */
+declare function UserLens(): react_jsx_runtime.JSX.Element;
+/**
+ * Badge component showing when lens is active
+ */
+declare function LensActiveBadge(): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Main Dev Toolbar component
+ *
+ * Renders only in development mode (checks process.env.NODE_ENV)
+ */
+declare function DevToolbar(): react_jsx_runtime.JSX.Element | null;
+/**
+ * Floating trigger button to show toolbar when hidden
+ */
+declare function DevToolbarTrigger(): react_jsx_runtime.JSX.Element | null;
+/**
+ * Complete toolbar with trigger
+ */
+declare function DevToolbarWithTrigger(): react_jsx_runtime.JSX.Element;
+
+/** Diagnostic query item */
+interface DiagnosticItem {
+    id: string;
+    label: string;
+    component: string;
+    observedValue: string;
+    onChainValue?: string;
+    indexedValue?: string;
+    dataSource: 'on-chain' | 'indexed' | 'mixed' | 'unknown';
+    zone: Zone;
+    status: 'pending' | 'verified' | 'mismatch' | 'unknown';
+}
+/**
+ * Diagnostic Panel Props
+ */
+interface DiagnosticPanelProps {
+    /** Items to diagnose */
+    items?: DiagnosticItem[];
+    /** Whether to auto-query on mount */
+    autoQuery?: boolean;
+    /** Callback when diagnosis completes */
+    onDiagnosisComplete?: (result: {
+        verified: DiagnosticItem[];
+        issues: LensValidationIssue[];
+    }) => void;
+}
+/**
+ * Diagnostic Panel Component
+ */
+declare function DiagnosticPanel({ items: initialItems, autoQuery, onDiagnosisComplete, }: DiagnosticPanelProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook for managing diagnostic items
+ */
+declare function useDiagnosticItems(): {
+    items: DiagnosticItem[];
+    addItem: (item: Omit<DiagnosticItem, 'id' | 'status'>) => void;
+    removeItem: (id: string) => void;
+    clearItems: () => void;
+    updateItem: (id: string, updates: Partial<DiagnosticItem>) => void;
+};
+
+/**
+ * Simulation Panel Props
+ */
+interface SimulationPanelProps {
+    /** Function to run simulation */
+    onSimulate?: (tx: SimulationTransactionRequest) => Promise<SimulationResult>;
+    /** Latest simulation result */
+    result?: SimulationResult | null;
+    /** Whether simulation is in progress */
+    isSimulating?: boolean;
+    /** Error message if simulation failed */
+    error?: string | null;
+    /** ETH price for USD estimates (optional) */
+    ethPrice?: number;
+    /** Whether to show detailed state changes */
+    showStateChanges?: boolean;
+    /** Whether to show decoded logs (requires ABI) */
+    showDecodedLogs?: boolean;
+}
+/**
+ * Simulation Panel Component
+ */
+declare function SimulationPanel({ onSimulate, result, isSimulating, error, ethPrice, showDecodedLogs, }: SimulationPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * State Comparison Component
+ *
+ * Side-by-side comparison of app state with diff highlighting.
+ * Shows data source tracing (indexed vs on-chain) and discrepancies.
+ */
+/**
+ * Data source type
+ */
+type DataSource = 'on-chain' | 'indexed' | 'cache' | 'local' | 'unknown';
+/**
+ * State value with metadata
+ */
+interface StateValue {
+    /** The actual value */
+    value: unknown;
+    /** Data source */
+    source: DataSource;
+    /** Timestamp when value was fetched */
+    fetchedAt?: number;
+    /** Key path in state tree */
+    path: string;
+}
+/**
+ * Comparison result for a single value
+ */
+interface ComparisonItem {
+    /** Key/path of the value */
+    path: string;
+    /** Left side value (e.g., "before" or "indexed") */
+    left?: StateValue;
+    /** Right side value (e.g., "after" or "on-chain") */
+    right?: StateValue;
+    /** Whether values differ */
+    isDifferent: boolean;
+    /** Change type */
+    changeType: 'added' | 'removed' | 'modified' | 'unchanged';
+}
+/**
+ * State snapshot for comparison
+ */
+interface StateSnapshot {
+    /** Snapshot ID */
+    id: string;
+    /** Snapshot label */
+    label: string;
+    /** Timestamp */
+    timestamp: number;
+    /** State values */
+    values: Record<string, StateValue>;
+}
+/**
+ * Props for StateComparison component
+ */
+interface StateComparisonProps {
+    /** Left state snapshot (e.g., "before" or "indexed") */
+    leftSnapshot?: StateSnapshot | null;
+    /** Right state snapshot (e.g., "after" or "on-chain") */
+    rightSnapshot?: StateSnapshot | null;
+    /** Left label */
+    leftLabel?: string;
+    /** Right label */
+    rightLabel?: string;
+    /** Filter to show only differences */
+    showOnlyDifferences?: boolean;
+    /** Filter by data source */
+    filterSource?: DataSource | null;
+    /** Callback when export is requested */
+    onExport?: (data: ComparisonItem[]) => void;
+}
+/**
+ * State Comparison Component
+ */
+declare function StateComparison({ leftSnapshot, rightSnapshot, leftLabel, rightLabel, showOnlyDifferences, filterSource, onExport, }: StateComparisonProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook for managing state snapshots
+ */
+declare function useStateSnapshots(): {
+    snapshots: StateSnapshot[];
+    leftSnapshot: StateSnapshot | null;
+    rightSnapshot: StateSnapshot | null;
+    leftId: string | null;
+    rightId: string | null;
+    setLeftId: react.Dispatch<react.SetStateAction<string | null>>;
+    setRightId: react.Dispatch<react.SetStateAction<string | null>>;
+    captureSnapshot: (label: string, values: Record<string, StateValue>) => StateSnapshot;
+    deleteSnapshot: (id: string) => void;
+    clearSnapshots: () => void;
+};
+
+/**
+ * IPC Client for Toolbar <-> Anchor/Lens Communication
+ *
+ * Provides a transport-agnostic interface for communicating with
+ * Anchor and Lens CLIs. In development mode, uses localStorage for
+ * request/response exchange. In production, would use file-based IPC.
+ */
+
+/** IPC Transport interface */
+interface IPCTransport {
+    /** Write a request */
+    writeRequest(request: IPCRequest): Promise<void>;
+    /** Read a response (returns null if not found) */
+    readResponse(requestId: string, cliType: string): Promise<IPCResponse | null>;
+    /** Cleanup request/response files */
+    cleanup(requestId: string): Promise<void>;
+}
+/**
+ * LocalStorage-based transport for development/browser
+ * Stores requests in localStorage, responses come from external source
+ */
+declare class LocalStorageTransport implements IPCTransport {
+    private prefix;
+    constructor(prefix?: string);
+    writeRequest(request: IPCRequest): Promise<void>;
+    readResponse(requestId: string, cliType: string): Promise<IPCResponse | null>;
+    cleanup(requestId: string): Promise<void>;
+}
+/**
+ * Mock transport for testing
+ * Immediately resolves with mock responses
+ */
+declare class MockTransport implements IPCTransport {
+    private mockResponses;
+    setMockResponse(requestId: string, cliType: string, response: IPCResponse): void;
+    writeRequest(_request: IPCRequest): Promise<void>;
+    readResponse(requestId: string, cliType: string): Promise<IPCResponse | null>;
+    cleanup(_requestId: string): Promise<void>;
+}
+/**
+ * IPC Client for communicating with Anchor/Lens CLIs
+ */
+declare class IPCClient {
+    private config;
+    private transport;
+    constructor(transport?: IPCTransport, config?: IPCClientConfig);
+    /**
+     * Send a request and wait for response
+     */
+    send<T, R>(type: IPCRequestType, payload: T, cliType?: string): Promise<R>;
+    /**
+     * Poll for response until timeout
+     */
+    private waitForResponse;
+    /**
+     * Validate lens context via Anchor CLI
+     */
+    validateLensContext(context: LensContext, zone?: Zone): Promise<LensValidateResponse>;
+    /**
+     * Run full Anchor validation with optional lens context
+     */
+    validateAnchor(statement?: string, lensContext?: LensContext, zone?: Zone): Promise<AnchorValidateResponse>;
+    /**
+     * Get the current transport
+     */
+    getTransport(): IPCTransport;
+    /**
+     * Set a new transport
+     */
+    setTransport(transport: IPCTransport): void;
+}
+/**
+ * Get the default IPC client instance
+ */
+declare function getIPCClient(): IPCClient;
+/**
+ * Reset the default IPC client (useful for testing)
+ */
+declare function resetIPCClient(): void;
+
+export { type AnchorRequest, type AnchorResponse, type AnchorValidatePayload, type AnchorValidateResponse, type BalanceChange, type ComparisonItem, type ComparisonState, type DataSource, DevToolbar, type DevToolbarActions, type DevToolbarConfig, DevToolbarProvider, type DevToolbarProviderProps, type DevToolbarState, DevToolbarTrigger, DevToolbarWithTrigger, DiagnosticPanel, type DiagnosticPanelProps, type DiagnosticsState, type ForkConfig, type ForkProvider, type ForkService, type ForkSnapshot, type ForkState, IPCClient, type IPCClientConfig, type IPCRequest, type IPCRequestType, type IPCResponse, type IPCResponseStatus, type IPCTransport, LensActiveBadge, type LensAwareAccount, type LensContext, type LensIssueSeverity, type LensIssueType, type LensValidatePayload, type LensValidateResponse, type LensValidationIssue, type LensValidationResult, LocalStorageTransport, MockTransport, type PhysicsViolation, type SavedAddress, type SimulationLog, SimulationPanel, type SimulationPanelProps, type SimulationResult, type SimulationScenario, type SimulationService, type SimulationState, type SimulationTransactionRequest, type StateChange, StateComparison, type StateComparisonProps, type StateSnapshot, type StateValue, type TasteSignal, type ToolbarTab, type TransactionInput, type UseForkStateReturn, type UseIPCClientReturn, type UseTransactionSimulationConfig, type UseTransactionSimulationReturn, UserLens, type UserLensState, type Zone, createAnvilForkService, createForkService, createSimulationService, createTenderlyForkService, getForkService, getIPCClient, getSimulationService, resetForkService, resetIPCClient, resetSimulationService, useDevToolbar, useDevToolbarConfig, useDevToolbarSelector, useDiagnosticItems, useForkState, useIPCClient, useImpersonatedAddress, useIsImpersonating, useLensAwareAccount, useSavedAddresses, useSimulation, useStateSnapshots, useTransactionSimulation };