Merge upstream main: fix phantom order sync corrupting position and PnL.

Author: Your Name

Cargo.lock

@@ -27,3 +27,4 @@ rust_decimal = { version = "1", features = ["serde-with-str"] }
 rust_decimal_macros = "1"
 async-trait = "0.1"
 anyhow = "1"
+fs2 = "0.4"

Cargo.toml

@@ -22,6 +22,7 @@ grid-engine = { path = "../../../crates/grid-engine" }
 exchange = { path = "../../../crates/exchange" }
 storage = { path = "../../../crates/storage" }
 chrono = { workspace = true }
+fs2 = { workspace = true }
 
 [features]
 default = ["custom-protocol"]

apps/desktop/src-tauri/Cargo.toml

@@ -1,9 +1,11 @@
 mod runner;
 mod i18n_err;
 
+use std::fs::OpenOptions;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use fs2::FileExt;
 use exchange::{
     fetch_candles, fetch_live_mid, list_live_markets, list_live_mids, Candle, CandleInterval,
     Exchange, HyperliquidExchange, MarketInfo, SimExchange,
@@ -1221,10 +1223,33 @@ async fn save_settings(
     })
 }
 
+/// One process per data directory — prevents two windows fighting the same HL account.
+fn acquire_instance_lock() -> anyhow::Result<std::fs::File> {
+    let dir = resolve_data_dir();
+    std::fs::create_dir_all(&dir)?;
+    let path = dir.join(".hyper-grid.lock");
+    let file = OpenOptions::new()
+        .create(true)
+        .write(true)
+        .open(&path)?;
+    file.try_lock_exclusive()
+        .map_err(|_| anyhow::anyhow!("another hyper-grid instance is already using {}", dir.display()))?;
+    Ok(file)
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tracing_subscriber::fmt().with_env_filter("info").init();
 
+    let _instance_lock = match acquire_instance_lock() {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("{e}");
+            eprintln!("Close the other hyper-grid window or use a separate HYPER_GRID_HOME.");
+            std::process::exit(1);
+        }
+    };
+
     let state = AppState::new().expect("storage");
     let state = Arc::new(Mutex::new(state));
     let state_for_exit = state.clone();

apps/desktop/src-tauri/src/main.rs

@@ -273,6 +273,8 @@ pub fn persist_checkpoint(storage: &Storage, engine: &GridEngine, phase: &str) {
 }
 
 pub fn record_fill_ledger(storage: &Storage, session_id: &str, fill: &grid_engine::FillEvent, pnl: Decimal) {
+    // `pnl` is net of fees from the engine; ledger stores gross separately.
+    let gross = pnl + fill.fee;
     let notional = fill.price * fill.size;
     let row = FillLedgerRow {
         session_id: session_id.to_string(),
@@ -291,7 +293,7 @@ pub fn record_fill_ledger(storage: &Storage, session_id: &str, fill: &grid_engin
         crossed: fill.crossed,
         fee: fill.fee,
         fee_token: fill.fee_token.clone(),
-        gross_closed_pnl: fill.closed_pnl.unwrap_or(pnl),
+        gross_closed_pnl: gross,
         position_before: None,
         position_after: None,
         source: "exchange".into(),
@@ -301,6 +303,36 @@ pub fn record_fill_ledger(storage: &Storage, session_id: &str, fill: &grid_engin
     }
 }
 
+fn sort_fills_chronologically(fills: &mut [grid_engine::FillEvent]) {
+    fills.sort_by_key(|f| f.exchange_time_ms.unwrap_or(0));
+}
+
+/// Apply exchange fills in time order. Returns replenish intents from successful fills.
+fn apply_fills_to_engine(
+    storage: &Storage,
+    engine: &mut GridEngine,
+    session_id: &str,
+    mut fills: Vec<grid_engine::FillEvent>,
+    record_ledger: bool,
+) -> Vec<grid_engine::OrderIntent> {
+    sort_fills_chronologically(&mut fills);
+    let mut replenish = Vec::new();
+    for fill in fills {
+        match engine.on_fill(fill.clone()) {
+            Ok((pnl, intent)) => {
+                if record_ledger {
+                    record_fill_ledger(storage, session_id, &fill, pnl);
+                }
+                if let Some(i) = intent {
+                    replenish.push(i);
+                }
+            }
+            Err(e) => warn!("fill apply failed: {e}"),
+        }
+    }
+    replenish
+}
+
 pub fn record_equity(storage: &Storage, engine: &GridEngine) {
     let snap = engine.snapshot();
     let sid = engine.session_id().to_string();
@@ -615,8 +647,8 @@ pub async fn execute_recenter(
 }
 
 /// Sync engine (+ HL cache) open orders from exchange.
-/// Local-only phantoms are treated as fills (so reverse replenish runs), then
-/// missing grid levels are repaired up toward `target_resting`.
+/// Stale local orders missing on the exchange are dropped (not simulated as fills).
+/// Missing grid levels are repaired only when the book is fully in sync.
 async fn sync_open_orders_from_exchange(
     st: &mut AppState,
     symbol: &str,
@@ -640,34 +672,58 @@ async fn sync_open_orders_from_exchange(
     let Some(engine) = st.engine.as_mut() else {
         return Ok(vec![]);
     };
-    let local = engine.live_orders().to_vec();
     let session_id = engine.session_id().to_string();
 
-    let mut replenish = Vec::new();
+    // Drain exchange fills we may have missed before inferring phantoms.
+    let mut replenish = if st.mode == RunMode::Simulation {
+        vec![]
+    } else {
+        let live = engine.live_orders().to_vec();
+        if let Some(hl) = st.hl.as_mut() {
+            hl.restore_tracked_orders(&live);
+        }
+        let fills = st
+            .hl
+            .as_mut()
+            .unwrap()
+            .drain_fills()
+            .await
+            .unwrap_or_default();
+        apply_fills_to_engine(&st.storage, engine, &session_id, fills, true)
+    };
+
+    let local = engine.live_orders().to_vec();
+
+    // Exchange says no open orders but we still track locals → desync (2nd instance,
+    // API glitch). Do not phantom-fill, replace with empty, or repair — that triggers
+    // a burst of replenish orders (see repair_hole after replace_open_orders([])).
+    if exchange.is_empty() && !local.is_empty() {
+        warn!(
+            "open-order sync {symbol}: exchange=0 local={} — skipping sync (desync)",
+            local.len()
+        );
+        let _ = st.storage.record_event(
+            "order_sync_desync",
+            &format!("{symbol}: exchange=0 local={} sync_skipped", local.len()),
+        );
+        return Ok(replenish);
+    }
+
     let local_only: Vec<_> = local
         .iter()
         .filter(|l| !exchange.iter().any(|e| orders_same(l, e)))
         .cloned()
         .collect();
     for phantom in &local_only {
-        let fill = GridEngine::synthetic_fill_from_order(phantom);
-        match engine.on_fill(fill.clone()) {
-            Ok((pnl, intent)) => {
-                record_fill_ledger(&st.storage, &session_id, &fill, pnl);
-                warn!(
-                    "phantom order treated as fill {:?} {} @ {}",
-                    fill.side, fill.size, fill.price
-                );
-                let _ = st.storage.record_event(
-                    "phantom_fill",
-                    &format!("{:?} {} @ {}", fill.side, fill.size, fill.price),
-                );
-                if let Some(i) = intent {
-                    replenish.push(i);
-                }
-            }
-            Err(e) => warn!("phantom fill apply failed: {e}"),
-        }
+        // Drop stale local entries only — never simulate fills or replenish from phantoms.
+        warn!(
+            "local order missing on exchange (not a fill): {:?} {} @ {}",
+            phantom.side, phantom.size, phantom.price
+        );
+        let _ = st.storage.record_event(
+            "phantom_drop",
+            &format!("{:?} {} @ {}", phantom.side, phantom.size, phantom.price),
+        );
     }
 
     let local_after = engine.live_orders().to_vec();
@@ -711,18 +767,27 @@ async fn sync_open_orders_from_exchange(
     let mid = engine
         .mid_price
         .unwrap_or_else(|| (engine.active_bounds().0 + engine.active_bounds().1) / Decimal::from(2));
-    match engine.repair_hole_intents(mid) {
-        Ok(extra) if !extra.is_empty() => {
-            info!(
-                "repairing {} missing grid level(s); open={} target={}",
-                extra.len(),
-                engine.live_orders().len(),
-                engine.target_resting
-            );
-            replenish.extend(extra);
+    // Only repair when exchange confirmed open orders — never fill the whole grid in one
+    // burst after a partial desync (local_only non-empty but exchange had some orders).
+    if local_only.is_empty() {
+        match engine.repair_hole_intents(mid) {
+            Ok(extra) if !extra.is_empty() => {
+                info!(
+                    "repairing {} missing grid level(s); open={} target={}",
+                    extra.len(),
+                    engine.live_orders().len(),
+                    engine.target_resting
+                );
+                replenish.extend(extra);
+            }
+            Ok(_) => {}
+            Err(e) => warn!("repair_hole_intents: {e}"),
         }
-        Ok(_) => {}
-        Err(e) => warn!("repair_hole_intents: {e}"),
+    } else if !local_only.is_empty() {
+        warn!(
+            "open-order sync {symbol}: {} local-only order(s) dropped; skipping repair this tick",
+            local_only.len()
+        );
     }
 
     if let Some(hl) = st.hl.as_mut() {
@@ -852,7 +917,7 @@ async fn sync_fills_and_position(
     symbol: &str,
     session_id: &str,
 ) -> Result<(), String> {
-    let fills = if st.mode == RunMode::Simulation {
+    let mut fills = if st.mode == RunMode::Simulation {
         st.sim
             .as_mut()
             .unwrap()
@@ -875,6 +940,7 @@ async fn sync_fills_and_position(
             .await
             .unwrap_or_default()
     };
+    sort_fills_chronologically(&mut fills);
     for fill in fills {
         if let Some(engine) = st.engine.as_mut() {
             match engine.on_fill(fill.clone()) {
@@ -1132,7 +1198,7 @@ async fn process_fills_and_replenish(
     symbol: &str,
     session_id: &str,
 ) -> Result<(), String> {
-    let fills = if st.mode == RunMode::Simulation {
+    let mut fills = if st.mode == RunMode::Simulation {
         st.sim
             .as_mut()
             .unwrap()
@@ -1158,6 +1224,7 @@ async fn process_fills_and_replenish(
 
     let mut replenish_intents = Vec::new();
     let mut risk_exit: Option<String> = None;
+    sort_fills_chronologically(&mut fills);
     for fill in fills {
         match st.engine.as_mut().unwrap().on_fill(fill.clone()) {
             Ok((pnl, replenish)) => {