@ebowwa/quant-rust 0.1.0

package/src/ffi.rs

@@ -0,0 +1,496 @@
+//! FFI (Foreign Function Interface) exports for Bun
+//!
+//! This module provides C ABI compatible functions for calling from TypeScript/Bun.
+
+use std::ffi::CString;
+use std::os::raw::c_char;
+use std::ptr;
+use std::sync::Mutex;
+
+use crate::types::*;
+
+/// Thread-safe error storage
+static LAST_ERROR: Mutex<Option<CString>> = Mutex::new(None);
+
+/// Set the last error message
+fn set_last_error(msg: &str) {
+    if let Ok(mut guard) = LAST_ERROR.lock() {
+        *guard = Some(CString::new(msg).unwrap_or_else(|_| CString::new("Invalid error message").unwrap()));
+    }
+}
+
+/// Get the last error message (returns null if no error)
+#[no_mangle]
+pub extern "C" fn quant_last_error() -> *const c_char {
+    if let Ok(guard) = LAST_ERROR.lock() {
+        if let Some(ref s) = *guard {
+            return s.as_ptr();
+        }
+    }
+    ptr::null()
+}
+
+/// Clear the last error
+#[no_mangle]
+pub extern "C" fn quant_clear_error() {
+    if let Ok(mut guard) = LAST_ERROR.lock() {
+        *guard = None;
+    }
+}
+
+/// Helper to return a JSON string via FFI
+fn return_json<T: serde::Serialize>(result: Result<T, String>) -> *mut c_char {
+    match result {
+        Ok(value) => {
+            match serde_json::to_string(&value) {
+                Ok(json) => CString::new(json).unwrap().into_raw(),
+                Err(e) => {
+                    set_last_error(&format!("JSON serialization error: {}", e));
+                    ptr::null_mut()
+                }
+            }
+        }
+        Err(e) => {
+            set_last_error(&e);
+            ptr::null_mut()
+        }
+    }
+}
+
+/// Helper to return a JSON value directly
+fn return_json_value(value: serde_json::Value) -> *mut c_char {
+    match serde_json::to_string(&value) {
+        Ok(json) => CString::new(json).unwrap().into_raw(),
+        Err(e) => {
+            set_last_error(&format!("JSON serialization error: {}", e));
+            ptr::null_mut()
+        }
+    }
+}
+
+// ============================================================================
+// OHLCV Functions
+// ============================================================================
+
+/// Create an OHLCV struct and return as JSON
+#[no_mangle]
+pub extern "C" fn quant_ohlcv_new(
+    timestamp: i64,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    volume: f64,
+) -> *mut c_char {
+    let ohlcv = OHLCV::new(timestamp, open, high, low, close, volume);
+    return_json(Ok(ohlcv))
+}
+
+/// Calculate typical price for OHLCV data array
+/// Input: pointer to f64 array of [open, high, low, close, volume, open2, high2, ...]
+/// count: number of OHLCV candles
+/// Output: pointer to f64 array of typical prices (caller must free with quant_free_f64_array)
+#[no_mangle]
+pub extern "C" fn quant_ohlcv_typical_prices(
+    data: *const f64,
+    count: usize,
+    out_len: *mut usize,
+) -> *mut f64 {
+    if data.is_null() || out_len.is_null() {
+        set_last_error("Null pointer provided");
+        return ptr::null_mut();
+    }
+
+    let data_slice = unsafe { std::slice::from_raw_parts(data, count * 6) };
+    let mut results = Vec::with_capacity(count);
+
+    for i in 0..count {
+        let base = i * 6;
+        let high = data_slice[base + 1];
+        let low = data_slice[base + 2];
+        let close = data_slice[base + 3];
+        results.push((high + low + close) / 3.0);
+    }
+
+    unsafe { *out_len = results.len(); }
+    results.leak().as_mut_ptr()
+}
+
+// ============================================================================
+// AMM Functions
+// ============================================================================
+
+/// Create an AMM state and return as JSON
+#[no_mangle]
+pub extern "C" fn quant_amm_new(pool_yes: f64, pool_no: f64, fee: f64) -> *mut c_char {
+    let amm = AMMState::new(pool_yes, pool_no, fee);
+    return_json(Ok(amm))
+}
+
+/// Calculate cost to buy shares from AMM
+#[no_mangle]
+pub extern "C" fn quant_amm_calculate_cost(
+    pool_yes: f64,
+    pool_no: f64,
+    buy_yes: bool,
+    shares: f64,
+) -> *mut c_char {
+    let result = if shares <= 0.0 {
+        Err("Shares must be positive".to_string())
+    } else if pool_yes <= 0.0 || pool_no <= 0.0 {
+        Err("Pool reserves must be positive".to_string())
+    } else {
+        let k = pool_yes * pool_no;
+        let cost = if buy_yes {
+            // Cost to buy YES shares: new_pool_no - pool_no where new_pool_no = k / (pool_yes + shares)
+            let new_pool_yes = pool_yes + shares;
+            let new_pool_no = k / new_pool_yes;
+            new_pool_no - pool_no
+        } else {
+            // Cost to buy NO shares
+            let new_pool_no = pool_no + shares;
+            let new_pool_yes = k / new_pool_no;
+            new_pool_yes - pool_yes
+        };
+        Ok(serde_json::json!({"cost": cost, "avg_price": cost / shares}))
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+/// Calculate price impact for a trade
+#[no_mangle]
+pub extern "C" fn quant_amm_price_impact(
+    pool_yes: f64,
+    pool_no: f64,
+    buy_yes: bool,
+    shares: f64,
+) -> *mut c_char {
+    let result = if shares <= 0.0 {
+        Err("Shares must be positive".to_string())
+    } else if pool_yes <= 0.0 || pool_no <= 0.0 {
+        Err("Pool reserves must be positive".to_string())
+    } else {
+        let initial_price = pool_no / (pool_yes + pool_no);
+        let k = pool_yes * pool_no;
+
+        let (new_pool_yes, new_pool_no) = if buy_yes {
+            let new_yes = pool_yes + shares;
+            (new_yes, k / new_yes)
+        } else {
+            let new_no = pool_no + shares;
+            (k / new_no, new_no)
+        };
+
+        let final_price = new_pool_no / (new_pool_yes + new_pool_no);
+        let impact = (final_price - initial_price).abs() / initial_price;
+
+        Ok(serde_json::json!({
+            "initial_price": initial_price,
+            "final_price": final_price,
+            "price_impact": impact,
+            "impact_bps": impact * 10000.0
+        }))
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+// ============================================================================
+// LMSR Functions
+// ============================================================================
+
+/// Calculate LMSR price
+#[no_mangle]
+pub extern "C" fn quant_lmsr_price(yes_shares: f64, no_shares: f64, b: f64) -> *mut c_char {
+    let result = if b <= 0.0 {
+        Err("Liquidity parameter b must be positive".to_string())
+    } else {
+        let state = LMSRState::new(yes_shares, no_shares, b);
+        Ok(serde_json::json!({
+            "yes_price": state.yes_price(),
+            "no_price": state.no_price()
+        }))
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+/// Calculate LMSR cost to buy shares
+#[no_mangle]
+pub extern "C" fn quant_lmsr_cost(
+    yes_shares: f64,
+    no_shares: f64,
+    b: f64,
+    buy_yes: bool,
+    shares: f64,
+) -> *mut c_char {
+    let result = if b <= 0.0 {
+        Err("Liquidity parameter b must be positive".to_string())
+    } else if shares <= 0.0 {
+        Err("Shares must be positive".to_string())
+    } else {
+        // LMSR cost formula: C(q') - C(q) = b * ln(sum(exp(q'_i/b))) - b * ln(sum(exp(q_i/b)))
+        let cost = if buy_yes {
+            let before = b * ((yes_shares / b).exp() + (no_shares / b).exp()).ln();
+            let after = b * (((yes_shares + shares) / b).exp() + (no_shares / b).exp()).ln();
+            after - before
+        } else {
+            let before = b * ((yes_shares / b).exp() + (no_shares / b).exp()).ln();
+            let after = b * ((yes_shares / b).exp() + ((no_shares + shares) / b).exp()).ln();
+            after - before
+        };
+        Ok(serde_json::json!({"cost": cost, "avg_price": cost / shares}))
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+// ============================================================================
+// Kelly Criterion Functions
+// ============================================================================
+
+/// Calculate Kelly criterion for prediction market
+#[no_mangle]
+pub extern "C" fn quant_kelly_criterion(
+    your_probability: f64,
+    market_price: f64,
+    bankroll: f64,
+) -> *mut c_char {
+    let result = if your_probability <= 0.0 || your_probability >= 1.0 {
+        Err("Probability must be between 0 and 1".to_string())
+    } else if market_price <= 0.0 || market_price >= 1.0 {
+        Err("Market price must be between 0 and 1".to_string())
+    } else if bankroll <= 0.0 {
+        Err("Bankroll must be positive".to_string())
+    } else {
+        let edge = your_probability - market_price;
+        let odds = (1.0 - market_price) / market_price;
+
+        // Kelly fraction: (bp - q) / b where b = odds, p = your_prob, q = 1 - your_prob
+        let kelly = (odds * your_probability - (1.0 - your_probability)) / odds;
+        let kelly = kelly.max(0.0); // Never bet negative
+
+        let half_kelly = kelly / 2.0;
+        let quarter_kelly = kelly / 4.0;
+
+        let result = KellyResult {
+            kelly_fraction: kelly,
+            half_kelly,
+            quarter_kelly,
+            full_bet_size: kelly * bankroll,
+            half_bet_size: half_kelly * bankroll,
+            quarter_bet_size: quarter_kelly * bankroll,
+            edge,
+            odds,
+        };
+        Ok(result)
+    };
+    return_json(result)
+}
+
+// ============================================================================
+// Arbitrage Detection
+// ============================================================================
+
+/// Detect arbitrage opportunity (if yes_price + no_price < 1)
+#[no_mangle]
+pub extern "C" fn quant_detect_arbitrage(yes_price: f64, no_price: f64) -> *mut c_char {
+    let result = if yes_price < 0.0 || yes_price > 1.0 || no_price < 0.0 || no_price > 1.0 {
+        Err("Prices must be between 0 and 1".to_string())
+    } else {
+        let total = yes_price + no_price;
+        let has_arb = total < 1.0;
+        let profit_per_share = if has_arb { 1.0 - total } else { 0.0 };
+
+        Ok(serde_json::json!({
+            "has_arbitrage": has_arb,
+            "yes_price": yes_price,
+            "no_price": no_price,
+            "total_price": total,
+            "profit_per_share": profit_per_share,
+            "profit_bps": profit_per_share * 10000.0
+        }))
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+// ============================================================================
+// Odds Conversion
+// ============================================================================
+
+/// Convert between probability, decimal odds, and American odds
+#[no_mangle]
+pub extern "C" fn quant_convert_odds(value: f64, from_type: i32) -> *mut c_char {
+    // from_type: 0 = probability, 1 = decimal odds, 2 = american odds
+    let result: Result<serde_json::Value, String> = match from_type {
+        0 => {
+            // Input is probability
+            if value <= 0.0 || value >= 1.0 {
+                Err("Probability must be between 0 and 1".to_string())
+            } else {
+                let decimal = 1.0 / value;
+                let american = if value >= 0.5 {
+                    -((value / (1.0 - value)) * 100.0).round()
+                } else {
+                    ((1.0 - value) / value * 100.0).round()
+                };
+                Ok(serde_json::json!({
+                    "probability": value,
+                    "decimal_odds": decimal,
+                    "american_odds": american
+                }))
+            }
+        }
+        1 => {
+            // Input is decimal odds
+            if value < 1.0 {
+                Err("Decimal odds must be >= 1".to_string())
+            } else {
+                let probability = 1.0 / value;
+                let american = if probability >= 0.5 {
+                    -((probability / (1.0 - probability)) * 100.0).round()
+                } else {
+                    ((1.0 - probability) / probability * 100.0).round()
+                };
+                Ok(serde_json::json!({
+                    "probability": probability,
+                    "decimal_odds": value,
+                    "american_odds": american
+                }))
+            }
+        }
+        2 => {
+            // Input is American odds
+            if value == 0.0 {
+                Err("American odds cannot be 0".to_string())
+            } else {
+                let probability = if value > 0.0 {
+                    100.0 / (value + 100.0)
+                } else {
+                    (-value) / ((-value) + 100.0)
+                };
+                let decimal = 1.0 / probability;
+                Ok(serde_json::json!({
+                    "probability": probability,
+                    "decimal_odds": decimal,
+                    "american_odds": value
+                }))
+            }
+        }
+        _ => Err("Invalid from_type: must be 0 (probability), 1 (decimal), or 2 (american)".to_string()),
+    };
+    match result {
+        Ok(value) => return_json_value(value),
+        Err(e) => return_json(Err::<serde_json::Value, String>(e))
+    }
+}
+
+// ============================================================================
+// Memory Management
+// ============================================================================
+
+/// Free a string returned from FFI
+#[no_mangle]
+pub extern "C" fn quant_free_string(s: *mut c_char) {
+    if !s.is_null() {
+        unsafe { drop(CString::from_raw(s)); }
+    }
+}
+
+/// Free a f64 array returned from FFI
+#[no_mangle]
+pub extern "C" fn quant_free_f64_array(ptr: *mut f64, len: usize) {
+    if !ptr.is_null() {
+        unsafe { drop(Vec::from_raw_parts(ptr, len, len)); }
+    }
+}
+
+/// Get library version
+#[no_mangle]
+pub extern "C" fn quant_version() -> *mut c_char {
+    CString::new(env!("CARGO_PKG_VERSION")).unwrap().into_raw()
+}
+
+// ============================================================================
+// Simple Statistical Functions
+// ============================================================================
+
+/// Calculate mean of f64 array
+#[no_mangle]
+pub extern "C" fn quant_mean(data: *const f64, len: usize) -> f64 {
+    if data.is_null() || len == 0 {
+        return f64::NAN;
+    }
+    let slice = unsafe { std::slice::from_raw_parts(data, len) };
+    slice.iter().sum::<f64>() / len as f64
+}
+
+/// Calculate standard deviation of f64 array
+#[no_mangle]
+pub extern "C" fn quant_std_dev(data: *const f64, len: usize) -> f64 {
+    if data.is_null() || len == 0 {
+        return f64::NAN;
+    }
+    let slice = unsafe { std::slice::from_raw_parts(data, len) };
+    let mean = slice.iter().sum::<f64>() / len as f64;
+    let variance = slice.iter()
+        .map(|x| (x - mean).powi(2))
+        .sum::<f64>() / len as f64;
+    variance.sqrt()
+}
+
+/// Calculate variance of f64 array
+#[no_mangle]
+pub extern "C" fn quant_variance(data: *const f64, len: usize) -> f64 {
+    if data.is_null() || len == 0 {
+        return f64::NAN;
+    }
+    let slice = unsafe { std::slice::from_raw_parts(data, len) };
+    let mean = slice.iter().sum::<f64>() / len as f64;
+    slice.iter()
+        .map(|x| (x - mean).powi(2))
+        .sum::<f64>() / len as f64
+}
+
+/// Calculate correlation between two f64 arrays
+#[no_mangle]
+pub extern "C" fn quant_correlation(x: *const f64, y: *const f64, len: usize) -> f64 {
+    if x.is_null() || y.is_null() || len == 0 {
+        return f64::NAN;
+    }
+    let x_slice = unsafe { std::slice::from_raw_parts(x, len) };
+    let y_slice = unsafe { std::slice::from_raw_parts(y, len) };
+
+    let mean_x = x_slice.iter().sum::<f64>() / len as f64;
+    let mean_y = y_slice.iter().sum::<f64>() / len as f64;
+
+    let mut cov = 0.0;
+    let mut var_x = 0.0;
+    let mut var_y = 0.0;
+
+    for i in 0..len {
+        let dx = x_slice[i] - mean_x;
+        let dy = y_slice[i] - mean_y;
+        cov += dx * dy;
+        var_x += dx * dx;
+        var_y += dy * dy;
+    }
+
+    if var_x == 0.0 || var_y == 0.0 {
+        return f64::NAN;
+    }
+
+    cov / (var_x.sqrt() * var_y.sqrt())
+}