feat(ev-dev): part 5 – add interactive TUI dashboard

[randygrok]

Description

Adds an interactive terminal UI dashboard to ev-dev with the --tui flag. The TUI displays real-time blocks, logs, and accounts panels using ratatui, with a custom tracing layer that captures log events in real-time. Plain log output remains the default behavior.

Type of Change

• New feature (non-breaking change which adds functionality)

Testing

• TUI renders blocks, logs, and accounts panels
• Keyboard navigation works (Tab, arrows, q to quit)
• Terminal properly restored on exit or panic
• Plain log output mode (--tui off) unchanged

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 450ddb20-e989-4f68-b919-f1b76720846b

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch feat/ev-dev-part5-tui

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[claude]

Claude finished @randygrok's task —— View job

---

PR Review: Interactive TUI Dashboard for ev-dev

I've completed a comprehensive review of the TUI implementation. Here's my analysis:

Todo List:

• Analyze main TUI application logic (app.rs)
• Review terminal UI rendering implementation (ui.rs)
• Check custom tracing layer implementation (tracing_layer.rs)
• Examine event handling system (events.rs)
• Review main.rs integration changes
• Analyze dependencies and version compatibility
• Check for async/threading issues
• Assess terminal cleanup and error handling
• Evaluate performance implications
• Check security considerations
• Assess test coverage
• Provide comprehensive review feedback

---

Code Quality Assessment: ✅ High Quality

The TUI implementation demonstrates excellent Rust practices with clean separation of concerns, proper async/await usage, and well-structured modules.

Strengths:

• Clear module organization (app, events, ui, tracing_layer)
• Consistent error handling with eyre::Result
• Well-defined data structures with appropriate visibility (pub(crate))
• Proper async task spawning with tokio::spawn

Potential Issues and Recommendations

🟡 Minor Issues

1. Missing Error Context in RPC Operations

• Location: app.rs:246 - ProviderBuilder::new().connect_http(rpc_url.parse().expect("valid RPC URL"))
• Issue: Hard panic on invalid RPC URL instead of graceful error handling
• Recommendation: Replace expect() with proper error handling and return early from async task

2. Silent Channel Send Failures

• Location: tracing_layer.rs:81 - let _ = self.tx.try_send(entry);
• Location: app.rs:349 - if tx.send(balances).await.is_err() { break; }
• Issue: Log events may be silently dropped when TUI buffer is full
• Impact: Users may miss important log information during high activity
• Recommendation: Consider using a bounded channel with overflow handling or logging dropped messages

3. Potential Integer Overflow in Gas Formatting

• Location: ui.rs:42-49 - Gas value formatting
• Issue: No bounds checking on u64 values before f64 conversion
• Recommendation: Add safety checks for extremely large gas values

🟢 Performance Considerations

Efficient Design Choices:

• Appropriate buffer limits (1000 logs, 200 blocks) prevent memory growth
• VecDeque usage for efficient FIFO operations
• Non-blocking channel operations with try_recv()
• 100ms UI refresh rate balances responsiveness with CPU usage

Balance Polling Optimization:

• 2-second polling interval is reasonable for dev environments
• Could be configurable for production use

🔒 Security Assessment: ✅ Secure

No Critical Security Issues Found:

• Private key clipboard operations are properly scoped
• RPC URLs are not logged or exposed insecurely
• Terminal escape sequences are handled by ratatui library
• No sensitive data persistence beyond memory

Good Security Practices:

• Clipboard operations include user confirmation with truncated addresses
• Private keys only copied on explicit user action (k key)
• Temporary file cleanup handled by tempfile crate

🧪 Test Coverage: ⚠️ Needs Attention

Current State: No tests found for TUI functionality

Recommendations:

1. Unit Tests: Add tests for core functions like format_ether(), format_gas(), parse_block_from_fields()
2. Integration Tests: Test app state transitions, event handling
3. Mock Testing: Test RPC error scenarios, channel overflow conditions

🔧 Technical Debt and Maintenance

1. Dependency Versions

• ratatui = "0.30" and crossterm = "0.29" are current stable versions ✅
• arboard = "3" for clipboard - appropriate choice ✅

2. Error Recovery

• Terminal panic recovery is properly implemented with custom panic hook
• TerminalGuard ensures cleanup on normal exit

3. Code Duplication

• Some address truncation logic is repeated (truncate_hex function addresses this partially)
• Consider extracting balance polling logic to separate module

Summary

This is a high-quality implementation that adds significant value to the development experience. The code demonstrates:

• ✅ Excellent architecture with proper separation of concerns
• ✅ Robust terminal handling with panic recovery
• ✅ Efficient async operations with appropriate error handling
• ✅ Good security practices for sensitive operations
• ⚠️ Missing test coverage (main improvement area)
• 🟡 Minor error handling improvements needed for RPC operations

Recommendation: Approve with minor fixes. The implementation is production-ready with suggested improvements for error handling and test coverage.

---