feat(ovsm): Real AMM with account reads/writes

- Add Solana builtins: accounts, instruction-data
- Implement get, mem-load, mem-store in IR generator
- AMM now reads from accounts, computes swap, writes back
- 480 bytes, 25 sBPF instructions, 67 CU

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

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

Author: 0xrinegade

crates/ovsm/src/compiler/ir.rs

@@ -163,13 +163,20 @@ pub struct IrGenerator {
 
 impl IrGenerator {
     pub fn new() -> Self {
-        Self {
+        let mut gen = Self {
             next_reg: 0,
             label_counter: 0,
             var_map: HashMap::new(),
             strings: Vec::new(),
             instructions: Vec::new(),
-        }
+        };
+        // Pre-allocate registers for Solana builtins (R1=accounts, R2=instruction-data per ABI)
+        let accounts_reg = IrReg::new(1);
+        let instr_data_reg = IrReg::new(2);
+        gen.var_map.insert("accounts".to_string(), accounts_reg);
+        gen.var_map.insert("instruction-data".to_string(), instr_data_reg);
+        gen.next_reg = 3; // Start allocating from R3
+        gen
     }
 
     /// Generate IR from typed program
@@ -431,6 +438,59 @@ impl IrGenerator {
                     }
                 }
 
+                // Handle (get array index) - array/object access
+                if name == "get" && args.len() == 2 {
+                    let base_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("Get base has no result"))?;
+                    let idx_reg = self.generate_expr(&args[1].value)?
+                        .ok_or_else(|| Error::runtime("Get index has no result"))?;
+                    let dst = self.alloc_reg();
+                    // Calculate offset: base + idx * 8
+                    let offset_reg = self.alloc_reg();
+                    let eight_reg = self.alloc_reg();
+                    self.emit(IrInstruction::ConstI64(eight_reg, 8));
+                    self.emit(IrInstruction::Mul(offset_reg, idx_reg, eight_reg));
+                    let addr_reg = self.alloc_reg();
+                    self.emit(IrInstruction::Add(addr_reg, base_reg, offset_reg));
+                    self.emit(IrInstruction::Load(dst, addr_reg, 0));
+                    return Ok(Some(dst));
+                }
+
+                // Handle (mem-load base offset) - direct memory load
+                if name == "mem-load" && args.len() == 2 {
+                    let base_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("mem-load base has no result"))?;
+                    let offset = match &args[1].value {
+                        Expression::IntLiteral(n) => *n,
+                        _ => {
+                            let off_reg = self.generate_expr(&args[1].value)?
+                                .ok_or_else(|| Error::runtime("mem-load offset has no result"))?;
+                            let dst = self.alloc_reg();
+                            let addr_reg = self.alloc_reg();
+                            self.emit(IrInstruction::Add(addr_reg, base_reg, off_reg));
+                            self.emit(IrInstruction::Load(dst, addr_reg, 0));
+                            return Ok(Some(dst));
+                        }
+                    };
+                    let dst = self.alloc_reg();
+                    self.emit(IrInstruction::Load(dst, base_reg, offset));
+                    return Ok(Some(dst));
+                }
+
+                // Handle (mem-store base offset value) - direct memory store
+                if name == "mem-store" && args.len() == 3 {
+                    let base_reg = self.generate_expr(&args[0].value)?
+                        .ok_or_else(|| Error::runtime("mem-store base has no result"))?;
+                    let offset = match &args[1].value {
+                        Expression::IntLiteral(n) => *n,
+                        _ => return Err(Error::runtime("mem-store offset must be constant")),
+                    };
+                    let value_reg = self.generate_expr(&args[2].value)?
+                        .ok_or_else(|| Error::runtime("mem-store value has no result"))?;
+                    self.emit(IrInstruction::Store(base_reg, value_reg, offset));
+                    return Ok(None); // Store has no result
+                }
+
                 // Generic tool call
                 let mut arg_regs = Vec::new();
                 for arg in args {

crates/ovsm/src/compiler/types.rs

@@ -142,8 +142,13 @@ pub struct TypeChecker {
 
 impl TypeChecker {
     pub fn new() -> Self {
+        let mut env = TypeEnv::new();
+        // Pre-define Solana program builtins
+        env.define("accounts", OvsmType::Array(Box::new(OvsmType::AccountInfo)));
+        env.define("instruction-data", OvsmType::Array(Box::new(OvsmType::I64)));
+
         Self {
-            env: TypeEnv::new(),
+            env,
             warnings: Vec::new(),
         }
     }
@@ -464,4 +469,34 @@ mod tests {
         eprintln!("Result: {:?}", result);
         assert!(result.is_ok(), "Should type-check successfully: {:?}", result);
     }
+
+    #[test]
+    fn test_arithmetic_expression() {
+        use crate::{SExprScanner, SExprParser};
+        use crate::compiler::{Compiler, CompileOptions};
+
+        // Test nested arithmetic like AMM
+        let source = r#"
+(define a 100)
+(define b 200)
+(define c (+ a b))
+c
+"#;
+        let options = CompileOptions {
+            opt_level: 0,  // Disable optimization to see actual IR
+            ..CompileOptions::default()
+        };
+        let compiler = Compiler::new(options);
+        let result = compiler.compile(source);
+
+        eprintln!("Compile result: {:?}", result);
+        assert!(result.is_ok(), "Should compile: {:?}", result);
+
+        let result = result.unwrap();
+        eprintln!("IR instructions: {}", result.ir_instruction_count);
+        eprintln!("sBPF instructions: {}", result.sbpf_instruction_count);
+
+        // Should have more than 3 instructions for the arithmetic
+        assert!(result.ir_instruction_count > 3, "Should have arithmetic IR");
+    }
 }

examples/ovsm_scripts/amm.ovsm

@@ -1,21 +1,33 @@
 ;;; AMM (Automated Market Maker) - Constant Product Formula
-;;; Implements x * y = k invariant for token swaps
+;;; Solana Program - reads from account data
+;;;
+;;; Account layout:
+;;; 0: Pool state account (reserves_x, reserves_y at offsets 0, 8)
+;;; 1: Instruction data (swap_amount at offset 0)
+
+;; 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)
 
-;; Pool state (simulated)
-(define reserves_x 1000000)
-(define reserves_y 1000000)
-(define lp_supply 1000000)
-
-;; Swap calculation (inline)
-(define swap_amount 10000)
+;; Calculate fee: fee = swap_amount * 30 / 10000
 (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))
 
-;; Result
+;; Update pool state
+(mem-store pool_account 0 new_reserves_x)
+(mem-store pool_account 8 (- reserves_y amount_out))
+
+;; Return amount_out
 amount_out

program.so

@@ -1725,10 +1725,8 @@ Return JSON: {{"action": "...", "reason": "...", "mcp_tool": "EXACT_TOOL_NAME",
         // Convert to JSON for analysis
         let result_json = self.value_to_json(result_value)?;
 
-        // Format findings
-        let findings = format!("Tool: {}\nData: {}",
-                               mcp_tool,
-                               serde_json::to_string_pretty(&result_json)?);
+        // Summarize findings instead of dumping raw JSON (which can be huge!)
+        let findings = self.summarize_mcp_result(&mcp_tool, &result_json);
 
         // Store as finding
         {
@@ -3014,6 +3012,84 @@ Generate the ASCII visualization ONLY (no explanations):"#,
         Ok(json)
     }
 
+    /// Summarize MCP result to avoid dumping raw JSON into AI prompts
+    fn summarize_mcp_result(&self, tool_name: &str, result: &serde_json::Value) -> String {
+        let mut summary = format!("Tool: {}\n", tool_name);
+
+        // Handle get_account_transfers specifically
+        if tool_name.contains("get_account_transfers") {
+            if let Some(data) = result.get("data").and_then(|d| d.get("data")).and_then(|d| d.as_array()) {
+                let total_transfers = data.len();
+
+                // Count by direction
+                let inflows: Vec<_> = data.iter().filter(|t| t.get("transferType").and_then(|v| v.as_str()) == Some("IN")).collect();
+                let outflows: Vec<_> = data.iter().filter(|t| t.get("transferType").and_then(|v| v.as_str()) == Some("OUT")).collect();
+
+                // Count by type
+                let sol_transfers: Vec<_> = data.iter().filter(|t| t.get("txType").and_then(|v| v.as_str()) == Some("sol")).collect();
+                let spl_transfers: Vec<_> = data.iter().filter(|t| t.get("txType").and_then(|v| v.as_str()) == Some("spl")).collect();
+                let defi_transfers: Vec<_> = data.iter().filter(|t| t.get("txType").and_then(|v| v.as_str()) == Some("defi")).collect();
+
+                // Get unique counterparties
+                let mut counterparties: std::collections::HashSet<&str> = std::collections::HashSet::new();
+                for t in data {
+                    if let Some(from) = t.get("from").and_then(|v| v.as_str()) {
+                        counterparties.insert(from);
+                    }
+                    if let Some(to) = t.get("to").and_then(|v| v.as_str()) {
+                        counterparties.insert(to);
+                    }
+                }
+
+                // Get token symbols
+                let mut tokens: std::collections::HashSet<&str> = std::collections::HashSet::new();
+                for t in data {
+                    if let Some(symbol) = t.get("tokenSymbol").and_then(|v| v.as_str()) {
+                        tokens.insert(symbol);
+                    }
+                }
+
+                summary.push_str(&format!("Summary:\n"));
+                summary.push_str(&format!("  - Total transfers: {}\n", total_transfers));
+                summary.push_str(&format!("  - Inflows: {}, Outflows: {}\n", inflows.len(), outflows.len()));
+                summary.push_str(&format!("  - SOL transfers: {}, SPL transfers: {}, DeFi: {}\n",
+                    sol_transfers.len(), spl_transfers.len(), defi_transfers.len()));
+                summary.push_str(&format!("  - Unique counterparties: {}\n", counterparties.len()));
+                summary.push_str(&format!("  - Tokens involved: {:?}\n", tokens.iter().take(10).collect::<Vec<_>>()));
+
+                // Sample top 5 transfers
+                summary.push_str("\nSample transfers (top 5):\n");
+                for (i, t) in data.iter().take(5).enumerate() {
+                    let from = t.get("from").and_then(|v| v.as_str()).unwrap_or("?");
+                    let to = t.get("to").and_then(|v| v.as_str()).unwrap_or("?");
+                    let amount = t.get("tokenAmount").and_then(|v| v.as_str()).unwrap_or("0");
+                    let symbol = t.get("tokenSymbol").and_then(|v| v.as_str()).unwrap_or("?");
+                    let tx_type = t.get("transferType").and_then(|v| v.as_str()).unwrap_or("?");
+                    summary.push_str(&format!("  {}. {} {} {} ({} -> {})\n",
+                        i + 1, amount, symbol, tx_type, &from[..8.min(from.len())], &to[..8.min(to.len())]));
+                }
+            } else {
+                summary.push_str("No transfer data in response\n");
+            }
+        }
+        // Handle get_account_stats
+        else if tool_name.contains("get_account_stats") {
+            summary.push_str(&format!("Account stats retrieved: {}\n",
+                serde_json::to_string(result).unwrap_or_default().chars().take(200).collect::<String>()));
+        }
+        // Default: truncate to reasonable size
+        else {
+            let json_str = serde_json::to_string_pretty(result).unwrap_or_default();
+            if json_str.len() > 500 {
+                summary.push_str(&format!("Data (truncated): {}...\n", &json_str[..500]));
+            } else {
+                summary.push_str(&format!("Data: {}\n", json_str));
+            }
+        }
+
+        summary
+    }
+
     /// Generate final investigation report
     async fn generate_final_report(&self) -> Result<String> {
         let state = self.state.lock().await;