use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use crate::app::App;
use crate::app::actions::Action;
use crate::app::state::{Focus, InputMode, NavTarget, View};
use crate::utils::felt_to_u64;
pub fn handle_key(app: &mut App, key: KeyEvent) -> Option<Action> {
if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
app.should_quit = true;
return None;
}
match app.input_mode {
InputMode::Normal => handle_normal_mode(app, key),
InputMode::Search => handle_search_mode(app, key),
}
}
fn handle_normal_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
if app.tx_detail.visual_mode && app.current_view() == View::TxDetail {
return handle_tx_visual_mode(app, key);
}
if app.block_detail.visual_mode && app.current_view() == View::BlockDetail {
return handle_block_visual_mode(app, key);
}
if app.class.visual_mode && app.current_view() == View::ClassInfo {
return handle_class_visual_mode(app, key);
}
if app.address.visual_mode && app.current_view() == View::AddressInfo {
return handle_address_visual_mode(app, key);
}
match key.code {
KeyCode::Char('q') => {
app.go_to_root_or_quit();
None
}
KeyCode::Char('/') => {
app.input_mode = InputMode::Search;
app.focus = Focus::SearchBar;
app.search_input.clear();
app.search_cursor = 0;
app.search_suggestions.clear();
app.search_selected = 0;
None
}
KeyCode::Char('j') | KeyCode::Down => {
app.select_next();
None
}
KeyCode::Char('k') | KeyCode::Up => {
app.select_previous();
None
}
KeyCode::Char('h') | KeyCode::Left => {
app.pop_view_saving_forward();
None
}
KeyCode::Char('o') if key.modifiers.contains(KeyModifiers::CONTROL) => {
app.pop_view_saving_forward();
None
}
KeyCode::Char('l') | KeyCode::Right | KeyCode::Enter => handle_enter(app),
KeyCode::Char('g') => {
app.select_first();
None
}
KeyCode::Char('G') => {
app.select_last();
None
}
KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => handle_cycle(app, 1),
KeyCode::PageUp => handle_cycle(app, 1),
KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
handle_cycle(app, -1)
}
KeyCode::PageDown => handle_cycle(app, -1),
KeyCode::Char('p') if key.modifiers.contains(KeyModifiers::CONTROL) => handle_axis(app, -1),
KeyCode::Char('n') if key.modifiers.contains(KeyModifiers::CONTROL) => handle_axis(app, 1),
KeyCode::Tab => {
if app.current_view() == View::AddressInfo {
app.address.tab = match app.address.tab {
crate::app::AddressTab::Transactions => crate::app::AddressTab::MetaTxs,
crate::app::AddressTab::MetaTxs => crate::app::AddressTab::Calls,
crate::app::AddressTab::Calls => crate::app::AddressTab::Balances,
crate::app::AddressTab::Balances => crate::app::AddressTab::Transfers,
crate::app::AddressTab::Transfers => crate::app::AddressTab::Events,
crate::app::AddressTab::Events => crate::app::AddressTab::ClassHistory,
crate::app::AddressTab::ClassHistory => crate::app::AddressTab::Transactions,
};
app.maybe_fetch_address_transfers();
return maybe_dispatch_meta_txs_on_entry(app);
}
if app.current_view() == View::TxDetail {
let has_privacy = tx_detail_has_privacy(app);
app.tx_detail.active_tab = app.tx_detail.active_tab.next_visible(has_privacy);
}
None
}
KeyCode::BackTab => {
if app.current_view() == View::AddressInfo {
app.address.tab = match app.address.tab {
crate::app::AddressTab::Transactions => crate::app::AddressTab::ClassHistory,
crate::app::AddressTab::MetaTxs => crate::app::AddressTab::Transactions,
crate::app::AddressTab::Calls => crate::app::AddressTab::MetaTxs,
crate::app::AddressTab::Balances => crate::app::AddressTab::Calls,
crate::app::AddressTab::Transfers => crate::app::AddressTab::Balances,
crate::app::AddressTab::Events => crate::app::AddressTab::Transfers,
crate::app::AddressTab::ClassHistory => crate::app::AddressTab::Events,
};
app.maybe_fetch_address_transfers();
return maybe_dispatch_meta_txs_on_entry(app);
}
if app.current_view() == View::TxDetail {
let has_privacy = tx_detail_has_privacy(app);
app.tx_detail.active_tab = app.tx_detail.active_tab.prev_visible(has_privacy);
}
None
}
KeyCode::Char(']') => app.navigate_forward(),
KeyCode::Char('n') => handle_nonce_cycle(app, -1),
KeyCode::Char('N') => handle_nonce_cycle(app, 1),
KeyCode::Char('r') => match app.current_view() {
View::AddressInfo => {
if let Some(addr) = app.address.context {
app.is_loading = true;
Some(Action::FetchAddressInfo { address: addr })
} else {
None
}
}
View::ClassInfo => {
if let Some(ch) = app.class.hash {
app.clear_class_info();
Some(Action::FetchClassInfo { class_hash: ch })
} else {
None
}
}
_ => Some(Action::FetchRecentBlocks { count: 50 }),
},
KeyCode::Char('?') => {
app.show_help = !app.show_help;
None
}
KeyCode::Esc => {
app.pop_view_saving_forward();
None
}
KeyCode::Char('v') if app.current_view() == View::TxDetail => {
if !app.tx_detail.nav_items.is_empty() {
app.tx_detail.visual_mode = true;
app.tx_detail.reset_nav_cursor_for_active_tab();
}
None
}
KeyCode::Char('v') if app.current_view() == View::AddressInfo => {
app.address.build_nav_items();
if !app.address.nav_items.is_empty() {
app.address.visual_mode = true;
}
None
}
KeyCode::Char('v') if app.current_view() == View::ClassInfo => {
if !app.class.nav_items.is_empty() {
app.class.visual_mode = true;
app.class.nav_cursor = 0;
}
None
}
KeyCode::Char('v') if app.current_view() == View::BlockDetail => {
if !app.block_detail.txs.items.is_empty() {
app.block_detail.visual_mode = true;
app.block_detail.nav_cursor = app.block_detail.txs.state.selected().unwrap_or(0);
}
None
}
KeyCode::Char('a') if app.current_view() == View::ClassInfo => {
app.class.show_abi = !app.class.show_abi;
None
}
KeyCode::Char('c') if app.current_view() == View::TxDetail => {
app.tx_detail.active_tab = crate::app::views::tx_detail::TxTab::Calls;
app.tx_detail.show_calldata = !app.tx_detail.show_calldata;
None
}
KeyCode::Char('d') if app.current_view() == View::TxDetail => {
app.tx_detail.active_tab = crate::app::views::tx_detail::TxTab::Calls;
app.tx_detail.show_decoded_calldata = !app.tx_detail.show_decoded_calldata;
None
}
KeyCode::Char('o') if app.current_view() == View::TxDetail => {
if !app.tx_detail.outside_executions.is_empty() {
app.tx_detail.active_tab = crate::app::views::tx_detail::TxTab::Calls;
app.tx_detail.show_outside_execution = !app.tx_detail.show_outside_execution;
app.build_tx_nav_items();
}
None
}
KeyCode::Char('e') if app.current_view() == View::TxDetail => {
app.tx_detail.expand_all = !app.tx_detail.expand_all;
app.build_tx_nav_items();
None
}
_ => None,
}
}
fn handle_tx_visual_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
match key.code {
KeyCode::Char('j') | KeyCode::Down => {
app.tx_nav_step(1);
None
}
KeyCode::Char('k') | KeyCode::Up => {
app.tx_nav_step(-1);
None
}
KeyCode::Tab => {
let has_privacy = tx_detail_has_privacy(app);
app.tx_detail.active_tab = app.tx_detail.active_tab.next_visible(has_privacy);
app.tx_detail.reset_nav_cursor_for_active_tab();
None
}
KeyCode::BackTab => {
let has_privacy = tx_detail_has_privacy(app);
app.tx_detail.active_tab = app.tx_detail.active_tab.prev_visible(has_privacy);
app.tx_detail.reset_nav_cursor_for_active_tab();
None
}
KeyCode::Enter | KeyCode::Char('l') | KeyCode::Right => {
let item = app
.tx_detail
.nav_items
.get(app.tx_detail.nav_cursor)
.cloned();
item.and_then(|i| app.navigate_to(NavTarget::from_nav_item(&i)))
}
KeyCode::Char('c') => {
app.tx_detail.show_calldata = !app.tx_detail.show_calldata;
None
}
KeyCode::Char('d') => {
app.tx_detail.show_decoded_calldata = !app.tx_detail.show_decoded_calldata;
None
}
KeyCode::Char('o') => {
if !app.tx_detail.outside_executions.is_empty() {
app.tx_detail.show_outside_execution = !app.tx_detail.show_outside_execution;
app.build_tx_nav_items();
app.tx_detail.reset_nav_cursor_for_active_tab();
}
None
}
KeyCode::Esc => {
app.tx_detail.visual_mode = false;
None
}
_ => None,
}
}
fn handle_block_visual_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
match key.code {
KeyCode::Char('j') | KeyCode::Down => {
let max = app.block_detail.txs.items.len().saturating_sub(1);
app.block_detail.nav_cursor = (app.block_detail.nav_cursor + 1).min(max);
app.block_detail
.txs
.state
.select(Some(app.block_detail.nav_cursor));
None
}
KeyCode::Char('k') | KeyCode::Up => {
app.block_detail.nav_cursor = app.block_detail.nav_cursor.saturating_sub(1);
app.block_detail
.txs
.state
.select(Some(app.block_detail.nav_cursor));
None
}
KeyCode::Enter | KeyCode::Char('l') | KeyCode::Right => {
let addr = app
.block_detail
.txs
.items
.get(app.block_detail.nav_cursor)
.map(|tx| tx.sender());
addr.and_then(|a| app.navigate_to(NavTarget::Address(a)))
}
KeyCode::Esc => {
app.block_detail.visual_mode = false;
None
}
_ => None,
}
}
fn handle_class_visual_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
match key.code {
KeyCode::Char('j') | KeyCode::Down => {
app.class_nav_step(1);
None
}
KeyCode::Char('k') | KeyCode::Up => {
app.class_nav_step(-1);
None
}
KeyCode::Enter | KeyCode::Char('l') | KeyCode::Right => {
let item = app.class.nav_items.get(app.class.nav_cursor).cloned();
item.and_then(|i| app.navigate_to(NavTarget::from_nav_item(&i)))
}
KeyCode::Esc => {
app.class.visual_mode = false;
None
}
_ => None,
}
}
fn handle_address_visual_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
match key.code {
KeyCode::Char('j') | KeyCode::Down => {
app.address_nav_step(1);
None
}
KeyCode::Char('k') | KeyCode::Up => {
app.address_nav_step(-1);
None
}
KeyCode::Enter | KeyCode::Char('l') | KeyCode::Right => {
let item = app.address.nav_items.get(app.address.nav_cursor).cloned();
item.and_then(|i| app.navigate_to(NavTarget::from_nav_item(&i)))
}
KeyCode::Esc => {
app.address.visual_mode = false;
None
}
_ => None,
}
}
fn handle_search_mode(app: &mut App, key: KeyEvent) -> Option<Action> {
if !app.search_suggestions.is_empty() {
match key.code {
KeyCode::Down => {
app.search_selected =
(app.search_selected + 1).min(app.search_suggestions.len() - 1);
return None;
}
KeyCode::Up => {
app.search_selected = app.search_selected.saturating_sub(1);
return None;
}
_ => {}
}
}
match key.code {
KeyCode::Esc => {
app.input_mode = InputMode::Normal;
app.focus = Focus::BlockList;
app.search_input.clear();
app.search_cursor = 0;
app.search_suggestions.clear();
app.search_selected = 0;
None
}
KeyCode::Enter => {
let query = if !app.search_suggestions.is_empty()
&& app.search_selected < app.search_suggestions.len()
{
format!("{:#x}", app.search_suggestions[app.search_selected].felt)
} else {
app.search_input.clone()
};
app.input_mode = InputMode::Normal;
app.focus = Focus::BlockList;
app.search_suggestions.clear();
app.search_selected = 0;
if query.is_empty() {
None
} else {
Some(Action::ResolveSearch { query })
}
}
KeyCode::Tab => {
if let Some(result) = app.search_suggestions.get(app.search_selected) {
let name = extract_name_from_display(&result.display);
app.search_input = name;
app.search_cursor = app.search_input.len();
app.update_suggestions();
}
None
}
KeyCode::Char(c) => {
search_insert(app, c.encode_utf8(&mut [0; 4]));
None
}
KeyCode::Backspace => {
if let Some(start) = prev_char_start(&app.search_input, app.search_cursor) {
app.search_input.remove(start);
app.search_cursor = start;
}
app.search_selected = 0;
app.update_suggestions();
None
}
KeyCode::Left => {
if let Some(start) = prev_char_start(&app.search_input, app.search_cursor) {
app.search_cursor = start;
}
None
}
KeyCode::Right => {
if let Some(c) = app.search_input[app.search_cursor..].chars().next() {
app.search_cursor += c.len_utf8();
}
None
}
KeyCode::Up | KeyCode::Down => None,
_ => None,
}
}
pub fn handle_paste(app: &mut App, text: &str) {
if app.input_mode != InputMode::Search {
return;
}
let text: String = text.chars().filter(|c| !c.is_control()).collect();
search_insert(app, &text);
}
fn prev_char_start(s: &str, cursor: usize) -> Option<usize> {
s[..cursor].char_indices().next_back().map(|(i, _)| i)
}
fn search_insert(app: &mut App, text: &str) {
app.search_input.insert_str(app.search_cursor, text);
app.search_cursor += text.len();
app.search_selected = 0;
app.update_suggestions();
}
fn extract_name_from_display(display: &str) -> String {
let trimmed = display.trim().trim_start_matches('*').trim();
if let Some(paren_pos) = trimmed.find(" (") {
trimmed[..paren_pos].to_string()
} else {
trimmed.to_string()
}
}
fn maybe_dispatch_meta_txs_on_entry(app: &mut App) -> Option<Action> {
if app.address.tab != crate::app::AddressTab::MetaTxs
|| app.address.meta_txs_dispatched
|| app.address.fetching_meta_txs
|| app.address.not_deployed
{
return None;
}
let addr = app.address.context?;
let from_block = app
.address
.deployment
.as_ref()
.map(|d| d.block_number)
.unwrap_or(0);
app.address.fetching_meta_txs = true;
app.address.meta_txs_dispatched = true;
app.address.meta_tx_from_block = from_block;
let window_size = app.address.meta_tx_last_window;
Some(Action::FetchAddressMetaTxs {
address: addr,
from_block,
continuation_token: None,
window_size,
limit: 50,
})
}
fn handle_cycle(app: &mut App, direction: i64) -> Option<Action> {
match app.current_view() {
View::Blocks => {
const CHUNK: i64 = 10;
let delta = -direction * CHUNK;
app.blocks_scroll_by(delta);
None
}
View::BlockDetail => {
const CHUNK: i64 = 20;
let delta = -direction * CHUNK;
app.block_detail_txs_scroll_by(delta);
None
}
View::TxDetail => {
const CHUNK: u16 = 10;
let s = app.tx_detail.active_scroll_mut();
*s = if direction > 0 {
s.saturating_sub(CHUNK)
} else {
s.saturating_add(CHUNK)
};
None
}
View::AddressInfo => {
const CHUNK: i64 = 20;
let delta = -direction * CHUNK;
app.address_list_scroll_by(delta);
None
}
View::ClassInfo => {
const CHUNK: u16 = 10;
app.class.scroll = if direction > 0 {
app.class.scroll.saturating_sub(CHUNK)
} else {
app.class.scroll.saturating_add(CHUNK)
};
None
}
}
}
fn handle_axis(app: &mut App, dir: i64) -> Option<Action> {
match app.current_view() {
View::BlockDetail => {
let current = app.block_detail.block.as_ref()?.number;
let target = if dir > 0 {
current.checked_sub(1)?
} else {
if current >= app.latest_block_number {
return None;
}
current + 1
};
app.is_loading = true;
app.clear_block_detail();
Some(Action::FetchBlockDetail { number: target })
}
View::TxDetail => {
let current_hash = app.tx_detail.transaction.as_ref()?.hash();
let len = app.block_detail.txs.items.len();
let idx = app
.block_detail
.txs
.items
.iter()
.position(|tx| tx.hash() == current_hash)?;
let new_idx = idx as i64 + dir;
if new_idx >= 0 && (new_idx as usize) < len {
let new_idx = new_idx as usize;
let hash = app.block_detail.txs.items[new_idx].hash();
app.block_detail.txs.state.select(Some(new_idx));
app.is_loading = true;
app.clear_tx_detail();
Some(Action::FetchTransaction { hash })
} else {
let current_block = app.block_detail.block.as_ref()?.number;
let target_block = if dir > 0 {
current_block.checked_sub(1)?
} else {
if current_block >= app.latest_block_number {
return None;
}
current_block + 1
};
let boundary = if dir > 0 {
crate::app::TxBoundary::First
} else {
crate::app::TxBoundary::Last
};
app.pending_tx_boundary = Some(boundary);
app.is_loading = true;
app.clear_tx_detail();
app.clear_block_detail();
Some(Action::FetchBlockDetail {
number: target_block,
})
}
}
_ => None,
}
}
fn handle_nonce_cycle(app: &mut App, direction: i64) -> Option<Action> {
if app.current_view() != View::TxDetail {
return None;
}
let tx = app.tx_detail.transaction.as_ref()?;
let current_nonce = match tx {
crate::data::types::SnTransaction::Invoke(i) => {
i.nonce.map(|n| felt_to_u64(&n)).unwrap_or(0)
}
_ => return None,
};
let target_nonce = (current_nonce as i64 + direction).max(0) as u64;
if let Some(summary) = app
.address
.txs
.items
.iter()
.find(|s| s.nonce == target_nonce)
{
let hash = summary.hash;
app.is_loading = true;
app.clear_tx_detail();
return Some(Action::FetchTransaction { hash });
}
let sender = tx.sender();
app.is_loading = true;
app.clear_tx_detail();
Some(Action::FetchTxByNonce {
sender,
current_nonce,
direction,
})
}
fn handle_enter(app: &mut App) -> Option<Action> {
match app.current_view() {
View::Blocks => {
let number = app.selected_block()?.number;
app.navigate_to(NavTarget::Block(number))
}
View::BlockDetail => {
let hash = app.selected_transaction()?.hash();
app.navigate_to(NavTarget::Transaction(hash))
}
View::AddressInfo => {
match app.address.tab {
crate::app::AddressTab::Transactions => {
if app.address.gap_selected.is_some() {
app.dispatch_address_gap_fill();
return None;
}
let hash = app.address.txs.selected_item()?.hash;
return app.navigate_to(NavTarget::Transaction(hash));
}
crate::app::AddressTab::Calls => {
if app.address.call_gap_selected.is_some() {
app.dispatch_address_call_gap_fill();
return None;
}
let hash = app.address.calls.selected_item()?.tx_hash;
return app.navigate_to(NavTarget::Transaction(hash));
}
crate::app::AddressTab::Events => {
let hash = app.address.events.selected_item()?.raw.transaction_hash;
return app.navigate_to(NavTarget::Transaction(hash));
}
crate::app::AddressTab::Transfers => {
if app.address.transfer_gap_selected.is_some() {
app.dispatch_address_transfer_gap_fill();
return None;
}
let hash = app.address.transfers.selected_item()?.tx_hash;
return app.navigate_to(NavTarget::Transaction(hash));
}
crate::app::AddressTab::MetaTxs => {
let hash = app.address.meta_txs.selected_item()?.hash;
return app.navigate_to(NavTarget::Transaction(hash));
}
crate::app::AddressTab::ClassHistory => {
let felt = app
.address
.class_history
.get(app.address.class_history_scroll)
.and_then(|e| starknet::core::types::Felt::from_hex(&e.class_hash).ok())?;
return app.navigate_to(NavTarget::ClassHash(felt));
}
_ => {}
}
None
}
View::TxDetail => None,
View::ClassInfo => None,
}
}
fn tx_detail_has_privacy(app: &App) -> bool {
let Some(tx) = &app.tx_detail.transaction else {
return false;
};
let oe: Vec<_> = app
.tx_detail
.outside_executions
.iter()
.map(|(_, info)| info.clone())
.collect();
crate::decode::privacy::summarize(
tx,
&app.tx_detail.decoded_calls,
&app.tx_detail.decoded_events,
&oe,
)
.is_some()
}
#[cfg(test)]
mod paste_tests {
use super::*;
use tokio::sync::mpsc;
fn search_app() -> App {
let (tx, _rx) = mpsc::unbounded_channel();
let mut app = App::new(tx);
app.input_mode = InputMode::Search;
app
}
#[test]
fn paste_inserts_whole_text_at_cursor() {
let mut app = search_app();
handle_paste(&mut app, "0x49d3");
handle_key(&mut app, KeyEvent::from(KeyCode::Left));
handle_key(&mut app, KeyEvent::from(KeyCode::Left));
handle_paste(&mut app, "ab");
assert_eq!(app.search_input, "0x49abd3");
assert_eq!(app.search_cursor, 6);
}
#[test]
fn paste_strips_control_characters() {
let mut app = search_app();
handle_paste(&mut app, "0x49d3\r\n");
assert_eq!(app.search_input, "0x49d3");
assert_eq!(app.search_cursor, 6);
}
#[test]
fn paste_in_normal_mode_is_ignored() {
let (tx, _rx) = mpsc::unbounded_channel();
let mut app = App::new(tx);
handle_paste(&mut app, "q");
assert_eq!(app.input_mode, InputMode::Normal);
assert!(app.search_input.is_empty());
assert!(!app.should_quit);
}
#[test]
fn non_ascii_input_keeps_cursor_on_char_boundaries() {
let mut app = search_app();
handle_paste(&mut app, "aé");
handle_key(&mut app, KeyEvent::from(KeyCode::Left));
handle_key(&mut app, KeyEvent::from(KeyCode::Char('ß')));
assert_eq!(app.search_input, "aßé");
handle_key(&mut app, KeyEvent::from(KeyCode::Right));
handle_key(&mut app, KeyEvent::from(KeyCode::Backspace));
assert_eq!((app.search_input.as_str(), app.search_cursor), ("aß", 3));
}
#[test]
fn paste_matches_typing_the_same_chars() {
let mut app = search_app();
handle_key(&mut app, KeyEvent::from(KeyCode::Char('0')));
handle_key(&mut app, KeyEvent::from(KeyCode::Char('x')));
let typed = (app.search_input.clone(), app.search_cursor);
let mut app = search_app();
handle_paste(&mut app, "0x");
assert_eq!((app.search_input, app.search_cursor), typed);
}
}