@wlfi-agent/cli 1.4.17 → 1.4.18

package/crates/vault-cli-admin/src/tui.rs

@@ -4,7 +4,10 @@ use std::path::PathBuf;
 use std::time::Duration;
 
 use anyhow::{anyhow, bail, Context, Result};
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
+use crossterm::event::{
+    self, DisableBracketedPaste, EnableBracketedPaste, Event, KeyCode, KeyEvent, KeyEventKind,
+    KeyModifiers,
+};
 use crossterm::execute;
 use crossterm::terminal::{
     disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
@@ -132,14 +135,15 @@ enum PendingDiscardAction {
     NewNetworkDraft,
     CycleSavedToken(i8),
     CycleSavedNetwork(i8),
+    Cancel,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 enum PendingDeleteAction {
-    DeleteDestinationOverride,
-    DeleteManualApproval,
-    DeleteToken,
-    DeleteNetwork,
+    DeleteDestinationOverride(usize),
+    DeleteManualApproval(usize),
+    DeleteToken(String),
+    DeleteNetwork(String),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -212,6 +216,25 @@ enum Field {
     Execute,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum FieldInteraction {
+    Edit,
+    Select,
+    Action,
+    ReadOnly,
+}
+
+impl FieldInteraction {
+    fn badge(self) -> &'static str {
+        match self {
+            Self::Edit => "[E]",
+            Self::Select => "[S]",
+            Self::Action => "[A]",
+            Self::ReadOnly => "[R]",
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 struct LimitDraft {
     per_tx_limit: String,
@@ -906,6 +929,16 @@ impl AppState {
         self.visible_fields()[self.selected]
     }
 
+    fn select_field(&mut self, target: Field) {
+        if let Some(index) = self
+            .visible_fields()
+            .iter()
+            .position(|field| *field == target)
+        {
+            self.selected = index;
+        }
+    }
+
     fn active_draft_dirty(&self) -> bool {
         match self.view {
             View::Tokens => self.token_dirty,
@@ -983,7 +1016,7 @@ impl AppState {
     }
 
     fn confirm_delete(&mut self, action: PendingDeleteAction, label: &str) -> bool {
-        if self.pending_delete_action == Some(action) {
+        if self.pending_delete_action == Some(action.clone()) {
             self.clear_pending_delete();
             return true;
         }
@@ -1080,6 +1113,10 @@ impl AppState {
         }
     }
 
+    fn request_cancel(&mut self) -> bool {
+        self.confirm_discard(PendingDiscardAction::Cancel)
+    }
+
     fn load_token_draft(&mut self, token_key: Option<&str>) {
         self.token_draft = token_key
             .and_then(|token_key| {
@@ -1159,6 +1196,7 @@ impl AppState {
         self.network_dirty = false;
         self.clear_pending_discard();
         self.clear_pending_delete();
+        self.select_field(Field::ChainConfigKey);
         self.set_success_message("new network draft ready");
     }
 
@@ -1167,10 +1205,9 @@ impl AppState {
             self.delete_destination_override();
             return;
         }
-        if self.confirm_delete(
-            PendingDeleteAction::DeleteDestinationOverride,
-            "the selected destination override",
-        ) {
+        let target =
+            PendingDeleteAction::DeleteDestinationOverride(self.token_draft.selected_override);
+        if self.confirm_delete(target, "the selected destination override") {
             self.delete_destination_override();
         }
     }
@@ -1180,33 +1217,34 @@ impl AppState {
             self.delete_manual_approval();
             return;
         }
-        if self.confirm_delete(
-            PendingDeleteAction::DeleteManualApproval,
-            "the selected manual approval policy",
-        ) {
+        let target =
+            PendingDeleteAction::DeleteManualApproval(self.token_draft.selected_manual_approval);
+        if self.confirm_delete(target, "the selected manual approval policy") {
             self.delete_manual_approval();
         }
     }
 
     fn request_delete_token(&mut self) -> Result<()> {
-        let has_candidate = self.token_draft.source_key.is_some()
-            || !self.token_draft.key.trim().is_empty();
+        let has_candidate =
+            self.token_draft.source_key.is_some() || !self.token_draft.key.trim().is_empty();
         if !has_candidate {
             return self.delete_token_config();
         }
-        if self.confirm_delete(PendingDeleteAction::DeleteToken, "the selected token") {
+        let target = PendingDeleteAction::DeleteToken(self.pending_token_delete_key()?);
+        if self.confirm_delete(target, "the selected token") {
             return self.delete_token_config();
         }
         Ok(())
     }
 
     fn request_delete_network(&mut self) -> Result<()> {
-        let has_candidate = self.network_draft.source_key.is_some()
-            || !self.network_draft.key.trim().is_empty();
+        let has_candidate =
+            self.network_draft.source_key.is_some() || !self.network_draft.key.trim().is_empty();
         if !has_candidate {
             return self.delete_network_config();
         }
-        if self.confirm_delete(PendingDeleteAction::DeleteNetwork, "the selected network") {
+        let target = PendingDeleteAction::DeleteNetwork(self.pending_network_delete_key()?);
+        if self.confirm_delete(target, "the selected network") {
             return self.delete_network_config();
         }
         Ok(())
@@ -1227,6 +1265,7 @@ impl AppState {
                 }
             }
             Field::SelectedDestinationOverride => {
+                self.clear_pending_delete();
                 cycle_index(
                     &mut self.token_draft.selected_override,
                     self.token_draft.destination_overrides.len(),
@@ -1234,6 +1273,7 @@ impl AppState {
                 );
             }
             Field::SelectedManualApproval => {
+                self.clear_pending_delete();
                 cycle_index(
                     &mut self.token_draft.selected_manual_approval,
                     self.token_draft.manual_approvals.len(),
@@ -1335,9 +1375,8 @@ impl AppState {
         );
     }
 
-    fn edit_selected(&mut self, key: KeyEvent) {
-        let selected_field = self.selected_field();
-        let target = match selected_field {
+    fn selected_text_field_mut(&mut self, selected_field: Field) -> Option<&mut String> {
+        match selected_field {
             Field::TokenKey => Some(&mut self.token_draft.key),
             Field::NetworkAddress => self
                 .token_draft
@@ -1427,34 +1466,38 @@ impl AppState {
             Field::ChainConfigName => Some(&mut self.network_draft.name),
             Field::ChainConfigRpcUrl => Some(&mut self.network_draft.rpc_url),
             _ => None,
-        };
-
-        let Some(target) = target else {
-            return;
-        };
+        }
+    }
 
+    fn edit_selected(&mut self, key: KeyEvent) {
+        let selected_field = self.selected_field();
         match key.code {
             KeyCode::Backspace => {
-                target.pop();
-                if field_uses_network_draft(selected_field) {
-                    self.mark_network_dirty();
+                let changed = if let Some(target) = self.selected_text_field_mut(selected_field) {
+                    target.pop();
+                    true
                 } else {
-                    self.mark_token_dirty();
+                    false
+                };
+                if changed {
+                    self.record_selected_text_change(selected_field);
                 }
-                self.clear_message();
             }
             KeyCode::Char(ch)
                 if !key.modifiers.contains(KeyModifiers::CONTROL)
                     && !key.modifiers.contains(KeyModifiers::ALT) =>
             {
                 if is_allowed_input_char(selected_field, ch) {
-                    target.push(ch);
-                    if field_uses_network_draft(selected_field) {
-                        self.mark_network_dirty();
-                    } else {
-                        self.mark_token_dirty();
+                    let changed =
+                        if let Some(target) = self.selected_text_field_mut(selected_field) {
+                            target.push(ch);
+                            true
+                        } else {
+                            false
+                        };
+                    if changed {
+                        self.record_selected_text_change(selected_field);
                     }
-                    self.clear_message();
                 } else {
                     self.set_error_message(format!(
                         "invalid character '{ch}' for the selected field"
@@ -1465,6 +1508,48 @@ impl AppState {
         }
     }
 
+    fn record_selected_text_change(&mut self, selected_field: Field) {
+        if field_uses_network_draft(selected_field) {
+            self.mark_network_dirty();
+        } else {
+            self.mark_token_dirty();
+        }
+        self.clear_message();
+    }
+
+    fn paste_selected(&mut self, pasted: &str) {
+        let selected_field = self.selected_field();
+        let sanitized = pasted
+            .trim()
+            .chars()
+            .filter(|ch| !matches!(ch, '\r' | '\n' | '\t'))
+            .collect::<String>();
+        let sanitized = sanitized.trim();
+        if sanitized.is_empty() {
+            return;
+        }
+
+        if let Some(invalid) = sanitized
+            .chars()
+            .find(|ch| !is_allowed_input_char(selected_field, *ch))
+        {
+            self.set_error_message(format!(
+                "invalid character '{invalid}' for the selected field"
+            ));
+            return;
+        }
+
+        let changed = if let Some(target) = self.selected_text_field_mut(selected_field) {
+            target.push_str(sanitized);
+            true
+        } else {
+            false
+        };
+        if changed {
+            self.record_selected_text_change(selected_field);
+        }
+    }
+
     fn add_destination_override(&mut self) {
         self.token_draft
             .destination_overrides
@@ -1696,6 +1781,28 @@ impl AppState {
         Ok(())
     }
 
+    fn pending_token_delete_key(&self) -> Result<String> {
+        self.token_draft
+            .source_key
+            .clone()
+            .or_else(|| {
+                let trimmed = self.token_draft.key.trim().to_lowercase();
+                (!trimmed.is_empty()).then_some(trimmed)
+            })
+            .context("no saved token is selected")
+    }
+
+    fn pending_network_delete_key(&self) -> Result<String> {
+        self.network_draft
+            .source_key
+            .clone()
+            .or_else(|| {
+                let trimmed = self.network_draft.key.trim().to_lowercase();
+                (!trimmed.is_empty()).then_some(trimmed)
+            })
+            .context("no saved network is selected")
+    }
+
     fn build_params(&self) -> Result<BootstrapParams> {
         build_bootstrap_params_from_shared_config(
             &self.shared_config_draft,
@@ -1808,6 +1915,7 @@ enum LoopAction {
     Continue,
     RefreshTokenMetadata,
     SaveTokenAndApply,
+    SaveNetworkAndApply,
     ApplyAndExit(Box<BootstrapParams>),
     Cancel,
 }
@@ -1819,7 +1927,8 @@ pub(crate) fn run_bootstrap_tui<T>(
 ) -> Result<Option<T>> {
     enable_raw_mode().context("failed to enable raw mode")?;
     let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen).context("failed to enter alternate screen")?;
+    execute!(stdout, EnterAlternateScreen, EnableBracketedPaste)
+        .context("failed to enter alternate screen")?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend).context("failed to initialize terminal backend")?;
 
@@ -1839,7 +1948,7 @@ pub(crate) fn run_bootstrap_tui<T>(
 
 fn cleanup_terminal(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
     disable_raw_mode().context("failed to disable raw mode")?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)
+    execute!(terminal.backend_mut(), DisableBracketedPaste, LeaveAlternateScreen)
         .context("failed to leave alternate screen")?;
     terminal.show_cursor().context("failed to show cursor")?;
     Ok(())
@@ -1893,9 +2002,27 @@ fn run_save_token_and_apply<T, B: Backend>(
         .clone()
         .unwrap_or_else(|| "saved token".to_string());
 
-    let params = app.build_params().map_err(|err| {
-        anyhow!("{success_message} but failed to apply to wallet: {err}")
-    })?;
+    let params = app
+        .build_params()
+        .map_err(|err| anyhow!("{success_message} but failed to apply to wallet: {err}"))?;
+    let output = apply_with_progress(terminal, app, params, on_apply)?;
+    Ok((output, format!("{success_message} and applied to wallet")))
+}
+
+fn run_save_network_and_apply<T, B: Backend>(
+    terminal: &mut Terminal<B>,
+    app: &mut AppState,
+    on_apply: &mut impl FnMut(BootstrapParams, &mut dyn FnMut(&str) -> Result<()>) -> Result<T>,
+) -> Result<(T, String)> {
+    app.save_network_config()?;
+    let success_message = app
+        .message
+        .clone()
+        .unwrap_or_else(|| "saved network".to_string());
+
+    let params = app
+        .build_params()
+        .map_err(|err| anyhow!("{success_message} but failed to apply to wallet: {err}"))?;
     let output = apply_with_progress(terminal, app, params, on_apply)?;
     Ok((output, format!("{success_message} and applied to wallet")))
 }
@@ -1914,51 +2041,70 @@ fn run_event_loop<T, B: Backend>(
             continue;
         }
 
-        let Event::Key(key) = event::read().context("failed to read terminal event")? else {
-            continue;
-        };
-        if key.kind != KeyEventKind::Press {
-            continue;
-        }
-
-        match handle_key_event(&mut app, key)? {
+        match handle_terminal_event(
+            &mut app,
+            event::read().context("failed to read terminal event")?,
+        )? {
             LoopAction::Continue => {}
             LoopAction::RefreshTokenMetadata => {
                 if let Err(err) = refresh_metadata_with_progress(terminal, &mut app) {
                     app.set_error_message(err.to_string());
                 }
             }
-            LoopAction::SaveTokenAndApply => match run_save_token_and_apply(
-                terminal,
-                &mut app,
-                &mut on_apply,
-            ) {
-                Ok((output, success_message)) => {
-                    last_output = Some(output);
-                    app.set_success_message(success_message);
+            LoopAction::SaveTokenAndApply => {
+                match run_save_token_and_apply(terminal, &mut app, &mut on_apply) {
+                    Ok((output, success_message)) => {
+                        last_output = Some(output);
+                        app.set_success_message(success_message);
+                    }
+                    Err(err) => {
+                        app.set_error_message(err.to_string());
+                    }
                 }
-                Err(err) => {
-                    app.set_error_message(err.to_string());
+            }
+            LoopAction::SaveNetworkAndApply => {
+                match run_save_network_and_apply(terminal, &mut app, &mut on_apply) {
+                    Ok((output, success_message)) => {
+                        last_output = Some(output);
+                        app.set_success_message(success_message);
+                    }
+                    Err(err) => {
+                        app.set_error_message(err.to_string());
+                    }
                 }
-            },
-            LoopAction::ApplyAndExit(params) => match apply_with_progress(
-                terminal,
-                &mut app,
-                *params,
-                &mut on_apply,
-            ) {
-                Ok(output) => return Ok(Some(output)),
-                Err(err) => {
-                    app.set_error_message(err.to_string());
+            }
+            LoopAction::ApplyAndExit(params) => {
+                match apply_with_progress(terminal, &mut app, *params, &mut on_apply) {
+                    Ok(output) => return Ok(Some(output)),
+                    Err(err) => {
+                        app.set_error_message(err.to_string());
+                    }
                 }
-            },
+            }
             LoopAction::Cancel => return Ok(last_output),
         }
     }
 }
 
+fn handle_terminal_event(app: &mut AppState, event: Event) -> Result<LoopAction> {
+    match event {
+        Event::Key(key) if key.kind == KeyEventKind::Press => handle_key_event(app, key),
+        Event::Paste(data) => {
+            app.paste_selected(&data);
+            Ok(LoopAction::Continue)
+        }
+        _ => Ok(LoopAction::Continue),
+    }
+}
+
 fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
     if key.code == KeyCode::Char('s') && key.modifiers.contains(KeyModifiers::CONTROL) {
+        if app.view == View::Tokens && app.token_dirty {
+            return Ok(LoopAction::SaveTokenAndApply);
+        }
+        if app.view == View::Networks && app.network_dirty {
+            return Ok(LoopAction::SaveNetworkAndApply);
+        }
         match app.build_params() {
             Ok(params) => return Ok(LoopAction::ApplyAndExit(Box::new(params))),
             Err(err) => {
@@ -1994,12 +2140,41 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
         return Ok(LoopAction::Continue);
     }
 
+    if field_interaction(app.selected_field()) == FieldInteraction::Edit
+        && !key.modifiers.contains(KeyModifiers::CONTROL)
+        && !key.modifiers.contains(KeyModifiers::ALT)
+    {
+        match key.code {
+            KeyCode::Char(_) | KeyCode::Backspace => {
+                app.edit_selected(key);
+                return Ok(LoopAction::Continue);
+            }
+            _ => {}
+        }
+    }
+
     match key.code {
-        KeyCode::Esc => return Ok(LoopAction::Cancel),
+        KeyCode::Esc => {
+            return Ok(if app.request_cancel() {
+                LoopAction::Cancel
+            } else {
+                LoopAction::Continue
+            });
+        }
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
-            return Ok(LoopAction::Cancel);
+            return Ok(if app.request_cancel() {
+                LoopAction::Cancel
+            } else {
+                LoopAction::Continue
+            });
+        }
+        KeyCode::Char('q') if key.modifiers.is_empty() => {
+            return Ok(if app.request_cancel() {
+                LoopAction::Cancel
+            } else {
+                LoopAction::Continue
+            });
         }
-        KeyCode::Char('q') if key.modifiers.is_empty() => return Ok(LoopAction::Cancel),
         KeyCode::Down | KeyCode::Char('j') => {
             app.select_next();
             app.clear_message();
@@ -2210,7 +2385,7 @@ fn draw_ui(frame: &mut ratatui::Frame<'_>, app: &AppState) {
                 Style::default()
             };
             ListItem::new(Line::from(vec![
-                Span::styled(field_label(*field), style),
+                Span::styled(field_display_label(*field), style),
                 Span::styled(": ", style),
                 Span::styled(field_value(app, *field), style),
             ]))
@@ -2258,11 +2433,12 @@ fn status_message_style(app: &AppState) -> Style {
 
 fn build_help_lines(view: View) -> Vec<Line<'static>> {
     let mut lines = vec![
+        Line::from("Legend: [E] edit [S] select/toggle [A] Enter [R] read-only"),
         Line::from("Views: Tab/Shift+Tab or ]/["),
-        Line::from("Fields: ↑/↓ j/k Home End"),
-        Line::from("Toggle/cycle: ←/→ h/l Space"),
-        Line::from("Actions: Enter"),
+        Line::from("Move: ↑/↓ j/k Home End"),
+        Line::from("Use: ←/→ h/l Space Enter"),
         Line::from("Drafts: Ctrl+N new, Ctrl+R reload, Ctrl+S bootstrap"),
+        Line::from("Paste: terminal paste appends into editable fields."),
     ];
     match view {
         View::Tokens => {
@@ -2270,10 +2446,10 @@ fn build_help_lines(view: View) -> Vec<Line<'static>> {
                 "Tokens: Ctrl+O add override, Ctrl+M add manual approval",
             ));
             lines.push(Line::from(
-                "Token name, symbol, and decimals come from RPC metadata refresh.",
+                "RPC fields are [R]; use [A] Fetch Metadata to refresh them.",
             ));
             lines.push(Line::from(
-                "Advanced exposes gas, fee, tx count, and calldata limits.",
+                "Advanced [S] exposes gas, fee, tx count, and calldata limits.",
             ));
         }
         View::Networks => {
@@ -2488,6 +2664,66 @@ fn field_label(field: Field) -> &'static str {
     }
 }
 
+fn field_interaction(field: Field) -> FieldInteraction {
+    match field {
+        Field::SelectedToken
+        | Field::NetworkMembership
+        | Field::EditingNetwork
+        | Field::NetworkIsNative
+        | Field::ShowAdvanced
+        | Field::SelectedDestinationOverride
+        | Field::SelectedManualApproval
+        | Field::SelectedNetwork
+        | Field::ChainConfigUseAsActive => FieldInteraction::Select,
+        Field::TokenKey
+        | Field::NetworkAddress
+        | Field::PerTxLimit
+        | Field::DailyLimit
+        | Field::WeeklyLimit
+        | Field::MaxGasPerChainWei
+        | Field::DailyMaxTxCount
+        | Field::PerTxMaxFeePerGasGwei
+        | Field::PerTxMaxPriorityFeePerGasWei
+        | Field::PerTxMaxCalldataBytes
+        | Field::OverrideRecipientAddress
+        | Field::OverridePerTxLimit
+        | Field::OverrideDailyLimit
+        | Field::OverrideWeeklyLimit
+        | Field::OverrideMaxGasPerChainWei
+        | Field::OverrideDailyMaxTxCount
+        | Field::OverridePerTxMaxFeePerGasGwei
+        | Field::OverridePerTxMaxPriorityFeePerGasWei
+        | Field::OverridePerTxMaxCalldataBytes
+        | Field::ManualApprovalRecipientAddress
+        | Field::ManualApprovalMinAmount
+        | Field::ManualApprovalMaxAmount
+        | Field::ManualApprovalPriority
+        | Field::ChainConfigKey
+        | Field::ChainConfigId
+        | Field::ChainConfigName
+        | Field::ChainConfigRpcUrl => FieldInteraction::Edit,
+        Field::RefreshTokenMetadata
+        | Field::DestinationOverrides
+        | Field::DeleteDestinationOverride
+        | Field::ManualApprovals
+        | Field::DeleteManualApproval
+        | Field::SaveToken
+        | Field::DeleteToken
+        | Field::SaveNetwork
+        | Field::DeleteNetwork
+        | Field::Execute => FieldInteraction::Action,
+        Field::TokenName | Field::TokenSymbol | Field::TokenDecimals => FieldInteraction::ReadOnly,
+    }
+}
+
+fn field_display_label(field: Field) -> String {
+    format!(
+        "{} {}",
+        field_interaction(field).badge(),
+        field_label(field)
+    )
+}
+
 fn field_value(app: &AppState, field: Field) -> String {
     match field {
         Field::SelectedToken => app
@@ -3402,10 +3638,18 @@ fn validate_optional_overlay_limit(
 mod tests {
     use super::{
         apply_with_progress, build_bootstrap_panel_lines, build_token_panel_lines,
-        handle_key_event, resolve_all_token_manual_approval_policies, resolve_all_token_policies,
-        status_message_style, AppState, ChainProfile, Field, KeyCode, KeyEvent, KeyModifiers,
-        LoopAction, MessageLevel, TokenChainProfile, TokenDestinationOverrideProfile,
-        TokenManualApprovalProfile, TokenPolicyProfile, TokenProfile, View, WlfiConfig,
+        handle_key_event, handle_terminal_event, resolve_all_token_manual_approval_policies,
+        resolve_all_token_policies, resolve_gwei_or_wei_or_default,
+        resolve_optional_gwei_or_wei, resolve_optional_policy_value,
+        resolve_optional_policy_value_or_default, resolve_policy_amount_or_default,
+        resolve_required_policy_amount, run_save_network_and_apply, run_save_token_and_apply,
+        status_message_style, validate_destination_override_overlay,
+        validate_optional_overlay_limit, validate_overlay_limit, AppState, ChainProfile, Event,
+        Field, KeyCode, KeyEvent, KeyModifiers, LoopAction, ManualApprovalDraft, MessageLevel,
+        NetworkDraft, PendingDeleteAction, PendingDiscardAction, ResolvedLimitFields,
+        TokenChainProfile, TokenDestinationOverrideProfile, TokenDraft,
+        TokenManualApprovalProfile, TokenNetworkDraft, TokenPolicyProfile, TokenProfile, View,
+        WlfiConfig,
     };
     use crate::shared_config::WalletProfile;
     use ratatui::{backend::TestBackend, style::Color, Terminal};
@@ -3454,28 +3698,28 @@ mod tests {
     fn sample_config() -> WlfiConfig {
         let mut config = empty_config();
         config.chains.insert(
-            "sepolia".to_string(),
+            "eth".to_string(),
             ChainProfile {
-                chain_id: 11155111,
-                name: "sepolia".to_string(),
-                rpc_url: Some("https://rpc.sepolia.example".to_string()),
+                chain_id: 1,
+                name: "eth".to_string(),
+                rpc_url: Some("https://rpc.ethereum.example".to_string()),
                 extra: BTreeMap::new(),
             },
         );
         config.chains.insert(
-            "base".to_string(),
+            "bsc".to_string(),
             ChainProfile {
-                chain_id: 8453,
-                name: "base".to_string(),
-                rpc_url: Some("https://mainnet.base.example".to_string()),
+                chain_id: 56,
+                name: "bsc".to_string(),
+                rpc_url: Some("https://rpc.bsc.example".to_string()),
                 extra: BTreeMap::new(),
             },
         );
         config.tokens.insert(
-            "usdc".to_string(),
+            "usd1".to_string(),
             TokenProfile {
-                name: Some("USD Coin".to_string()),
-                symbol: "USDC".to_string(),
+                name: Some("USD1".to_string()),
+                symbol: "USD1".to_string(),
                 default_policy: Some(sample_policy("10", "100", "500")),
                 destination_overrides: vec![TokenDestinationOverrideProfile {
                     recipient: "0x1000000000000000000000000000000000000001".to_string(),
@@ -3494,9 +3738,9 @@ mod tests {
                 }],
                 chains: BTreeMap::from([
                     (
-                        "sepolia".to_string(),
+                        "eth".to_string(),
                         TokenChainProfile {
-                            chain_id: 11155111,
+                            chain_id: 1,
                             is_native: false,
                             address: Some("0x1000000000000000000000000000000000000000".to_string()),
                             decimals: 6,
@@ -3505,9 +3749,9 @@ mod tests {
                         },
                     ),
                     (
-                        "base".to_string(),
+                        "bsc".to_string(),
                         TokenChainProfile {
-                            chain_id: 8453,
+                            chain_id: 56,
                             is_native: false,
                             address: Some("0x2000000000000000000000000000000000000000".to_string()),
                             decimals: 6,
@@ -3522,6 +3766,240 @@ mod tests {
         config
     }
 
+    #[test]
+    fn view_and_message_level_helpers_cover_navigation_and_labels() {
+        assert_eq!(View::Tokens.title(), "Tokens");
+        assert!(View::Tokens.description().contains("source of truth"));
+        assert_eq!(View::Tokens.next(), View::Networks);
+        assert_eq!(View::Networks.next(), View::Bootstrap);
+        assert_eq!(View::Bootstrap.next(), View::Tokens);
+        assert_eq!(View::Tokens.previous(), View::Bootstrap);
+        assert_eq!(View::Networks.previous(), View::Tokens);
+        assert_eq!(View::Bootstrap.previous(), View::Networks);
+
+        assert_eq!(MessageLevel::Info.style(), ratatui::style::Style::default().fg(Color::Cyan));
+        assert_eq!(
+            MessageLevel::Success.style(),
+            ratatui::style::Style::default().fg(Color::Green)
+        );
+        assert_eq!(MessageLevel::Error.style(), ratatui::style::Style::default().fg(Color::Red));
+
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        assert_eq!(app.active_draft_label(), "token draft");
+        app.token_dirty = true;
+        assert!(app.active_draft_dirty());
+
+        app.view = View::Networks;
+        assert_eq!(app.active_draft_label(), "network draft");
+        app.network_dirty = true;
+        assert!(app.active_draft_dirty());
+
+        app.view = View::Bootstrap;
+        assert_eq!(app.active_draft_label(), "current view");
+        assert!(!app.active_draft_dirty());
+    }
+
+    #[test]
+    fn limit_draft_roundtrip_and_empty_policy_helpers_cover_chain_paths() {
+        let empty = super::LimitDraft::from_policy(None, 6);
+        assert_eq!(empty, super::LimitDraft::empty());
+
+        let draft = super::LimitDraft::from_policy(Some(&sample_policy("12.5", "100", "500.25")), 6);
+        assert_eq!(draft.per_tx_limit, "12.5");
+        assert_eq!(draft.daily_limit, "100");
+        assert_eq!(draft.weekly_limit, "500.25");
+        assert_eq!(draft.max_gas_per_chain_wei, "1000000000000000");
+        assert_eq!(draft.per_tx_max_fee_per_gas_gwei, "25");
+
+        let token_policy = draft.as_token_level_policy(6).expect("token-level policy");
+        assert_eq!(token_policy.per_tx_amount_decimal.as_deref(), Some("12.5"));
+        assert_eq!(token_policy.daily_amount_decimal.as_deref(), Some("100"));
+        assert_eq!(token_policy.weekly_amount_decimal.as_deref(), Some("500.25"));
+        assert_eq!(
+            token_policy.per_tx_max_fee_per_gas_wei.as_deref(),
+            Some("25000000000")
+        );
+        assert!(token_policy.daily_max_tx_count.is_none());
+
+        let chain_policy = draft.as_chain_policy(6).expect("chain policy");
+        assert_eq!(chain_policy.per_tx_limit.as_deref(), Some("12500000"));
+        assert_eq!(chain_policy.daily_limit.as_deref(), Some("100000000"));
+        assert_eq!(chain_policy.weekly_limit.as_deref(), Some("500250000"));
+    }
+
+    #[test]
+    fn field_visibility_and_selection_helpers_cover_view_transitions() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.message = Some("stale".to_string());
+        app.pending_discard_action = Some(PendingDiscardAction::NextView);
+        app.pending_delete_action = Some(PendingDeleteAction::DeleteToken("usd1".to_string()));
+        app.selected = usize::MAX;
+        app.normalize_selection();
+        assert_eq!(app.selected, app.visible_fields().len() - 1);
+
+        app.next_view();
+        assert_eq!(app.view, View::Networks);
+        assert_eq!(app.selected, 0);
+        assert!(app.message.is_none());
+        assert!(app.pending_discard_action.is_none());
+        assert!(app.pending_delete_action.is_none());
+        assert!(app.visible_fields().contains(&Field::DeleteNetwork));
+
+        app.previous_view();
+        assert_eq!(app.view, View::Tokens);
+
+        app.view = View::Bootstrap;
+        assert_eq!(app.visible_fields(), vec![Field::Execute]);
+        app.select_next();
+        assert_eq!(app.selected, 0);
+        app.select_prev();
+        assert_eq!(app.selected, 0);
+        assert!(app.request_reload_current_view());
+        app.request_new_current_draft();
+        assert_eq!(app.view, View::Bootstrap);
+        assert!(app.request_cancel());
+    }
+
+    #[test]
+    fn delete_key_and_pending_selection_helpers_cover_errors_and_normalization() {
+        let mut app = AppState::from_shared_config(&empty_config(), false);
+        assert!(app.pending_token_delete_key().is_err());
+
+        app.view = View::Networks;
+        assert!(app.pending_network_delete_key().is_err());
+
+        app.view = View::Tokens;
+        app.token_draft.key = "  MixedToken  ".to_string();
+        assert_eq!(
+            app.pending_token_delete_key().expect("pending token key"),
+            "mixedtoken"
+        );
+
+        app.view = View::Networks;
+        app.network_draft.key = "  ExampleChain  ".to_string();
+        assert_eq!(
+            app.pending_network_delete_key().expect("pending network key"),
+            "examplechain"
+        );
+    }
+
+    #[test]
+    fn save_and_apply_helpers_return_success_messages() {
+        let mut token_app = AppState::from_shared_config(&sample_config(), false);
+        let backend = TestBackend::new(120, 40);
+        let mut terminal = Terminal::new(backend).expect("terminal");
+        let (token_output, token_message) = run_save_token_and_apply(
+            &mut terminal,
+            &mut token_app,
+            &mut |params, on_status| {
+                on_status("token apply hook").expect("status");
+                Ok(params.token_policies.len())
+            },
+        )
+        .expect("save token and apply");
+        assert_eq!(token_output, 2);
+        assert!(token_message.contains("saved token"));
+
+        let mut network_app = AppState::from_shared_config(&sample_config(), false);
+        network_app.view = View::Networks;
+        let backend = TestBackend::new(120, 40);
+        let mut terminal = Terminal::new(backend).expect("terminal");
+        let (network_output, network_message) = run_save_network_and_apply(
+            &mut terminal,
+            &mut network_app,
+            &mut |params, on_status| {
+                on_status("network apply hook").expect("status");
+                Ok(params.token_policies.len())
+            },
+        )
+        .expect("save network and apply");
+        assert_eq!(network_output, 2);
+        assert!(network_message.contains("saved network"));
+    }
+
+    #[test]
+    fn policy_value_resolution_and_overlay_helpers_cover_remaining_branches() {
+        assert_eq!(
+            resolve_required_policy_amount("limit", Some("1.5"), None, None, 6)
+                .expect("decimal amount"),
+            1_500_000
+        );
+        assert_eq!(
+            resolve_required_policy_amount("limit", None, Some("42"), None, 6).expect("raw amount"),
+            42
+        );
+        assert_eq!(
+            resolve_required_policy_amount("limit", None, None, Some(2.5), 6)
+                .expect("legacy amount"),
+            2_500_000
+        );
+        assert!(resolve_required_policy_amount("limit", None, None, None, 6).is_err());
+
+        assert_eq!(
+            resolve_policy_amount_or_default(Some("3"), None, None, 9, 6).expect("decimal"),
+            3_000_000
+        );
+        assert_eq!(
+            resolve_policy_amount_or_default(None, Some("7"), None, 9, 6).expect("raw"),
+            7
+        );
+        assert_eq!(
+            resolve_policy_amount_or_default(None, None, Some(1.25), 9, 6).expect("legacy"),
+            1_250_000
+        );
+        assert_eq!(
+            resolve_policy_amount_or_default(None, None, None, 9, 6).expect("default"),
+            9
+        );
+
+        assert_eq!(
+            resolve_optional_gwei_or_wei(Some("2"), None).expect("gwei"),
+            2_000_000_000
+        );
+        assert_eq!(
+            resolve_optional_gwei_or_wei(None, Some("5")).expect("wei"),
+            5
+        );
+        assert_eq!(
+            resolve_gwei_or_wei_or_default(None, None, 11).expect("default"),
+            11
+        );
+        assert_eq!(resolve_optional_policy_value(None).expect("none"), 0);
+        assert_eq!(
+            resolve_optional_policy_value_or_default(None, 13).expect("default"),
+            13
+        );
+
+        let defaults = ResolvedLimitFields {
+            per_tx_max_wei: 100,
+            daily_max_wei: 200,
+            weekly_max_wei: 300,
+            max_gas_per_chain_wei: 400,
+            daily_max_tx_count: 5,
+            per_tx_max_fee_per_gas_wei: 6,
+            per_tx_max_priority_fee_per_gas_wei: 7,
+            per_tx_max_calldata_bytes: 8,
+        };
+        let tighter = ResolvedLimitFields {
+            per_tx_max_wei: 90,
+            daily_max_wei: 190,
+            weekly_max_wei: 290,
+            max_gas_per_chain_wei: 300,
+            daily_max_tx_count: 4,
+            per_tx_max_fee_per_gas_wei: 5,
+            per_tx_max_priority_fee_per_gas_wei: 6,
+            per_tx_max_calldata_bytes: 7,
+        };
+        validate_destination_override_overlay("recipient", &defaults, &tighter)
+            .expect("tighter overlay");
+
+        assert!(validate_overlay_limit("recipient", "per-tx max", 100, 101).is_err());
+        assert!(validate_optional_overlay_limit("recipient", "gas max", 0, 1).is_err());
+        assert!(validate_optional_overlay_limit("recipient", "gas max", 10, 0).is_err());
+        assert!(validate_optional_overlay_limit("recipient", "gas max", 10, 11).is_err());
+        validate_optional_overlay_limit("recipient", "gas max", 10, 9).expect("valid optional");
+    }
+
     #[test]
     fn tokens_view_is_default_and_not_numbered() {
         let app = AppState::from_shared_config(&sample_config(), false);
@@ -3537,7 +4015,7 @@ mod tests {
             .map(|line| line.to_string())
             .collect::<Vec<_>>()
             .join("\n");
-        assert!(rendered.contains("USD Coin (usdc)"));
+        assert!(rendered.contains("USD1 (usd1)"));
         assert!(rendered.contains("overrides 1"));
         assert!(rendered.contains("manual approvals 1"));
     }
@@ -3554,7 +4032,7 @@ mod tests {
     #[test]
     fn build_params_skips_empty_destination_override_limits() {
         let mut config = sample_config();
-        if let Some(token) = config.tokens.get_mut("usdc") {
+        if let Some(token) = config.tokens.get_mut("usd1") {
             token.destination_overrides = vec![TokenDestinationOverrideProfile {
                 recipient: "0x1000000000000000000000000000000000000001".to_string(),
                 limits: TokenPolicyProfile::default(),
@@ -3646,6 +4124,35 @@ mod tests {
         assert_eq!(super::field_value(&app, Field::PerTxLimit), "10");
     }
 
+    #[test]
+    fn field_display_labels_show_interaction_badges() {
+        assert_eq!(super::field_display_label(Field::TokenKey), "[E] Token Key");
+        assert_eq!(
+            super::field_display_label(Field::SelectedToken),
+            "[S] Selected Token"
+        );
+        assert_eq!(
+            super::field_display_label(Field::RefreshTokenMetadata),
+            "[A] Fetch Metadata"
+        );
+        assert_eq!(
+            super::field_display_label(Field::TokenName),
+            "[R] Token Name (RPC)"
+        );
+    }
+
+    #[test]
+    fn token_help_lines_include_interaction_legend() {
+        let rendered = super::build_help_lines(View::Tokens)
+            .into_iter()
+            .map(|line| line.to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
+        assert!(rendered.contains("Legend: [E] edit [S] select/toggle [A] Enter [R] read-only"));
+        assert!(rendered.contains("Paste: terminal paste appends into editable fields."));
+        assert!(rendered.contains("RPC fields are [R]; use [A] Fetch Metadata to refresh them."));
+    }
+
     #[test]
     fn save_token_defers_apply_to_event_loop_when_metadata_is_complete() {
         let config = sample_config();
@@ -3668,6 +4175,84 @@ mod tests {
         fs::remove_dir_all(config_root).expect("cleanup temp config root");
     }
 
+    #[test]
+    fn ctrl_s_saves_dirty_token_before_bootstrap() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        app.token_draft.key.push('x');
+        app.mark_token_dirty();
+
+        let action = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL),
+        )
+        .expect("handle ctrl+s");
+
+        assert!(matches!(action, LoopAction::SaveTokenAndApply));
+    }
+
+    #[test]
+    fn ctrl_s_saves_dirty_network_before_bootstrap() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        app.view = View::Networks;
+        app.network_draft.name.push('x');
+        app.mark_network_dirty();
+
+        let action = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL),
+        )
+        .expect("handle ctrl+s");
+
+        assert!(matches!(action, LoopAction::SaveNetworkAndApply));
+    }
+
+    #[test]
+    fn paste_event_appends_trimmed_text_to_editable_fields() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        app.view = View::Networks;
+        app.network_draft.rpc_url.clear();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ChainConfigRpcUrl)
+            .expect("chain config rpc field");
+
+        let action = handle_terminal_event(
+            &mut app,
+            Event::Paste(" https://bsc.drpc.org \n".to_string()),
+        )
+        .expect("handle paste");
+
+        assert!(matches!(action, LoopAction::Continue));
+        assert_eq!(app.network_draft.rpc_url, "https://bsc.drpc.org");
+        assert!(app.network_dirty);
+    }
+
+    #[test]
+    fn paste_event_rejects_invalid_chars_for_selected_field() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        let original_key = app.token_draft.key.clone();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::TokenKey)
+            .expect("token key field");
+
+        let action = handle_terminal_event(&mut app, Event::Paste("bad key".to_string()))
+            .expect("handle invalid paste");
+
+        assert!(matches!(action, LoopAction::Continue));
+        assert_eq!(app.token_draft.key, original_key);
+        assert_eq!(
+            app.message.as_deref(),
+            Some("invalid character ' ' for the selected field")
+        );
+    }
+
     #[test]
     fn refresh_metadata_action_is_deferred_to_event_loop_for_progress_rendering() {
         let config = sample_config();
@@ -3690,13 +4275,14 @@ mod tests {
         let mut app = AppState::from_shared_config(&sample_config(), false);
         let params = app.build_params().expect("params");
 
-        let output = apply_with_progress(&mut terminal, &mut app, params, &mut |params, on_status| {
-            assert_eq!(params.token_policies.len(), 2);
-            on_status("initializing daemon")?;
-            on_status("registering spending policies")?;
-            Ok("ok".to_string())
-        })
-        .expect("apply succeeds");
+        let output =
+            apply_with_progress(&mut terminal, &mut app, params, &mut |params, on_status| {
+                assert_eq!(params.token_policies.len(), 2);
+                on_status("initializing daemon")?;
+                on_status("registering spending policies")?;
+                Ok("ok".to_string())
+            })
+            .expect("apply succeeds");
 
         assert_eq!(output, "ok");
         assert_eq!(
@@ -3774,8 +4360,11 @@ mod tests {
             .position(|field| *field == Field::TokenKey)
             .expect("token key field");
 
-        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
-            .expect("edit token key");
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE),
+        )
+        .expect("edit token key");
         assert!(app.token_dirty);
 
         let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE))
@@ -3803,8 +4392,11 @@ mod tests {
             .position(|field| *field == Field::ChainConfigName)
             .expect("chain config name field");
 
-        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
-            .expect("edit network name");
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE),
+        )
+        .expect("edit network name");
         assert!(app.network_dirty);
         assert!(app.network_draft.name.ends_with('x'));
 
@@ -3837,8 +4429,11 @@ mod tests {
             .iter()
             .position(|field| *field == Field::TokenKey)
             .expect("token key field");
-        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
-            .expect("edit token key");
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE),
+        )
+        .expect("edit token key");
 
         app.selected = app
             .visible_fields()
@@ -3848,7 +4443,7 @@ mod tests {
 
         let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
             .expect("first cycle");
-        assert_eq!(app.token_draft.source_key.as_deref(), Some("usdc"));
+        assert_eq!(app.token_draft.source_key.as_deref(), Some("usd1"));
         assert!(app
             .message
             .as_deref()
@@ -3861,6 +4456,53 @@ mod tests {
         assert!(!app.token_dirty);
     }
 
+    #[test]
+    fn q_requires_confirmation_before_canceling_dirty_token_draft() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.token_draft.key.push('x');
+        app.mark_token_dirty();
+
+        let action = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
+        )
+        .expect("first cancel");
+        assert!(matches!(action, LoopAction::Continue));
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the token draft"));
+
+        let action = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
+        )
+        .expect("second cancel");
+        assert!(matches!(action, LoopAction::Cancel));
+    }
+
+    #[test]
+    fn escape_requires_confirmation_before_canceling_dirty_network_draft() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.view = View::Networks;
+        app.network_draft.name.push('x');
+        app.mark_network_dirty();
+
+        let action = handle_key_event(&mut app, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE))
+            .expect("first cancel");
+        assert!(matches!(action, LoopAction::Continue));
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the network draft"));
+
+        let action = handle_key_event(&mut app, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE))
+            .expect("second cancel");
+        assert!(matches!(action, LoopAction::Cancel));
+    }
+
     #[test]
     fn delete_manual_approval_requires_confirmation() {
         let mut app = AppState::from_shared_config(&sample_config(), false);
@@ -3884,6 +4526,103 @@ mod tests {
         assert!(app.token_draft.manual_approvals.is_empty());
     }
 
+    #[test]
+    fn changing_selected_manual_approval_restarts_delete_confirmation() {
+        let mut config = sample_config();
+        let token = config.tokens.get_mut("usd1").expect("usd1 token");
+        let mut second_policy = token.manual_approval_policies[0].clone();
+        second_policy.priority = 200;
+        second_policy.min_amount_decimal = Some("600".to_string());
+        second_policy.max_amount_decimal = Some("900".to_string());
+        token.manual_approval_policies.push(second_policy);
+
+        let mut app = AppState::from_shared_config(&config, false);
+        let delete_field = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::DeleteManualApproval)
+            .expect("delete manual approval field");
+        let selected_field = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::SelectedManualApproval)
+            .expect("selected manual approval field");
+
+        app.selected = delete_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("first delete");
+        assert_eq!(app.token_draft.manual_approvals.len(), 2);
+
+        app.selected = selected_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
+            .expect("cycle manual approval");
+        assert_eq!(app.token_draft.selected_manual_approval, 1);
+
+        app.selected = delete_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("re-arm delete for second selection");
+        assert_eq!(app.token_draft.manual_approvals.len(), 2);
+        assert!(app
+            .message
+            .as_deref()
+            .expect("renewed confirmation")
+            .contains("repeat the action to confirm deleting the selected manual approval policy"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("delete selected manual approval");
+        assert_eq!(app.token_draft.manual_approvals.len(), 1);
+        assert_eq!(app.token_draft.manual_approvals[0].priority, "120");
+    }
+
+    #[test]
+    fn changing_selected_override_restarts_delete_confirmation() {
+        let mut config = sample_config();
+        let token = config.tokens.get_mut("usd1").expect("usd1 token");
+        let mut second_override = token.destination_overrides[0].clone();
+        second_override.recipient = "0x2000000000000000000000000000000000000002".to_string();
+        token.destination_overrides.push(second_override);
+
+        let mut app = AppState::from_shared_config(&config, false);
+        let delete_field = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::DeleteDestinationOverride)
+            .expect("delete override field");
+        let selected_field = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::SelectedDestinationOverride)
+            .expect("selected override field");
+
+        app.selected = delete_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("first delete");
+        assert_eq!(app.token_draft.destination_overrides.len(), 2);
+
+        app.selected = selected_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
+            .expect("cycle override");
+        assert_eq!(app.token_draft.selected_override, 1);
+
+        app.selected = delete_field;
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("re-arm delete for second selection");
+        assert_eq!(app.token_draft.destination_overrides.len(), 2);
+        assert!(app
+            .message
+            .as_deref()
+            .expect("renewed confirmation")
+            .contains("repeat the action to confirm deleting the selected destination override"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("delete selected override");
+        assert_eq!(app.token_draft.destination_overrides.len(), 1);
+        assert_eq!(
+            app.token_draft.destination_overrides[0].recipient_address,
+            "0x1000000000000000000000000000000000000001"
+        );
+    }
+
     #[test]
     fn delete_token_requires_confirmation() {
         let mut app = AppState::from_shared_config(&sample_config(), false);
@@ -3899,7 +4638,7 @@ mod tests {
 
         let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
             .expect("first delete");
-        assert!(app.shared_config_draft.tokens.contains_key("usdc"));
+        assert!(app.shared_config_draft.tokens.contains_key("usd1"));
         assert!(app
             .message
             .as_deref()
@@ -3908,8 +4647,354 @@ mod tests {
 
         let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
             .expect("second delete");
-        assert!(!app.shared_config_draft.tokens.contains_key("usdc"));
+        assert!(!app.shared_config_draft.tokens.contains_key("usd1"));
 
         fs::remove_dir_all(config_root).expect("cleanup temp config root");
     }
+
+    #[test]
+    fn token_draft_validation_errors_cover_remaining_paths() {
+        let config = sample_config();
+        let mut draft = TokenDraft::blank(&config);
+
+        assert!(draft.selected_network_mut().is_none());
+        assert!(draft
+            .min_network_decimals()
+            .expect_err("empty draft must fail")
+            .to_string()
+            .contains("select at least one network for the token"));
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("missing key must fail")
+            .to_string()
+            .contains("token key is required"));
+
+        draft.key = "usd1".to_string();
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("missing name must fail")
+            .to_string()
+            .contains("fetch token metadata before saving the token"));
+
+        draft.name = "USD1".to_string();
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("missing symbol must fail")
+            .to_string()
+            .contains("fetch token metadata before saving the token"));
+
+        draft.symbol = "USD1".to_string();
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("missing network must fail")
+            .to_string()
+            .contains("select at least one network for the token"));
+
+        draft.limits = super::LimitDraft::from_policy(Some(&sample_policy("10", "100", "500")), 6);
+        draft.networks.push(TokenNetworkDraft {
+            chain_key: "eth".to_string(),
+            chain_id: "1".to_string(),
+            is_native: false,
+            address: "0x1000000000000000000000000000000000000000".to_string(),
+            decimals: "999".to_string(),
+        });
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("large decimals must fail")
+            .to_string()
+            .contains("decimals must be <= 255"));
+
+        draft.networks[0].decimals = "6".to_string();
+        draft.networks[0].is_native = true;
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("native token with address must fail")
+            .to_string()
+            .contains("must not set an address when native"));
+
+        draft.networks[0].is_native = false;
+        draft.networks[0].chain_key = "missing".to_string();
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("unknown chain must fail")
+            .to_string()
+            .contains("unknown saved network 'missing'"));
+
+        draft.networks[0].chain_key = "eth".to_string();
+        draft.destination_overrides.push(super::DestinationOverrideDraft {
+            recipient_address: "not-an-address".to_string(),
+            limits: draft.limits.clone(),
+        });
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("invalid override recipient must fail")
+            .to_string()
+            .contains("destination override recipient"));
+
+        draft.destination_overrides.clear();
+        draft.manual_approvals.push(ManualApprovalDraft {
+            recipient_address: String::new(),
+            min_amount: "1".to_string(),
+            max_amount: "2".to_string(),
+            priority: (u32::MAX as u64 + 1).to_string(),
+        });
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("large priority must fail")
+            .to_string()
+            .contains("manual approval priority must be <= 4294967295"));
+
+        draft.manual_approvals[0].priority = "10".to_string();
+        draft.manual_approvals[0].recipient_address = "not-an-address".to_string();
+        assert!(draft
+            .to_profile(&config)
+            .expect_err("invalid manual approval recipient must fail")
+            .to_string()
+            .contains("manual approval recipient"));
+    }
+
+    #[test]
+    fn token_draft_membership_and_normalize_cover_remaining_branches() {
+        let empty = empty_config();
+        let mut empty_draft = TokenDraft::blank(&empty);
+        assert!(empty_draft
+            .toggle_network_membership(&empty)
+            .expect_err("empty config must fail")
+            .to_string()
+            .contains("save a network before adding it to a token"));
+
+        let config = sample_config();
+        let mut draft = TokenDraft::blank(&config);
+        draft.available_network_index = 1;
+        draft.toggle_network_membership(&config).expect("add network");
+        assert_eq!(draft.networks.len(), 1);
+        assert_eq!(draft.networks[0].chain_key, "eth");
+
+        draft.destination_overrides.push(super::DestinationOverrideDraft::default());
+        draft.manual_approvals.push(ManualApprovalDraft::default());
+        draft.selected_network = usize::MAX;
+        draft.selected_override = usize::MAX;
+        draft.selected_manual_approval = usize::MAX;
+
+        draft.toggle_network_membership(&config).expect("remove network");
+        assert!(draft.networks.is_empty());
+        assert_eq!(draft.selected_network, 0);
+        assert_eq!(draft.selected_override, 0);
+        assert_eq!(draft.selected_manual_approval, 0);
+    }
+
+    #[test]
+    fn network_draft_to_profile_defaults_name_and_optional_rpc() {
+        let draft = NetworkDraft::blank();
+        assert!(draft
+            .to_profile()
+            .expect_err("blank key must fail")
+            .to_string()
+            .contains("network key is required"));
+
+        let mut draft = NetworkDraft::blank();
+        draft.key = " BSC ".to_string();
+        draft.chain_id = "56".to_string();
+        let (source_key, chain_key, profile, use_as_active) =
+            draft.to_profile().expect("network profile");
+        assert!(source_key.is_none());
+        assert_eq!(chain_key, "bsc");
+        assert_eq!(profile.name, "bsc");
+        assert_eq!(profile.rpc_url, None);
+        assert!(!use_as_active);
+    }
+
+    #[test]
+    fn app_state_network_draft_navigation_helpers_cover_remaining_paths() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.view = View::Networks;
+        app.network_draft.name.push('x');
+        app.mark_network_dirty();
+
+        app.request_previous_view();
+        assert_eq!(app.view, View::Networks);
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the network draft"));
+
+        app.request_previous_view();
+        assert_eq!(app.view, View::Tokens);
+
+        app.view = View::Networks;
+        app.load_network_draft(Some("missing"));
+        assert_eq!(app.network_draft.source_key.as_deref(), Some("bsc"));
+
+        app.request_new_current_draft();
+        assert!(app.network_draft.source_key.is_none());
+        assert_eq!(app.message.as_deref(), Some("new network draft ready"));
+        assert_eq!(app.selected_field(), Field::ChainConfigKey);
+
+        app.cycle_saved_network(1);
+        assert_eq!(app.network_draft.source_key.as_deref(), Some("bsc"));
+        app.cycle_saved_network(-1);
+        assert!(app.network_draft.source_key.is_none());
+    }
+
+    #[test]
+    fn step_selected_and_delete_network_cover_remaining_network_paths() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::NetworkMembership)
+            .expect("network membership field");
+        app.step_selected(1);
+        assert_eq!(app.token_draft.available_network_index, 1);
+
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::EditingNetwork)
+            .expect("editing network field");
+        app.step_selected(1);
+        assert_eq!(app.token_draft.selected_network, 1);
+
+        app.token_draft.networks[app.token_draft.selected_network].address =
+            "0x3000000000000000000000000000000000000000".to_string();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::NetworkIsNative)
+            .expect("network native field");
+        app.step_selected(1);
+        let selected_network = app
+            .token_draft
+            .selected_network()
+            .expect("selected network");
+        assert!(selected_network.is_native);
+        assert!(selected_network.address.is_empty());
+
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ShowAdvanced)
+            .expect("show advanced field");
+        app.step_selected(1);
+        assert!(app.show_advanced);
+
+        app.view = View::Networks;
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::SelectedNetwork)
+            .expect("selected network field");
+        app.step_selected(1);
+        assert_eq!(app.network_draft.source_key.as_deref(), Some("eth"));
+
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ChainConfigUseAsActive)
+            .expect("use as active field");
+        app.step_selected(1);
+        assert!(app.network_draft.use_as_active);
+        assert!(app.network_dirty);
+
+        let mut empty_app = AppState::from_shared_config(&empty_config(), false);
+        empty_app.view = View::Networks;
+        assert!(empty_app
+            .request_delete_network()
+            .expect_err("blank network delete must fail")
+            .to_string()
+            .contains("no saved network is selected"));
+
+        let mut deleting_app = AppState::from_shared_config(&config, false);
+        deleting_app.view = View::Networks;
+        deleting_app
+            .request_delete_network()
+            .expect("first delete only arms confirmation");
+        assert_eq!(
+            deleting_app.pending_delete_action,
+            Some(PendingDeleteAction::DeleteNetwork("bsc".to_string()))
+        );
+        assert!(deleting_app
+            .request_delete_network()
+            .expect_err("network still referenced by token must fail")
+            .to_string()
+            .contains("network 'bsc' is still used by token 'usd1'"));
+    }
+
+    #[test]
+    fn switching_to_new_network_focuses_key_field_for_immediate_typing() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        app.view = View::Networks;
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::SelectedNetwork)
+            .expect("selected network field");
+
+        app.cycle_saved_network(-1);
+        assert!(app.network_draft.source_key.is_none());
+        assert_eq!(app.selected_field(), Field::ChainConfigKey);
+
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE),
+        )
+        .expect("type into new network key");
+
+        assert_eq!(app.network_draft.key, "s");
+        assert!(app.network_dirty);
+    }
+
+    #[test]
+    fn editing_network_name_accepts_letters_that_overlap_navigation_shortcuts() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.view = View::Networks;
+        app.request_new_current_draft();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ChainConfigName)
+            .expect("network name field");
+
+        let selected = app.selected;
+        for ch in "sepolia".chars() {
+            let _ = handle_key_event(
+                &mut app,
+                KeyEvent::new(KeyCode::Char(ch), KeyModifiers::NONE),
+            )
+            .expect("type network name");
+        }
+
+        assert_eq!(app.selected, selected);
+        assert_eq!(app.network_draft.name, "sepolia");
+        assert!(app.network_dirty);
+    }
+
+    #[test]
+    fn editing_network_rpc_url_accepts_http_prefix() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.view = View::Networks;
+        app.request_new_current_draft();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ChainConfigRpcUrl)
+            .expect("network rpc url field");
+
+        let selected = app.selected;
+        for ch in "http".chars() {
+            let _ = handle_key_event(
+                &mut app,
+                KeyEvent::new(KeyCode::Char(ch), KeyModifiers::NONE),
+            )
+            .expect("type rpc prefix");
+        }
+
+        assert_eq!(app.selected, selected);
+        assert_eq!(app.network_draft.rpc_url, "http");
+        assert!(app.network_dirty);
+    }
 }