feat(quick-trade): use authoritative exchange fill history

Author: tianhe

backend_api_python/app/routes/alpaca.py

@@ -410,6 +410,26 @@ def get_orders():
         return jsonify({"success": False, "error": str(e)}), 500
 
 
+@alpaca_blp.route('/fills', methods=['GET'])
+@login_required
+def get_fills():
+    """Get authoritative Alpaca fill activities for the selected account."""
+    try:
+        client, err = _require_connected_client()
+        if err is not None:
+            return err
+        symbol = str(request.args.get("symbol") or "").strip()
+        limit = int(request.args.get("limit") or 100)
+        return jsonify({
+            "success": True,
+            "data": client.get_fill_history(symbol=symbol, limit=limit),
+            "source": "exchange",
+        })
+    except Exception as e:
+        logger.error(f"Get Alpaca fills failed: {e}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+
 # ==================== Trading ====================
 
 @alpaca_blp.route('/order', methods=['POST'])

backend_api_python/app/routes/quick_trade.py

@@ -1084,7 +1084,7 @@ def _compute_position() -> List[Dict[str, Any]]:
                 request.args.get("api_family", ""),
             ),
             _compute_position,
-            ttl_sec=8,
+            ttl_sec=2,
             stale_ttl_sec=90,
             timeout_sec=10,
             namespace="quick_trade_position",
@@ -1876,7 +1876,43 @@ def get_history():
                 "created_at": to_utc_iso(r.get("created_at")) or str(r.get("created_at") or ""),
             })
 
-        return jsonify({"code": 1, "msg": "success", "data": {"trades": trades}})
+        exchange_history = {"supported": False, "trades": []}
+        if credential_id > 0 and symbol and market_type in ("spot", "swap"):
+            try:
+                from app.services.quick_trade.trade_history import exchange_trade_history
+
+                config = build_exchange_config(credential_id, user_id, {"market_type": market_type})
+                client = create_exchange_client(config, market_type=market_type)
+                exchange_history = exchange_trade_history(
+                    client,
+                    symbol,
+                    market_type=market_type,
+                    limit=limit,
+                    offset=offset,
+                )
+            except Exception as exc:
+                logger.info("Native exchange trade history unavailable: %s", exc)
+
+        if exchange_history.get("supported"):
+            active_statuses = {
+                "new", "open", "pending", "submitted", "partially_filled",
+                "partially-filled", "accepted", "cancel_pending",
+            }
+            pending_orders = [
+                trade for trade in trades
+                if str(trade.get("status") or "").strip().lower() in active_statuses
+            ]
+            trades = pending_orders + list(exchange_history.get("trades") or [])
+            trades.sort(key=lambda trade: str(trade.get("created_at") or ""), reverse=True)
+
+        return jsonify({
+            "code": 1,
+            "msg": "success",
+            "data": {
+                "trades": trades,
+                "source": "exchange" if exchange_history.get("supported") else "local_fallback",
+            },
+        })
     except Exception as e:
         logger.error(f"get_history failed: {e}")
         return jsonify({"code": 0, "msg": str(e)}), 500

backend_api_python/app/services/alpaca_trading/client.py

@@ -602,6 +602,7 @@ def get_account_activities(
         after: str = "",
         until: str = "",
         date: str = "",
+        direction: str = "asc",
         page_size: int = 100,
         max_pages: int = 20,
     ) -> List[Dict[str, Any]]:
@@ -616,7 +617,7 @@ def get_account_activities(
         url = f"{host.rstrip('/')}/v2/account/activities"
         params: Dict[str, Any] = {
             "activity_types": types,
-            "direction": "asc",
+            "direction": "desc" if str(direction or "").strip().lower() == "desc" else "asc",
             "page_size": max(1, min(int(page_size or 100), 100)),
         }
         if date:
@@ -648,6 +649,73 @@ def get_account_activities(
             params["page_token"] = token
         return output
 
+    def get_fill_history(
+        self,
+        *,
+        symbol: str = "",
+        limit: int = 100,
+        max_pages: int = 20,
+    ) -> List[Dict[str, Any]]:
+        """Return account-owned Alpaca executions, one row per fill activity."""
+        requested_limit = max(1, min(int(limit or 100), 500))
+        requested_symbol = str(symbol or "").replace("/", "").replace("-", "").upper()
+        activities = self.get_account_activities(
+            activity_types=["FILL"],
+            direction="desc",
+            page_size=100,
+            max_pages=max_pages,
+        )
+        output: List[Dict[str, Any]] = []
+        for activity in activities:
+            row_symbol = str(activity.get("symbol") or "").replace("/", "").replace("-", "").upper()
+            if requested_symbol and row_symbol != requested_symbol:
+                continue
+            quantity = abs(_num(activity.get("qty") or activity.get("quantity")))
+            price = _num(activity.get("price") or activity.get("avg_price"))
+            activity_id = str(
+                activity.get("id")
+                or activity.get("activity_id")
+                or activity.get("execution_id")
+                or ""
+            ).strip()
+            side = str(activity.get("side") or "").strip().lower()
+            if not activity_id or not row_symbol or quantity <= 0 or price <= 0 or side not in {"buy", "sell"}:
+                continue
+            executed_at = str(
+                activity.get("transaction_time")
+                or activity.get("executed_at")
+                or activity.get("at")
+                or ""
+            )
+            output.append({
+                "id": f"exchange-alpaca-{activity_id}",
+                "exchange_fill_id": activity_id,
+                "exchange_order_id": str(activity.get("order_id") or ""),
+                "client_order_id": str(activity.get("client_order_id") or ""),
+                "symbol": row_symbol,
+                "side": side,
+                "order_type": "fill",
+                "status": "filled",
+                "market_type": "spot",
+                "amount": quantity * price,
+                "filled_amount": quantity,
+                "avg_fill_price": price,
+                "commission": 0.0,
+                "commission_ccy": "USD",
+                "commission_quote": None,
+                "fees_by_ccy": {},
+                "fee_status": "pending",
+                "realized_pnl": None,
+                "source": "exchange",
+                "filled_at": executed_at,
+                "created_at": executed_at,
+                "activity_type": str(activity.get("activity_type") or "FILL"),
+                "fill_type": str(activity.get("type") or "fill"),
+            })
+            if len(output) >= requested_limit:
+                break
+        return output
+
     # ==================== Query Methods ====================
 
     def get_account_summary(self) -> Dict[str, Any]:

backend_api_python/app/services/quick_trade/position_activity.py

@@ -5,6 +5,7 @@
 from math import isfinite
 
 from app.services.live_trading.binance import BinanceFuturesClient
+from app.services.live_trading.binance_spot import BinanceSpotClient
 from app.services.live_trading.bitget import BitgetMixClient
 from app.services.live_trading.bitget_classic import BitgetClassicMixClient
 from app.services.live_trading.bybit import BybitClient
@@ -121,11 +122,7 @@ def binance_position_history(client, symbol, limit=50):
         return {"supported": False, "positions": []}
     native_symbol = to_binance_futures_symbol(symbol)
     try:
-        rows = client._signed_request(
-            "GET",
-            "/fapi/v1/userTrades",
-            params={"symbol": native_symbol, "limit": 1000},
-        )
+        rows = client.get_user_trades(symbol=symbol, limit=1000)
     except Exception as exc:
         logger.info("Binance native trade history unavailable: %s", exc)
         return {"supported": False, "positions": []}
@@ -221,6 +218,99 @@ def close(side, quantity, price, fee, gross_pnl, timestamp, row_id):
     return {"supported": True, "positions": result[: max(1, int(limit or 50))]}
 
 
+def binance_trade_history(client, symbol, market_type="swap", limit=50):
+    """Return exchange-owned Binance fills for the selected instrument."""
+    market = str(market_type or "swap").strip().lower()
+    if isinstance(client, BinanceFuturesClient) and market == "swap":
+        reader = client.get_user_trades
+    elif isinstance(client, BinanceSpotClient) and market == "spot":
+        reader = client.get_my_trades
+    else:
+        return {"supported": False, "trades": []}
+
+    native_symbol = to_binance_futures_symbol(symbol)
+    try:
+        rows = reader(symbol=symbol, limit=max(1, min(int(limit or 50), 1000)))
+    except Exception as exc:
+        logger.info("Binance native trade history unavailable: %s", exc)
+        return {"supported": False, "trades": []}
+
+    net_quantity = 0.0
+    normalized = []
+    ordered = sorted(
+        (row for row in (rows or []) if isinstance(row, dict)),
+        key=lambda row: (_number(row.get("time")), _number(row.get("id") or row.get("tradeId"))),
+    )
+    for row in ordered:
+        if str(row.get("symbol") or "").upper() != native_symbol:
+            continue
+        quantity = abs(_number(row.get("qty") or row.get("quantity")))
+        price = _number(row.get("price"))
+        if quantity <= 0 or price <= 0:
+            continue
+        side = str(row.get("side") or ("BUY" if row.get("isBuyer") else "SELL")).strip().lower()
+        if side not in {"buy", "sell"}:
+            continue
+        position_side = str(row.get("positionSide") or "BOTH").strip().upper()
+        realized_value = row.get("realizedPnl")
+        realized_pnl = None if realized_value in (None, "") else _number(realized_value)
+        is_close = False
+        close_side = ""
+        if market == "swap":
+            if position_side == "LONG":
+                is_close = side == "sell"
+                close_side = "long" if is_close else ""
+            elif position_side == "SHORT":
+                is_close = side == "buy"
+                close_side = "short" if is_close else ""
+            else:
+                delta = quantity if side == "buy" else -quantity
+                if net_quantity > 1e-15 and delta < 0:
+                    is_close = True
+                    close_side = "long"
+                elif net_quantity < -1e-15 and delta > 0:
+                    is_close = True
+                    close_side = "short"
+                net_quantity += delta
+                if abs(net_quantity) <= 1e-15:
+                    net_quantity = 0.0
+            if realized_pnl is not None and abs(realized_pnl) > 1e-15:
+                is_close = True
+                close_side = close_side or ("short" if side == "buy" else "long")
+
+        commission_ccy = str(row.get("commissionAsset") or "").upper()
+        commission = abs(_number(row.get("commission")))
+        quote_ccy = str(symbol or "").split("/", 1)[-1].split(":", 1)[0].upper()
+        trade_id = str(row.get("id") or row.get("tradeId") or f"{row.get('orderId')}:{row.get('time')}")
+        normalized.append({
+            "id": f"exchange-{trade_id}",
+            "symbol": symbol,
+            "side": side,
+            "order_type": "fill",
+            "amount": quantity * price,
+            "price": 0.0,
+            "leverage": 0,
+            "market_type": market,
+            "status": "filled",
+            "exchange_order_id": str(row.get("orderId") or ""),
+            "client_order_id": str(row.get("clientOrderId") or ""),
+            "filled_amount": quantity,
+            "avg_fill_price": price,
+            "commission": commission,
+            "commission_ccy": commission_ccy,
+            "commission_quote": commission if not commission_ccy or commission_ccy == quote_ccy else None,
+            "fee_status": "confirmed" if commission > 0 else "actual_zero",
+            "realized_pnl": realized_pnl if is_close else None,
+            "source": "exchange",
+            "is_close": is_close,
+            "close_side": close_side,
+            "created_at": utc_time(row.get("time")),
+        })
+
+    normalized.sort(key=lambda row: str(row.get("created_at") or ""), reverse=True)
+    return {"supported": True, "trades": normalized[: max(1, int(limit or 50))]}
+
+
 def bybit_position_history(client, symbol, limit=50):
     """Return exchange-owned closed position cycles for Bybit linear contracts."""
     if not isinstance(client, BybitClient) or str(getattr(client, "category", "linear")) != "linear":