hyperquant 1.55__tar.gz → 1.56__tar.gz

{hyperquant-1.55 → hyperquant-1.56}/.gitignore

@@ -28,6 +28,7 @@ wheels/
 env/
 venv/
 ENV/
+apis.json
 
 # IDE
 .idea/
@@ -38,3 +39,7 @@ ENV/
 # OS
 .DS_Store
 Thumbs.db
+
+# Local runtime artifacts
+*.log
+polymarket_orders.log

{hyperquant-1.55 → hyperquant-1.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.55
+Version: 1.56
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-1.55 → hyperquant-1.56}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.55"
+version = "1.56"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.55 → hyperquant-1.56}/src/hyperquant/broker/models/polymarket.py

@@ -14,186 +14,413 @@ if TYPE_CHECKING:
 
    
 class Position(DataStore):
-    """Position DataStore keyed by Polymarket token id."""
+    """Position store fed only by User WS trade events."""
 
     _KEYS = ["asset"]
 
     def _init(self) -> None:
-        # 缓存LIVE订单已计入的size_matched: {order_id: size_matched}
-        self._live_cache: dict[str, float] = {}
+        self._owner_key: str | None = None
+        self._dedup_seen: dict[str, float] = {}
+        self._dedup_ttl_secs = 15 * 60
+        self._dedup_max_entries = 50_000
+        self._market_state: dict[str, dict[str, Any]] = {}
+        self._market_assets: dict[str, dict[str, str | None]] = {}
 
+    def set_owner_key(self, api_key: str | None) -> None:
+        owner = str(api_key).strip().lower() if api_key else ""
+        self._owner_key = owner or None
 
     def sorted(
         self, query: Item | None = None, limit: int | None = None
     ) -> dict[str, list[Item]]:
-        """按ts降序排列，按outcome分组"""
         if query is None:
             query = {}
         result: dict[str, list[Item]] = {}
         for item in self:
             if all(k in item and query[k] == item[k] for k in query):
                 outcome = item.get("outcome") or "unknown"
-                if outcome not in result:
-                    result[outcome] = []
-                result[outcome].append(item)
+                result.setdefault(outcome, []).append(item)
         for outcome in result:
-            result[outcome].sort(key=lambda x: (x.get("eventSlug") or '0'), reverse=True)
+            result[outcome].sort(key=lambda x: float(x.get("ts") or 0.0), reverse=True)
             if limit:
                 result[outcome] = result[outcome][:limit]
         return result
 
     def _on_response(self, msg: list[Item]) -> None:
-        if msg:
-            self._clear()
-            for rec in msg:
-                rec["ts"] = 0
-            self._update(msg)
+        # Inventory is user-trade driven only (do not overwrite via REST snapshots).
+        _ = msg
+        return
 
-    def on_trade(self, trade: Item) -> None:
-        status = str(trade.get("status") or "").upper()
-        if status not in {"MATCHED"}:
-            return
+    @staticmethod
+    def _to_float(value: Any) -> float | None:
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return None
 
-        asset_id = trade.get("asset_id")
-        outcome = trade.get("outcome")
-        side = str(trade.get("side") or "").upper()
-        size_raw = trade.get("size")
-        price_raw = trade.get("price")
+    @staticmethod
+    def _status_bucket(status: str) -> str | None:
+        if status in {"MATCHED", "MINED", "CONFIRMED"}:
+            return "SUCCESS"
+        if status == "FAILED":
+            return "FAILED"
+        return None
+
+    @staticmethod
+    def _normalize_owner(owner: Any) -> str:
+        return str(owner or "").strip().lower()
+
+    @staticmethod
+    def _dedup_bucket(status_bucket: str) -> str:
+        return "SUCCESS" if status_bucket == "SUCCESS" else "FAILED"
+
+    def _remember_dedup(self, key: str) -> bool:
+        now = time.time()
+        cutoff = now - self._dedup_ttl_secs
+        if self._dedup_seen:
+            stale = [k for k, ts in self._dedup_seen.items() if ts < cutoff]
+            for k in stale:
+                self._dedup_seen.pop(k, None)
+
+        if key in self._dedup_seen:
+            return False
+
+        self._dedup_seen[key] = now
+        if len(self._dedup_seen) > self._dedup_max_entries:
+            oldest_key = min(self._dedup_seen, key=self._dedup_seen.get)
+            self._dedup_seen.pop(oldest_key, None)
+        return True
+
+    def _infer_side_key(
+        self,
+        *,
+        market: str,
+        asset_id: str,
+        outcome: str | None,
+        outcome_index: Any,
+    ) -> str | None:
+        assets = self._market_assets.setdefault(market, {"YES": None, "NO": None})
+
+        mapped_side: str | None = None
+        if asset_id:
+            if assets.get("YES") == asset_id:
+                mapped_side = "YES"
+            elif assets.get("NO") == asset_id:
+                mapped_side = "NO"
+
+        # Prefer outcome text for side inference; outcome_index is fallback only.
+        text_side: str | None
+        text = str(outcome or "").strip().upper()
+        if text in {"YES", "UP", "TRUE"}:
+            text_side = "YES"
+        elif text in {"NO", "DOWN", "FALSE"}:
+            text_side = "NO"
+        else:
+            text_side = None
+
+        idx_side: str | None = None
+        if outcome_index is not None:
+            try:
+                idx = int(outcome_index)
+                if idx == 0:
+                    idx_side = "YES"
+                elif idx == 1:
+                    idx_side = "NO"
+            except (TypeError, ValueError):
+                idx_side = None
+
+        explicit_side = text_side if text_side is not None else idx_side
+
+        # Correct a previously wrong binding once explicit side appears.
+        if mapped_side and explicit_side and mapped_side != explicit_side:
+            dst_asset = assets.get(explicit_side)
+            if dst_asset in (None, asset_id):
+                assets[mapped_side] = None
+                assets[explicit_side] = asset_id
+                self._migrate_side_state(market=market, from_side=mapped_side, to_side=explicit_side)
+                mapped_side = explicit_side
+            else:
+                # Conflicting mapping (both legs already occupied by different assets): skip.
+                return None
+
+        if mapped_side:
+            return mapped_side
 
+        # Unknown outcome/index: do not guess side to avoid poisoning inventory.
+        if explicit_side is None:
+            return None
+
+        bound = assets.get(explicit_side)
+        if bound not in (None, asset_id):
+            return None
+        assets[explicit_side] = asset_id
+        return explicit_side
 
-        if not asset_id or not outcome or side not in {"BUY", "SELL"}:
+    def _migrate_side_state(self, *, market: str, from_side: str, to_side: str) -> None:
+        if from_side == to_side:
+            return
+        state = self._market_state.get(market)
+        if not state:
             return
 
-        try:
-            size = float(size_raw)
-        except (TypeError, ValueError):
+        from_qty_key = "yes_qty" if from_side == "YES" else "no_qty"
+        from_avg_key = "yes_avg_cost" if from_side == "YES" else "no_avg_cost"
+        to_qty_key = "yes_qty" if to_side == "YES" else "no_qty"
+        to_avg_key = "yes_avg_cost" if to_side == "YES" else "no_avg_cost"
+
+        from_qty = float(state.get(from_qty_key) or 0.0)
+        from_avg = float(state.get(from_avg_key) or 0.0)
+        to_qty = float(state.get(to_qty_key) or 0.0)
+
+        # Safe migration only when destination leg has no existing inventory.
+        if to_qty > 1e-12:
             return
-        try:
-            price = float(price_raw)
-        except (TypeError, ValueError):
-            price = None
-
-
-
-        key = {"asset": asset_id, "outcome": outcome}
-        existing = self.get(key) or {}
-
-        cur_size = float(existing.get("size") or 0.0)
-        cur_total_bought = float(existing.get("totalBought") or 0.0)
-        cur_avg_price = float(existing.get("avgPrice") or 0.0)
-        cur_cost = cur_size * cur_avg_price
-
-        if side == "BUY":
-            new_size = cur_size + size
-            total_bought = cur_total_bought + size
-            # 未拿到成交价时使用当前均价兜底，避免均价被拉低
-            effective_price = price if price is not None else cur_avg_price
-            new_cost = cur_cost + size * effective_price
-        else:  # SELL
-            new_size = cur_size - size
-            total_bought = cur_total_bought
-            # 卖出按照当前均价释放成本
-            new_cost = cur_cost - min(size, cur_size) * cur_avg_price
-
-        if new_size <= 0:
-            new_size = 0.0
-            avg_price = 0.0
-            new_cost = 0.0
-        else:
-            avg_price = max(new_cost, 0.0) / new_size
+        state[to_qty_key] = from_qty
+        state[to_avg_key] = from_avg
+        state[from_qty_key] = 0.0
+        state[from_avg_key] = 0.0
+        self._recompute_derived(state)
 
-        rec: dict[str, Any] = {
-            "asset": asset_id,
-            "outcome": outcome,
-            "side": side,
-            "size": new_size,
-            "totalBought": total_bought,
-            "avgPrice": avg_price,
+    def _default_state(self) -> dict[str, Any]:
+        return {
+            "yes_qty": 0.0,
+            "no_qty": 0.0,
+            "yes_avg_cost": 0.0,
+            "no_avg_cost": 0.0,
+            "net_diff": 0.0,
+            "portfolio_cost": 0.0,
+            "yes_asset": None,
+            "no_asset": None,
+            "yes_outcome": "Yes",
+            "no_outcome": "No",
         }
 
+    def _recompute_derived(self, state: dict[str, Any]) -> None:
+        yes_qty = float(state.get("yes_qty") or 0.0)
+        no_qty = float(state.get("no_qty") or 0.0)
+        yes_avg = float(state.get("yes_avg_cost") or 0.0)
+        no_avg = float(state.get("no_avg_cost") or 0.0)
+
+        state["net_diff"] = yes_qty - no_qty
+        state["portfolio_cost"] = (yes_avg + no_avg) if (yes_qty > 0.0 and no_qty > 0.0) else 0.0
+
+    def _upsert_row(self, row: dict[str, Any]) -> None:
+        existing = self.get({"asset": row["asset"]})
         if existing:
-            self._update([rec])
+            self._update([row])
         else:
-            self._insert([rec])
+            self._insert([row])
+
+    def _publish_market_state(self, market: str, state: dict[str, Any]) -> None:
+        now_ms = int(time.time() * 1000)
+
+        common = {
+            "market": market,
+            "yes_qty": float(state.get("yes_qty") or 0.0),
+            "no_qty": float(state.get("no_qty") or 0.0),
+            "yes_avg_cost": float(state.get("yes_avg_cost") or 0.0),
+            "no_avg_cost": float(state.get("no_avg_cost") or 0.0),
+            "net_diff": float(state.get("net_diff") or 0.0),
+            "portfolio_cost": float(state.get("portfolio_cost") or 0.0),
+            "ts": now_ms,
+            "source": "user_ws_trade",
+        }
 
-    def _on_order(self, order: dict[str, Any]) -> None:
-        """通过order更新持仓，处理LIVE时部分成交的增量统计"""
-        # print(order)
-        # order写入本地尝试后续分析
-        # with open("polymarket_orders.log", "a") as f:
-        #     f.write(json.dumps(order) + "\n")
-        order_id = order.get("id")
-        asset_id = order.get("asset_id")
-        outcome = order.get("outcome")
-        side = str(order.get("side") or "").upper()
-        size_matched = float(order.get("size_matched") or 0)
-        price = float(order.get("price") or 0)
-        status = str(order.get("status") or "").upper()
-
-        if not order_id or not asset_id or not outcome or side not in {"BUY", "SELL"}:
+        yes_asset = state.get("yes_asset")
+        no_asset = state.get("no_asset")
+        if yes_asset:
+            yes_qty = common["yes_qty"]
+            yes_avg = common["yes_avg_cost"]
+            self._upsert_row(
+                {
+                    "asset": yes_asset,
+                    "outcome": state.get("yes_outcome") or "Yes",
+                    "size": yes_qty,
+                    "avgPrice": yes_avg,
+                    "totalAvgPrice": yes_avg,
+                    **common,
+                }
+            )
+        if no_asset:
+            no_qty = common["no_qty"]
+            no_avg = common["no_avg_cost"]
+            self._upsert_row(
+                {
+                    "asset": no_asset,
+                    "outcome": state.get("no_outcome") or "No",
+                    "size": no_qty,
+                    "avgPrice": no_avg,
+                    "totalAvgPrice": no_avg,
+                    **common,
+                }
+            )
+
+    def _apply_fill(self, fill: dict[str, Any], status_bucket: str) -> None:
+        market = str(fill.get("market") or "")
+        if not market:
+            market = "__unknown_market__"
+
+        asset_id = str(fill.get("asset_id") or "")
+        if not asset_id:
+            return
+
+        outcome = fill.get("outcome")
+        side = str(fill.get("side") or "").upper()
+        size = self._to_float(fill.get("size"))
+        price = self._to_float(fill.get("price"))
+        if side not in {"BUY", "SELL"} or size is None or price is None or size <= 0.0 or price <= 0.0:
             return
 
-        cached = self._live_cache.get(order_id, 0.0)
-
-        if status == "LIVE":
-            # LIVE时计算增量
-            delta = size_matched - cached
-            if delta > 0:
-                self._live_cache[order_id] = size_matched
-                self._apply_trade(asset_id, outcome, side, delta, price)
-        elif status in {"CANCELED", "MATCHED"}:
-            # 订单完结：计算最终增量 = 最终size_matched - 已计入的cached
-            delta = size_matched - cached
-            if delta > 0:
-                self._apply_trade(asset_id, outcome, side, delta, price)
-            # 清理缓存
-            self._live_cache.pop(order_id, None)
-
-    def _apply_trade(self, asset_id: str, outcome: str, side: str, size: float, price: float) -> None:
-        """应用成交到持仓"""
-        if size <= 0:
+        side_key = self._infer_side_key(
+            market=market,
+            asset_id=asset_id,
+            outcome=str(outcome or ""),
+            outcome_index=fill.get("outcome_index"),
+        )
+        if side_key is None:
             return
 
-        key = {"asset": asset_id, "outcome": outcome}
-        existing = self.get(key) or {}
-
-        cur_size = float(existing.get("size") or 0.0)
-        cur_total_bought = float(existing.get("totalBought") or 0.0)
-        cur_avg_price = float(existing.get("avgPrice") or 0.0)
-        cur_cost = cur_size * cur_avg_price
-
-        if side == "BUY":
-            new_size = cur_size + size
-            total_bought = cur_total_bought + size
-            effective_price = price if price else cur_avg_price
-            new_cost = cur_cost + size * effective_price
-        else:  # SELL
-            new_size = cur_size - size
-            total_bought = cur_total_bought
-            new_cost = cur_cost - min(size, cur_size) * cur_avg_price
-
-        if new_size <= 0:
-            new_size = 0.0
-            avg_price = 0.0
-            new_cost = 0.0
+        state = self._market_state.setdefault(market, self._default_state())
+        assets = self._market_assets.get(market) or {}
+        state["yes_asset"] = assets.get("YES")
+        state["no_asset"] = assets.get("NO")
+        if side_key == "YES":
+            state["yes_asset"] = asset_id
+            if outcome:
+                state["yes_outcome"] = outcome
         else:
-            avg_price = max(new_cost, 0.0) / new_size
+            state["no_asset"] = asset_id
+            if outcome:
+                state["no_outcome"] = outcome
+
+        trade_sign = 1.0 if side == "BUY" else -1.0
+        status_sign = -1.0 if status_bucket == "FAILED" else 1.0
+        delta = size * trade_sign * status_sign
+        if abs(delta) < 1e-12:
+            return
 
-        rec: dict[str, Any] = {
-            "asset": asset_id,
-            "outcome": outcome,
-            "side": side,
-            "size": new_size,
-            "totalBought": total_bought,
-            "totalAvgPrice": avg_price,
-            "avgPrice": avg_price,
-            "ts": int(time.time() * 1000),
-        }
+        qty_key = "yes_qty" if side_key == "YES" else "no_qty"
+        avg_key = "yes_avg_cost" if side_key == "YES" else "no_avg_cost"
+        old_qty = float(state.get(qty_key) or 0.0)
+        old_avg = float(state.get(avg_key) or 0.0)
+        new_qty = max(old_qty + delta, 0.0)
+        state[qty_key] = new_qty
+
+        if delta > 0.0 and new_qty > 0.0:
+            state[avg_key] = (old_qty * old_avg + delta * price) / new_qty
+        elif new_qty < 1e-12:
+            state[avg_key] = 0.0
+        else:
+            state[avg_key] = old_avg
 
-        if existing:
-            self._update([rec])
+        self._recompute_derived(state)
+        self._publish_market_state(market, state)
+
+    def _parse_maker_fills(self, trade: Item) -> list[dict[str, Any]]:
+        fills: list[dict[str, Any]] = []
+        maker_orders = trade.get("maker_orders") or []
+        if not isinstance(maker_orders, list):
+            return fills
+
+        trade_price = self._to_float(trade.get("price"))
+        trade_size = self._to_float(trade.get("size"))
+        trade_side = str(trade.get("side") or "").upper()
+
+        for maker in maker_orders:
+            if not isinstance(maker, dict):
+                continue
+            owner = self._normalize_owner(maker.get("owner"))
+            if self._owner_key and (not owner or owner != self._owner_key):
+                continue
+
+            side = str(maker.get("side") or trade_side or "").upper()
+            size = self._to_float(maker.get("matched_amount"))
+            if size is None:
+                size = self._to_float(maker.get("size"))
+            if size is None:
+                size = trade_size
+            price = self._to_float(maker.get("price"))
+            if price is None:
+                price = trade_price
+            if side not in {"BUY", "SELL"} or size is None or price is None:
+                continue
+            fills.append(
+                {
+                    "trade_id": trade.get("id"),
+                    "order_id": maker.get("order_id"),
+                    "market": trade.get("market"),
+                    "asset_id": maker.get("asset_id") or trade.get("asset_id"),
+                    "outcome": maker.get("outcome") or trade.get("outcome"),
+                    "outcome_index": maker.get("outcome_index"),
+                    "side": side,
+                    "size": size,
+                    "price": price,
+                }
+            )
+        return fills
+
+    def _parse_taker_fill(self, trade: Item) -> list[dict[str, Any]]:
+        owner = self._normalize_owner(trade.get("trade_owner") or trade.get("owner"))
+        if self._owner_key and owner and owner != self._owner_key:
+            return []
+
+        side = str(trade.get("side") or "").upper()
+        size = self._to_float(trade.get("size"))
+        price = self._to_float(trade.get("price"))
+        if side not in {"BUY", "SELL"} or size is None or price is None:
+            return []
+
+        return [
+            {
+                "trade_id": trade.get("id"),
+                "order_id": trade.get("taker_order_id") or trade.get("order_id"),
+                "market": trade.get("market"),
+                "asset_id": trade.get("asset_id"),
+                "outcome": trade.get("outcome"),
+                "outcome_index": trade.get("outcome_index"),
+                "side": side,
+                "size": size,
+                "price": price,
+            }
+        ]
+
+    def on_trade(self, trade: Item) -> None:
+        status = str(trade.get("status") or "").upper()
+        status_bucket = self._status_bucket(status)
+        if status_bucket is None:
+            return
+
+        trader_side = str(trade.get("trader_side") or "")
+        maker_orders = trade.get("maker_orders") or []
+        has_maker_orders = isinstance(maker_orders, list) and len(maker_orders) > 0
+
+        if trader_side.upper() == "MAKER" or (not trader_side and has_maker_orders):
+            fills = self._parse_maker_fills(trade)
+            if not fills:
+                return
         else:
-            self._insert([rec])
+            fills = self._parse_taker_fill(trade)
+
+        bucket = self._dedup_bucket(status_bucket)
+        for fill in fills:
+            trade_id = str(fill.get("trade_id") or "")
+            order_id = str(fill.get("order_id") or "")
+            if trade_id:
+                dedup_key = f"tid:{trade_id}:oid:{order_id}:{bucket}"
+            else:
+                dedup_key = (
+                    f"oid:{order_id}:{bucket}:"
+                    f"{fill.get('asset_id')}:{fill.get('side')}:"
+                    f"{fill.get('price')}:{fill.get('size')}"
+                )
+            if not self._remember_dedup(dedup_key):
+                continue
+            self._apply_fill(fill, status_bucket)
+
+    def _on_order(self, order: dict[str, Any]) -> None:
+        # Position is no longer order-driven.
+        _ = order
+        return
 
 
 
@@ -796,6 +1023,9 @@ class PolymarketDataStore(DataStoreCollection):
         self._create("trade", datastore_class=Trade)
         self._create("price", datastore_class=Price)
 
+    def set_owner_key(self, api_key: str | None) -> None:
+        self.position.set_owner_key(api_key)
+
     @property
     def book(self) -> Book:
         """Order Book DataStore
@@ -853,50 +1083,32 @@ class PolymarketDataStore(DataStoreCollection):
     @property
     def position(self) -> Position:
         """
+        User inventory snapshot keyed by ``asset`` (token id), updated from
+        authenticated User WS ``trade`` events only.
 
-        .. code:: python
-        
-            [{
-                # 🔑 基础信息
-                "proxyWallet": "0x56687bf447db6ffa42ffe2204a05edaa20f55839",  # 代理钱包地址（用于代表用户在链上的交易地址）
-                "asset": "<string>",                                          # outcome token 资产地址或 symbol
-                "conditionId": "0xdd22472e552920b8438158ea7238bfadfa4f736aa4cee91a6b86c39ead110917",  # 市场条件 ID（event 的唯一标识）
-                
-                # 💰 交易与价格信息
-                "size": 123,             # 当前持仓数量（仅在未平仓时存在）
-                "avgPrice": 123,         # 平均买入价（每个 outcome token 的均价）
-                "curPrice": 123,         # 当前市场价格
-                "initialValue": 123,     # 初始建仓总价值（avgPrice × size）
-                "currentValue": 123,     # 当前持仓市值（curPrice × size）
-
-                # 📊 盈亏指标
-                "cashPnl": 123,             # 未实现盈亏（当前浮动盈亏）
-                "percentPnl": 123,          # 未实现盈亏百分比
-                "realizedPnl": 123,         # 已实现盈亏（平仓后的实际收益）
-                "percentRealizedPnl": 123,  # 已实现盈亏百分比（相对成本的收益率）
-
-                # 🧮 累计交易信息
-                "totalBought": 123,  # 累计买入数量（含历史）
-
-                # 新增字段
-                "totalAvgPrice": 123, # 累计买入均价（含历史）
-                
-                # ⚙️ 状态标志
-                "redeemable": True,   # 是否可赎回（True 表示市场已结算且你是赢家，可提取 USDC）
-                "mergeable": True,    # 是否可合并（多笔相同 outcome 可合并为一笔）
-                "negativeRisk": True, # 是否为负风险组合（风险对冲导致净敞口为负）
-                
-                # 🧠 市场元数据
-                "title": "<string>",          # 市场标题（如 “Bitcoin up or down 15m”）
-                "slug": "<string>",           # outcome 唯一 slug（对应前端页面路径的一部分）
-                "eventSlug": "<string>",      # event slug（整个预测事件的唯一路径标识）
-                "icon": "<string>",           # 图标 URL（一般为事件关联资产）
-                "outcome": "<string>",        # 当前持有的 outcome 名称（例如 “Yes” 或 “No”）
-                "outcomeIndex": 123,          # outcome 在该市场中的索引（0 或 1）
-                "oppositeOutcome": "<string>",# 对立 outcome 名称
-                "oppositeAsset": "<string>",  # 对立 outcome token 地址
-                "endDate": "<string>",        # 市场结束时间（UTC ISO 格式字符串）
-            }]
+        Notes:
+        - Data source: user WS trade events (MATCHED/MINED/CONFIRMED/FAILED).
+        - Order stream and REST position sync do not drive inventory.
+        - Maker fills are owner-filtered by api key; reconnect duplicates are deduped.
+        - FAILED events reverse prior inventory impact.
+
+        .. code:: json
+            {
+                "asset": "15425820309554596073938947961054885346747932482195187699753650361958599405318",  // token id
+                "outcome": "Yes",            // 当前asset对应的outcome名称
+                "size": 5.0,                 // 当前asset仓位数量（对应 yes_qty 或 no_qty）
+                "avgPrice": 0.47,            // 当前asset均价
+                "totalAvgPrice": 0.47,       // 与 avgPrice 同步，兼容旧字段
+                "market": "0x...",           // conditionId / market id
+                "yes_qty": 5.0,              // YES腿数量
+                "no_qty": 3.0,               // NO腿数量
+                "yes_avg_cost": 0.47,        // YES腿VWAP成本
+                "no_avg_cost": 0.49,         // NO腿VWAP成本
+                "net_diff": 2.0,             // 净敞口 = yes_qty - no_qty
+                "portfolio_cost": 0.96,      // 组合成本 = yes_avg_cost + no_avg_cost（双腿都有仓时）
+                "ts": 1772269014393,         // 本地更新时间戳(ms)
+                "source": "user_ws_trade"    // 数据来源标记
+            }
         """
 
         return self._get("position")
@@ -948,7 +1160,7 @@ class PolymarketDataStore(DataStoreCollection):
             }
         """
 
-        return self._get("trade")
+        return self._get("mytrade")
     
     @property
     def price(self) -> Price:
@@ -1037,12 +1249,10 @@ class PolymarketDataStore(DataStoreCollection):
                 self.book._on_message(m)
             elif msg_type == "order":
                 self.orders._on_message(m)
-                self.position._on_order(m)
 
             elif msg_type == "trade":
                 self.mytrade._on_message(m)
-                # self.fill._on_trade(m)
-                # self.position.on_trade(m)
+                self.position.on_trade(m)
             elif msg_type == 'orders_matched':
                 payload = m.get("payload") or {}
                 if not payload:
@@ -1072,4 +1282,4 @@ class PolymarketDataStore(DataStoreCollection):
                 continue
             msg_type = str(raw_type).lower()
             if msg_type == "last_trade_price":
-                self.trade._on_message(m)
+                self.trade._on_message(m)

{hyperquant-1.55 → hyperquant-1.56}/src/hyperquant/broker/polymarket.py

@@ -264,6 +264,9 @@ class Polymarket:
         self._forward_ws: dict[str, Any] | None = None
 
         self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
+        creds = self._api_creds()
+        if creds:
+            self.store.set_owner_key(creds.get("api_key"))
 
     async def __aenter__(self) -> "Polymarket":
         if self.auth:
@@ -647,15 +650,8 @@ class Polymarket:
         if not creds:
             raise RuntimeError("Polymarket API credentials are required for personal subscriptions")
 
-        # 记录 position store 最后更新时间
-        last_position_update = time.time()
-        
         def _handler(message, ws=None):
-            nonlocal last_position_update
             self.store.onmessage(message, ws)
-            # 检测是否是 position 相关消息
-            if isinstance(message, dict) and message.get('event_type') in ('order', 'trade'):
-                last_position_update = time.time()
             if callback:
                 callback(message, ws)
 
@@ -664,30 +660,23 @@ class Polymarket:
         api_key = creds.get("api_key")
         api_secret = creds.get("api_secret")
         api_passphrase = creds.get("api_passphrase")
+        self.store.set_owner_key(api_key)
         if not api_key or not api_secret or not api_passphrase:
             raise RuntimeError("Polymarket API key/secret/passphrase missing; call create_or_derive_api_creds")
 
         auth = {"apiKey": api_key, "secret": api_secret, "passphrase": api_passphrase}
         payload = {"markets": list(markets or []), "type": "user", "auth": auth}
 
-        # 在开始前用rest_api同步持仓
-        await self.update('position')
+        # Position inventory is user-trade driven; ignore REST position sync.
+        _ = rest_position_sync_interval
 
-        # 后台任务：3秒无更新则同步持仓
+        # 后台任务：定时同步 orders（best-effort）
         async def _rest_sync_watchdog():
-            nonlocal last_position_update
             last_orders_update = time.time()
             while True:
                 await asyncio.sleep(1)
                 now = time.time()
-                # position: 6秒无更新则同步
-                if now - last_position_update > rest_position_sync_interval:
-                    try:
-                        await self.update('position')
-                        last_position_update = now
-                    except Exception:
-                        pass
-                # orders: 每3秒同步一次
+                # orders: 定时同步一次
                 if now - last_orders_update > rest_order_sync_interval:
                     try:
                         await self.update('orders')
@@ -2625,6 +2614,7 @@ class Polymarket:
         if not creds["api_key"] or not creds["api_secret"] or not creds["api_passphrase"]:
             raise RuntimeError("Polymarket API creds response missing key/secret/passphrase")
         session.__dict__["_polymarket_api_creds"] = creds
+        self.store.set_owner_key(creds.get("api_key"))
         apis = session.__dict__.get("_apis")
         if isinstance(apis, dict):
             entry = list(apis.get(API_NAME, []))

{hyperquant-1.55 → hyperquant-1.56}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.54"
+version = "1.55"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },