feat(tui): Add search, copy-to-clipboard, and edge labels

**Quick Win Features:**

**1. Fuzzy Wallet Search (#4 Priority)**
- Press `/` to activate search mode
- Type to fuzzy-search wallet addresses/labels
- Press `n`/`N` to cycle through results
- Press ESC to exit search
- Search results highlighted in yellow
- Auto-centers viewport on selected result
- Shows "Search: query (X/Y results)" status bar
- Search persists until manually cleared

**2. Copy to Clipboard (#6 Priority)**
- Press `y` to copy selected wallet address
- Uses arboard crate (already in dependencies)
- Shows toast notification: "Copied: 5Q544f...e4j1"
- Toast auto-dismisses after 2 seconds
- Toast appears centered at top of graph

**3. Edge Labels (#1 Priority)**
- Shows transfer amount and token on each edge
- Format: "1.5 SOL", "2.5k USDC" (auto-scales)
- Only renders when zoom > 0.8 (prevents clutter)
- EdgeLabel struct stores amount, token, timestamp
- Labels render at edge midpoint

**Implementation Details:**

**Graph Struct Changes:**
- Added `EdgeLabel` struct with amount/token/timestamp
- Changed connections from `(usize, usize, String)` → `(usize, usize, EdgeLabel)`
- Added search state: query, results, result_idx, search_active
- Added toast notification system with timer
- `add_connection()` now accepts amount, token, timestamp params

**Input Handling:**
- New GraphInput variants: StartSearch, SearchChar, SearchBackspace, SearchNext, SearchPrev, Copy
- Search performs case-insensitive substring matching
- Auto-selects and centers first search result
- n/N keys cycle through results with viewport centering

**UI Enhancements:**
- Search bar renders at bottom with yellow border
- Shows result counter: "Search: 5Q (2/5 results)"
- Toast notifications with green background
- Search matches highlighted in yellow (distinct from white selection)
- Edge labels use format_short() for compact display

**Help Text Updates:**
- Added `/` - Start search
- Added `n/N` - Next/previous result
- Added `y` - Copy address to clipboard

**Bug Fixes:**
- Added serde::Serialize to TokenVolume and TransferEvent
- Fixed missing timestamp parameter in build_from_transfers()
- Updated add_transfer() signature to include timestamp

**Testing Workflow:**
```bash
./target/release/osvm wallet-explorer <WALLET>
# Press 2 for Graph tab
# Press / and type wallet substring
# Press n to cycle results
# Press y to copy selected address
# Zoom in to see edge labels with amounts
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: 0xrinegade

Cargo.lock

@@ -77,6 +77,7 @@ proptest = "1.4"
 criterion = "0.5"
 bolero = "0.10"
 tokio-test = "0.4"
+solana_rbpf = "0.8.5"
 
 [[bench]]
 name = "execution_bench"

crates/ovsm/Cargo.toml

@@ -0,0 +1,92 @@
+//! Compile OVSM to sBPF and deploy to localnet
+use ovsm::compiler::{Compiler, CompileOptions, debug_compile};
+use std::process::Command;
+
+fn main() {
+    let source = std::fs::read_to_string("/tmp/hello_test.ovsm")
+        .expect("Failed to read /tmp/hello_test.ovsm");
+
+    println!("=== Compiling OVSM to sBPF ===\n");
+
+    // Full debug output
+    debug_compile(&source);
+
+    // Compile to ELF
+    let options = CompileOptions {
+        opt_level: 0,
+        debug_info: true,
+        ..Default::default()
+    };
+    let compiler = Compiler::new(options);
+
+    match compiler.compile(&source) {
+        Ok(result) => {
+            let elf_path = "/tmp/amm_program.so";
+            std::fs::write(elf_path, &result.elf_bytes).expect("Failed to write ELF");
+            println!("\n✅ Wrote ELF to {}", elf_path);
+            println!("   Size: {} bytes", result.elf_bytes.len());
+
+            // Generate program keypair
+            let program_keypair = "/tmp/amm_program_keypair.json";
+            let keygen = Command::new("solana-keygen")
+                .args(["new", "--no-bip39-passphrase", "--outfile", program_keypair, "--force"])
+                .output()
+                .expect("Failed to generate keypair");
+
+            if !keygen.status.success() {
+                eprintln!("Failed to generate program keypair");
+                return;
+            }
+
+            // Get program ID
+            let pubkey_output = Command::new("solana-keygen")
+                .args(["pubkey", program_keypair])
+                .output()
+                .expect("Failed to get pubkey");
+            let program_id = String::from_utf8_lossy(&pubkey_output.stdout).trim().to_string();
+            println!("   Program ID: {}", program_id);
+
+            println!("\n=== Deploying to localnet ===\n");
+
+            // Deploy
+            let deploy = Command::new("solana")
+                .args([
+                    "program", "deploy",
+                    "--keypair", "/tmp/test-deploy-keypair.json",
+                    "--program-id", program_keypair,
+                    "--url", "http://localhost:8899",
+                    elf_path,
+                ])
+                .output()
+                .expect("Failed to deploy");
+
+            println!("Deploy stdout: {}", String::from_utf8_lossy(&deploy.stdout));
+            println!("Deploy stderr: {}", String::from_utf8_lossy(&deploy.stderr));
+
+            if deploy.status.success() {
+                println!("\n🎉 Program deployed successfully!");
+                println!("   Program ID: {}", program_id);
+
+                // Verify deployment
+                let account = Command::new("solana")
+                    .args([
+                        "program", "show",
+                        "--url", "http://localhost:8899",
+                        &program_id,
+                    ])
+                    .output();
+
+                if let Ok(output) = account {
+                    println!("\n=== Program Info ===");
+                    println!("{}", String::from_utf8_lossy(&output.stdout));
+                }
+            } else {
+                println!("\n❌ Deployment failed");
+                println!("   This is expected - our minimal ELF may not pass full BPF loader verification");
+            }
+        }
+        Err(e) => {
+            eprintln!("❌ Compilation failed: {:?}", e);
+        }
+    }
+}

crates/ovsm/examples/compile_and_deploy.rs

@@ -0,0 +1,35 @@
+use ovsm::compiler::debug_compile;
+
+fn main() {
+    let amm = r#"
+;; AMM Constant Product Swap
+;; Load pool reserves from account 0
+(define pool_account (get accounts 0))
+(define reserves_x (mem-load pool_account 0))
+(define reserves_y (mem-load pool_account 8))
+
+;; Load swap amount from instruction data
+(define swap_amount (mem-load instruction-data 0))
+
+;; Constants
+(define FEE_BPS 30)
+(define BPS_DENOMINATOR 10000)
+
+;; Calculate fee
+(define fee (/ (* swap_amount FEE_BPS) BPS_DENOMINATOR))
+(define amount_in_after_fee (- swap_amount fee))
+
+;; Constant product formula: dy = y * dx / (x + dx)
+(define new_reserves_x (+ reserves_x amount_in_after_fee))
+(define amount_out (/ (* reserves_y amount_in_after_fee) new_reserves_x))
+
+;; Update pool state
+(mem-store pool_account 0 new_reserves_x)
+(mem-store pool_account 8 (- reserves_y amount_out))
+
+;; Return output amount
+amount_out
+"#;
+
+    debug_compile(amm);
+}

crates/ovsm/examples/debug_amm.rs

@@ -0,0 +1,38 @@
+// Debug ELF parsing to find exact failure point
+use solana_rbpf::elf_parser::{consts::*, types::*, Elf64Parser};
+
+fn main() {
+    let elf_path = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| "/tmp/hello_final.so".to_string());
+
+    println!("📂 Loading ELF: {}", elf_path);
+    let elf_bytes = std::fs::read(&elf_path).expect("Failed to read ELF");
+    println!("   Size: {} bytes\n", elf_bytes.len());
+
+    println!("🔍 Parsing ELF...");
+
+    match Elf64Parser::parse(&elf_bytes) {
+        Ok(parser) => {
+            println!("✅ ELF parsed successfully!\n");
+
+            // Check dynamic table
+            println!("📊 Dynamic Table:");
+            if let Some(dynsym) = parser.dynamic_symbol_table() {
+                println!("   Dynamic symbols: {} entries", dynsym.len());
+            } else {
+                println!("   No dynamic symbol table");
+            }
+
+            if let Some(relocs) = parser.dynamic_relocations_table() {
+                println!("   Dynamic relocations: {} entries", relocs.len());
+            } else {
+                println!("   No dynamic relocations");
+            }
+        }
+        Err(e) => {
+            println!("❌ ELF parsing failed!");
+            println!("\n🔍 Error: {:?}", e);
+        }
+    }
+}

crates/ovsm/examples/debug_elf_parse.rs

@@ -0,0 +1,40 @@
+//! Validate ELF with solana_rbpf
+use solana_rbpf::{
+    elf::Executable,
+    program::{BuiltinProgram, SBPFVersion},
+    verifier::RequisiteVerifier,
+};
+
+#[derive(Debug)]
+struct TestContext {
+    remaining: u64,
+}
+
+impl solana_rbpf::vm::ContextObject for TestContext {
+    fn trace(&mut self, _state: [u64; 12]) {}
+    fn consume(&mut self, amount: u64) { self.remaining = self.remaining.saturating_sub(amount); }
+    fn get_remaining(&self) -> u64 { self.remaining }
+}
+
+fn main() {
+    let elf_bytes = std::fs::read("/tmp/amm_program.so").expect("read elf");
+    println!("ELF size: {} bytes", elf_bytes.len());
+
+    let loader = std::sync::Arc::new(BuiltinProgram::<TestContext>::new_mock());
+
+    match Executable::<TestContext>::from_elf(&elf_bytes, loader) {
+        Ok(exe) => {
+            println!("✅ Valid sBPF ELF (loaded)!");
+            println!("   Entry offset: {}", exe.get_entrypoint_instruction_offset());
+
+            // Verify bytecode
+            match exe.verify::<RequisiteVerifier>() {
+                Ok(()) => println!("   Verification: ✅ PASS"),
+                Err(e) => println!("   Verification: ❌ {:?}", e),
+            }
+        }
+        Err(e) => {
+            println!("❌ Invalid ELF: {:?}", e);
+        }
+    }
+}