poly-position-watcher 0.2.8__tar.gz → 0.3.0__tar.gz

{poly_position_watcher-0.2.8/poly_position_watcher.egg-info → poly_position_watcher-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poly-position-watcher
-Version: 0.2.8
+Version: 0.3.0
 Summary: polymarket proxy wallet redeem
 Home-page: https://github.com/tosmart01/polymarket-position-watcher
 Author: pinbar
@@ -31,8 +31,9 @@ Dynamic: requires-python
 
 - WSS real-time tracking for `TRADE` and `ORDER` (positions + orders)
 - HTTP polling fallback for reliability
-- Optional fee calculation (toggle + custom formula)
-- Two sizes exposed: `size` for CLOB matched trades, `sellable_size` for on-chain confirmed trades
+- Optional fee calculation using market `feeSchedule`
+- Position fields for fill checks:
+  `size` (post-fee net size), `original_size` (pre-fee net size), `sellable_size` (on-chain confirmed size), `fee_amount` (accumulated fee amount)
 - Failed trades are detected and returned on positions (`has_failed`, `failed_trades`)
 
 **Note: WSS disconnects are auto-detected and reconnected.**
@@ -64,13 +65,21 @@ with PositionWatcherService(
     enable_http_fallback=True,  # Enable HTTP polling fallback
     add_init_positions_to_http=True,  # Auto-add condition_ids from init positions to HTTP monitoring
     enable_fee_calc=True,  # Optional: enable fee adjustments
-    # fee_calc_fn=custom_fee_fn,  # Optional: override fee formula
 ) as service:
+    service.set_market_fee_schedule(
+        "<condition_id>",
+        {"rate": 0.0175, "exponent": 1, "takerOnly": True, "rebateRate": 0.25},
+    )
+
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
     print(order)
+    if position:
+        print("size(post-fee):", position.size)
+        print("size(pre-fee):", position.original_size)
+        print("fee_amount:", position.fee_amount)
     service.show_positions(limit=10)
     service.show_orders(limit=10)
     
@@ -113,7 +122,9 @@ OrderMessage(
 UserPosition(
   price: 0.0,
   size: 0.0,
+  original_size: 0.0,
   volume: 0.0,
+  fee_amount: 0.0,
   sellable_size: 0.0,
   token_id: '',
   last_update: 0.0,
@@ -140,14 +151,20 @@ service.show_orders(limit=10)
 ## **⚠️ Fee notice (taker fee / maker rebate)**
 ---
 
-Some Polymarket markets enable taker fee / maker rebate. This library **fully supports fee calculation** and lets you control it:
+Some Polymarket markets enable taker fee / maker rebate. This library supports fee calculation from market `feeSchedule` data:
 
-- Enable with `enable_fee_calc=True` to apply fees using `feeRateBps` from trades/orders
-- Customize with `fee_calc_fn` if you need a different formula
+- Enable with `enable_fee_calc=True`
+- Register `condition_id -> feeSchedule` through `service.set_market_fee_schedule(...)` or `service.set_market_fee_schedules(...)`
+- Optionally override the fee handler with `fee_calc_fn`
 - Disable (default) if you prefer pre-fee positions
+- Returned position fields:
+  `size` = post-fee net size, `original_size` = pre-fee net size, `fee_amount` = accumulated fee amount
 
 Default fee formula (when `fee_calc_fn` is not provided):
-`fee = 0.25 * (p * (1 - p)) ** 2 * (fee_rate_bps / 1000)`, and `new_size = (1 - fee) * size`.
+`fee = size * price * rate * (price * (1 - price)) ** exponent`.
+
+On taker buys, the fee is deducted in shares, so `size` is reduced by `fee / price`.
+On taker sells, the fee is charged in USDC, so position size is unchanged and only `fee_amount` increases.
 
 ---
 
@@ -173,8 +190,9 @@ The HTTP fallback polling threads run persistently throughout the `with` stateme
 | `enable_http_fallback` | bool | False | Enable persistent HTTP polling threads as WebSocket fallback |
 | `http_poll_interval` | float | 3.0 | HTTP polling interval in seconds |
 | `add_init_positions_to_http` | bool | False | Automatically add condition IDs from initialized positions to HTTP monitoring |
-| `enable_fee_calc` | bool | False | Apply fee adjustments using `feeRateBps` from trades/orders |
-| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, fee_rate_bps) -> new_size` |
+| `enable_fee_calc` | bool | False | Apply fee adjustments using registered market `feeSchedule` data |
+| `market_fee_schedules` | mapping | None | Optional initial `condition_id -> feeSchedule` mapping |
+| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, side, fee_schedule) -> (new_size, fee_amount)` |
 
 ### Environment Variables
 

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/README.md

@@ -12,8 +12,9 @@
 
 - WSS real-time tracking for `TRADE` and `ORDER` (positions + orders)
 - HTTP polling fallback for reliability
-- Optional fee calculation (toggle + custom formula)
-- Two sizes exposed: `size` for CLOB matched trades, `sellable_size` for on-chain confirmed trades
+- Optional fee calculation using market `feeSchedule`
+- Position fields for fill checks:
+  `size` (post-fee net size), `original_size` (pre-fee net size), `sellable_size` (on-chain confirmed size), `fee_amount` (accumulated fee amount)
 - Failed trades are detected and returned on positions (`has_failed`, `failed_trades`)
 
 **Note: WSS disconnects are auto-detected and reconnected.**
@@ -45,13 +46,21 @@ with PositionWatcherService(
     enable_http_fallback=True,  # Enable HTTP polling fallback
     add_init_positions_to_http=True,  # Auto-add condition_ids from init positions to HTTP monitoring
     enable_fee_calc=True,  # Optional: enable fee adjustments
-    # fee_calc_fn=custom_fee_fn,  # Optional: override fee formula
 ) as service:
+    service.set_market_fee_schedule(
+        "<condition_id>",
+        {"rate": 0.0175, "exponent": 1, "takerOnly": True, "rebateRate": 0.25},
+    )
+
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
     print(order)
+    if position:
+        print("size(post-fee):", position.size)
+        print("size(pre-fee):", position.original_size)
+        print("fee_amount:", position.fee_amount)
     service.show_positions(limit=10)
     service.show_orders(limit=10)
     
@@ -94,7 +103,9 @@ OrderMessage(
 UserPosition(
   price: 0.0,
   size: 0.0,
+  original_size: 0.0,
   volume: 0.0,
+  fee_amount: 0.0,
   sellable_size: 0.0,
   token_id: '',
   last_update: 0.0,
@@ -121,14 +132,20 @@ service.show_orders(limit=10)
 ## **⚠️ Fee notice (taker fee / maker rebate)**
 ---
 
-Some Polymarket markets enable taker fee / maker rebate. This library **fully supports fee calculation** and lets you control it:
+Some Polymarket markets enable taker fee / maker rebate. This library supports fee calculation from market `feeSchedule` data:
 
-- Enable with `enable_fee_calc=True` to apply fees using `feeRateBps` from trades/orders
-- Customize with `fee_calc_fn` if you need a different formula
+- Enable with `enable_fee_calc=True`
+- Register `condition_id -> feeSchedule` through `service.set_market_fee_schedule(...)` or `service.set_market_fee_schedules(...)`
+- Optionally override the fee handler with `fee_calc_fn`
 - Disable (default) if you prefer pre-fee positions
+- Returned position fields:
+  `size` = post-fee net size, `original_size` = pre-fee net size, `fee_amount` = accumulated fee amount
 
 Default fee formula (when `fee_calc_fn` is not provided):
-`fee = 0.25 * (p * (1 - p)) ** 2 * (fee_rate_bps / 1000)`, and `new_size = (1 - fee) * size`.
+`fee = size * price * rate * (price * (1 - price)) ** exponent`.
+
+On taker buys, the fee is deducted in shares, so `size` is reduced by `fee / price`.
+On taker sells, the fee is charged in USDC, so position size is unchanged and only `fee_amount` increases.
 
 ---
 
@@ -154,8 +171,9 @@ The HTTP fallback polling threads run persistently throughout the `with` stateme
 | `enable_http_fallback` | bool | False | Enable persistent HTTP polling threads as WebSocket fallback |
 | `http_poll_interval` | float | 3.0 | HTTP polling interval in seconds |
 | `add_init_positions_to_http` | bool | False | Automatically add condition IDs from initialized positions to HTTP monitoring |
-| `enable_fee_calc` | bool | False | Apply fee adjustments using `feeRateBps` from trades/orders |
-| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, fee_rate_bps) -> new_size` |
+| `enable_fee_calc` | bool | False | Apply fee adjustments using registered market `feeSchedule` data |
+| `market_fee_schedules` | mapping | None | Optional initial `condition_id -> feeSchedule` mapping |
+| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, side, fee_schedule) -> (new_size, fee_amount)` |
 
 ### Environment Variables
 

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/poly_position_watcher/_version.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.2.8"
+__version__ = "0.3.0"

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/poly_position_watcher/position_service.py

@@ -10,7 +10,7 @@ import threading
 from datetime import datetime
 from queue import Queue, Empty
 from collections import defaultdict
-from typing import Callable, Dict, List
+from typing import Any, Callable, Dict, List, Mapping
 
 from poly_position_watcher.common.enums import Side, TradeStatus
 from poly_position_watcher.common.logger import logger
@@ -36,14 +36,23 @@ class PositionStore:
     """
 
     def __init__(
-            self,
-            user_address: str,
-            enable_fee_calc: bool = False,
-            fee_calc_fn: Callable[[float, float, float], float] | None = None,
+        self,
+        user_address: str,
+        enable_fee_calc: bool = False,
+        market_fee_schedules: Mapping[str, Mapping[str, Any]] | None = None,
+        fee_calc_fn: Callable[
+            [float, float, Side | str, Mapping[str, Any]], tuple[float, float]
+        ]
+        | None = None,
     ):
         self.user_address = user_address
         self.enable_fee_calc = enable_fee_calc
         self.fee_calc_fn = fee_calc_fn
+        self.market_fee_schedules: Dict[str, dict[str, Any]] = {
+            condition_id: dict(fee_schedule)
+            for condition_id, fee_schedule in (market_fee_schedules or {}).items()
+            if fee_schedule
+        }
         self.trades_by_token: Dict[str, Dict[str, TradeMessage]] = defaultdict(dict)
         self.positions: Dict[str, UserPosition] = {}
         self.orders: Dict[str, OrderMessage] = {}
@@ -126,9 +135,9 @@ class PositionStore:
         with self._lock:
             existing = self.orders.get(order.id)
             if (
-                    existing
-                    and order.size_matched <= existing.size_matched
-                    and order.status == existing.status
+                existing
+                and order.size_matched <= existing.size_matched
+                and order.status == existing.status
             ):
                 return
             if abs(order.size_matched - order.original_size) < 0.5:
@@ -136,8 +145,52 @@ class PositionStore:
             self.orders[order.id] = order
             self._put(order.id, order)
 
+    def set_market_fee_schedule(
+        self, condition_id: str, fee_schedule: Mapping[str, Any] | None
+    ) -> None:
+        with self._lock:
+            if fee_schedule:
+                self.market_fee_schedules[condition_id] = dict(fee_schedule)
+            else:
+                self.market_fee_schedules.pop(condition_id, None)
+            self._rebuild_positions_for_market(condition_id)
+
+    def set_market_fee_schedules(
+        self, fee_schedule_map: Mapping[str, Mapping[str, Any] | None]
+    ) -> None:
+        with self._lock:
+            affected_markets: set[str] = set()
+            for condition_id, fee_schedule in fee_schedule_map.items():
+                affected_markets.add(condition_id)
+                if fee_schedule:
+                    self.market_fee_schedules[condition_id] = dict(fee_schedule)
+                else:
+                    self.market_fee_schedules.pop(condition_id, None)
+
+            for condition_id in affected_markets:
+                self._rebuild_positions_for_market(condition_id)
+
+    def _rebuild_positions_for_market(self, condition_id: str) -> None:
+        for token_id, trades_map in self.trades_by_token.items():
+            trades = list(trades_map.values())
+            if not trades or not any(trade.market == condition_id for trade in trades):
+                continue
+
+            result = self.get_token_id_from_trade(trades[0])
+            if result is None:
+                continue
+
+            outcome, _ = result
+            user_pos = self.build_position(
+                trades=trades, token_id=token_id, outcome=outcome
+            )
+            if user_pos is None:
+                continue
+            self.positions[token_id] = user_pos
+            self._put(token_id, user_pos)
+
     def build_position(
-            self, trades: list[TradeMessage], token_id, outcome: str
+        self, trades: list[TradeMessage], token_id, outcome: str
     ) -> UserPosition | None:
         def _status_is(trade: TradeMessage, status: TradeStatus) -> bool:
             return trade.status == status or trade.status == status.value
@@ -150,12 +203,17 @@ class PositionStore:
         has_failed = bool(len(filled_trades))
         if has_failed:
             filled_size = sum([i.size for i in filled_trades])
-            logger.warning(f"found error trades, total size: {filled_size}: {filled_trades}")
-        market_slug = next((trade.market_slug for trade in trades if trade.market_slug), "")
+            logger.warning(
+                f"found error trades, total size: {filled_size}: {filled_trades}"
+            )
+        market_slug = next(
+            (trade.market_slug for trade in trades if trade.market_slug), ""
+        )
         position_result = calculate_position_from_trades(
             success_trades,
             user_address=self.user_address,
             enable_fee_calc=self.enable_fee_calc,
+            fee_schedule_by_market=self.market_fee_schedules,
             fee_calc_fn=self.fee_calc_fn,
         )
         sellable_size = 0.0
@@ -164,13 +222,16 @@ class PositionStore:
                 confirmed_trades,
                 user_address=self.user_address,
                 enable_fee_calc=self.enable_fee_calc,
+                fee_schedule_by_market=self.market_fee_schedules,
                 fee_calc_fn=self.fee_calc_fn,
             )
             sellable_size = confirmed_result.size
         current = UserPosition(
             price=position_result.avg_price,
             size=position_result.size,
+            original_size=position_result.original_size,
             volume=position_result.amount,
+            fee_amount=position_result.fee_amount,
             sellable_size=sellable_size,
             token_id=token_id,
             last_update=position_result.last_update,
@@ -202,12 +263,12 @@ class PositionStore:
         return self.orders.get(order_id)
 
     def blocking_get_token_position(
-            self, token_id: str, timeout: float = None
+        self, token_id: str, timeout: float = None
     ) -> UserPosition:
         return self._get(token_id, timeout)
 
     def blocking_get_order_by_id(
-            self, order_id: str, timeout: float = None
+        self, order_id: str, timeout: float = None
     ) -> OrderMessage:
         return self._get(order_id, timeout)
 
@@ -231,16 +292,20 @@ class PositionWatcherService:
     """
 
     def __init__(
-            self,
-            client,
-            ws_idle_timeout=60 * 60,
-            wss_proxies: dict | None = None,
-            init_positions: bool = False,
-            enable_http_fallback: bool = False,
-            http_poll_interval: float = 1.5,
-            add_init_positions_to_http: bool = False,
-            enable_fee_calc: bool = False,
-            fee_calc_fn: Callable[[float, float, float], float] | None = None,
+        self,
+        client,
+        ws_idle_timeout=60 * 60,
+        wss_proxies: dict | None = None,
+        init_positions: bool = False,
+        enable_http_fallback: bool = False,
+        http_poll_interval: float = 1.5,
+        add_init_positions_to_http: bool = False,
+        enable_fee_calc: bool = False,
+        market_fee_schedules: Mapping[str, Mapping[str, Any]] | None = None,
+        fee_calc_fn: Callable[
+            [float, float, Side | str, Mapping[str, Any]], tuple[float, float]
+        ]
+        | None = None,
     ):
         """
         :param client: ClobClient instance
@@ -251,8 +316,9 @@ class PositionWatcherService:
         :param http_poll_interval: HTTP polling interval in seconds
         :param add_init_positions_to_http: Whether to add condition_ids from init_positions to HTTP monitoring
         :param enable_fee_calc: Whether to apply fee adjustments in position calc
-        :param fee_calc_fn: Optional custom fee function (size, price, fee_rate_bps) -> new_size
-        
+        :param market_fee_schedules: Optional mapping of condition_id -> feeSchedule
+        :param fee_calc_fn: Optional custom fee function (size, price, side, fee_schedule) -> (new_size, fee_amount)
+
         wss_proxies example: {
             "http_proxy_host": "127.0.0.1",
             "http_proxy_port": 8118,
@@ -264,6 +330,7 @@ class PositionWatcherService:
         self.position_store = PositionStore(
             self.user_address,
             enable_fee_calc=enable_fee_calc,
+            market_fee_schedules=market_fee_schedules,
             fee_calc_fn=fee_calc_fn,
         )
         self._wss_proxies = wss_proxies or {}
@@ -303,15 +370,19 @@ class PositionWatcherService:
         init_condition_ids = []
         if self.init_positions:
             try:
-                initialize_trades = self.api_worker.fetch_trades_from_positions(self.user_address)
+                initialize_trades = self.api_worker.fetch_trades_from_positions(
+                    self.user_address
+                )
                 if initialize_trades:
                     for token_id, trades in initialize_trades.items():
                         self.position_store.init_trades(trades)
-                    positions_info = '\n'.join([
-                        f"slug={pos.market_slug}, price={pos.price}, size={pos.size:.4f},"
-                        f"volume={pos.volume:.4f}, token_id={pos.token_id}, outcome={pos.outcome}"
-                        for pos in self.position_store.positions.values()
-                    ])
+                    positions_info = "\n".join(
+                        [
+                            f"slug={pos.market_slug}, price={pos.price}, size={pos.size:.4f},"
+                            f"volume={pos.volume:.4f}, token_id={pos.token_id}, outcome={pos.outcome}"
+                            for pos in self.position_store.positions.values()
+                        ]
+                    )
                     logger.info(f"Initialized positions:\n{positions_info}")
             except Exception as e:
                 logger.error(f"Failed to initialize positions: {e}")
@@ -326,7 +397,9 @@ class PositionWatcherService:
             # Add init positions' condition_ids to HTTP monitoring if requested
             if self.add_init_positions_to_http and init_condition_ids:
                 self._http_fallback.add(market_ids=init_condition_ids)
-                logger.info(f"Added {len(init_condition_ids)} condition_ids from init_positions to HTTP monitoring")
+                logger.info(
+                    f"Added {len(init_condition_ids)} condition_ids from init_positions to HTTP monitoring"
+                )
 
         return self
 
@@ -391,6 +464,16 @@ class PositionWatcherService:
             return position
         return UserPosition(token_id=token_id, price=0, size=0, volume=0, last_update=0)
 
+    def set_market_fee_schedule(
+        self, condition_id: str, fee_schedule: Mapping[str, Any] | None
+    ) -> None:
+        self.position_store.set_market_fee_schedule(condition_id, fee_schedule)
+
+    def set_market_fee_schedules(
+        self, fee_schedule_map: Mapping[str, Mapping[str, Any] | None]
+    ) -> None:
+        self.position_store.set_market_fee_schedules(fee_schedule_map)
+
     @staticmethod
     def _truncate(value: str, limit: int) -> str:
         if len(value) <= limit:
@@ -400,9 +483,7 @@ class PositionWatcherService:
         tail = keep - head
         return f"{value[:head]}...{value[-tail:]}" if keep else "..."
 
-    def show_positions(
-            self, limit: int | None = None, max_width: int = 24
-    ) -> str:
+    def show_positions(self, limit: int | None = None, max_width: int = 24) -> str:
         """
         Pretty print current positions and return the rendered table.
         """
@@ -421,20 +502,30 @@ class PositionWatcherService:
                 if pos.last_update
                 else ""
             )
-            rows.append({
-                "slug": pos.market_slug or "",
-                "outcome": pos.outcome or "",
-                "token_id": pos.token_id or "",
-                "price": f"{pos.price:.3f}",
-                "size": f"{pos.size:.3f}",
-                "volume": f"{pos.volume:.4f}",
-                "updated_at": last_update,
-            })
+            rows.append(
+                {
+                    "slug": pos.market_slug or "",
+                    "outcome": pos.outcome or "",
+                    "token_id": pos.token_id or "",
+                    "price": f"{pos.price:.3f}",
+                    "size": f"{pos.size:.3f}",
+                    "volume": f"{pos.volume:.4f}",
+                    "updated_at": last_update,
+                }
+            )
 
         rows.sort(key=lambda r: abs(float(r["volume"])), reverse=True)
         if limit:
             rows = rows[:limit]
-        headers = ["slug", "outcome", "token_id", "price", "size", "volume", "updated_at"]
+        headers = [
+            "slug",
+            "outcome",
+            "token_id",
+            "price",
+            "size",
+            "volume",
+            "updated_at",
+        ]
         table = Table(title="Positions", show_lines=False, show_footer=True)
         table.add_column("slug", style="cyan")
         table.add_column("outcome", style="magenta")
@@ -471,9 +562,7 @@ class PositionWatcherService:
         record_console.print(table)
         return record_console.export_text()
 
-    def show_orders(
-            self, limit: int | None = None, max_width: int = 24
-    ) -> str:
+    def show_orders(self, limit: int | None = None, max_width: int = 24) -> str:
         """
         Pretty print current orders and return the rendered table.
         """
@@ -494,17 +583,19 @@ class PositionWatcherService:
                 if order.timestamp
                 else ""
             )
-            rows.append({
-                "slug": order.market_slug or "",
-                "outcome": order.outcome or "",
-                "order_id": order.id or "",
-                "side": order.side or "",
-                "price": f"{order.price:.3f}",
-                "size_matched": f"{order.size_matched:.4f}",
-                "original_size": f"{order.original_size or 0.0:.4f}",
-                "status": order.status or "",
-                "created_at": created_at,
-            })
+            rows.append(
+                {
+                    "slug": order.market_slug or "",
+                    "outcome": order.outcome or "",
+                    "order_id": order.id or "",
+                    "side": order.side or "",
+                    "price": f"{order.price:.3f}",
+                    "size_matched": f"{order.size_matched:.4f}",
+                    "original_size": f"{order.original_size or 0.0:.4f}",
+                    "status": order.status or "",
+                    "created_at": created_at,
+                }
+            )
         rows.sort(key=lambda r: abs(float(r["size_matched"])), reverse=True)
         if limit:
             rows = rows[:limit]
@@ -556,7 +647,7 @@ class PositionWatcherService:
         return self.position_store.get_order_by_id(order_id)
 
     def blocking_get_position(
-            self, token_id: str, timeout: float = None
+        self, token_id: str, timeout: float = None
     ) -> UserPosition | None:
         """
         超时返回None；若无仓位则返回 size=0 的占位 UserPosition
@@ -568,7 +659,7 @@ class PositionWatcherService:
             return self.get_position(token_id)
 
     def blocking_get_order(
-            self, order_id: str, timeout: float = None
+        self, order_id: str, timeout: float = None
     ) -> OrderMessage | None:
         """
         超时返回None（即返回 None，表示没有订单更新）
@@ -582,23 +673,29 @@ class PositionWatcherService:
     # -------------------------------------------------------------------------
     # HTTP Fallback Management (delegates to HttpFallbackManager)
     # -------------------------------------------------------------------------
-    def add_http_listen(self, order_ids: list[str] = None, market_ids: list[str] = None):
+    def add_http_listen(
+        self, order_ids: list[str] = None, market_ids: list[str] = None
+    ):
         """
         Add markets/orders to HTTP fallback polling.
-        
+
         :param order_ids: List of order IDs to monitor
         :param market_ids: List of market (condition) IDs to monitor
         """
         if not self.enable_http_fallback or not self._http_fallback:
-            logger.warning("HTTP fallback is not enabled. Enable it in __init__ to use this method.")
+            logger.warning(
+                "HTTP fallback is not enabled. Enable it in __init__ to use this method."
+            )
             return
 
         self._http_fallback.add(market_ids=market_ids, order_ids=order_ids)
 
-    def remove_http_listen(self, order_ids: list[str] = None, market_ids: list[str] = None):
+    def remove_http_listen(
+        self, order_ids: list[str] = None, market_ids: list[str] = None
+    ):
         """
         Remove markets/orders from HTTP fallback polling.
-        
+
         :param order_ids: List of order IDs to remove
         :param market_ids: List of market (condition) IDs to remove
         """

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/poly_position_watcher/schema/position_model.py

@@ -122,7 +122,9 @@ class OrderMessage(PrettyPrintBaseModel):
 class UserPosition(PrettyPrintBaseModel):
     price: float
     size: float
+    original_size: float = 0.0
     volume: float
+    fee_amount: float = 0.0
     sellable_size: float = 0.0
     token_id: Optional[str] = None
     last_update: float
@@ -150,9 +152,11 @@ class PositionResult(PrettyPrintBaseModel):
     """仓位计算结果"""
 
     size: float
+    original_size: float = 0.0
     avg_price: float
     realized_pnl: float
     amount: float
+    fee_amount: float = 0.0
     position_value: Optional[float] = None
     unrealized_pnl: Optional[float] = None
     total_pnl: Optional[float] = None

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/poly_position_watcher/trade_calculator.py

@@ -5,7 +5,7 @@
 # @File: trade_calculator.py
 # @Software: PyCharm
 from collections import deque
-from typing import Callable, List
+from typing import Any, Callable, List, Mapping
 
 from poly_position_watcher.common.enums import Side
 from poly_position_watcher.schema.position_model import (
@@ -15,17 +15,41 @@ from poly_position_watcher.schema.position_model import (
 )
 
 
-def _default_fee_calc(size: float, price: float, fee_rate_bps: float) -> float:
-    fee_multiplier = fee_rate_bps / 1000 if fee_rate_bps else 0.0
-    fee = 0.25 * (price * (1 - price)) ** 2 * fee_multiplier
-    return (1 - fee) * size
+def _default_fee_calc(
+    size: float,
+    price: float,
+    side: Side | str,
+    fee_schedule: Mapping[str, Any],
+) -> tuple[float, float]:
+    rate = float(fee_schedule.get("rate") or 0.0)
+    exponent = float(fee_schedule.get("exponent") or 0.0)
+    if size <= 0 or price <= 0 or rate <= 0:
+        return size, 0.0
+
+    fee_amount = round(
+        max(size * price * rate * ((price * (1 - price)) ** exponent), 0.0),
+        4,
+    )
+    if fee_amount <= 0:
+        return size, 0.0
+
+    if side == Side.BUY or side == Side.BUY.value:
+        fee_size = fee_amount / price
+        return max(size - fee_size, 0.0), fee_amount
+
+    return size, fee_amount
 
 
 def calculate_position_from_trades(
     trades: List[TradeMessage],
     user_address: str,
     enable_fee_calc: bool = False,
-    fee_calc_fn: Callable[[float, float, float], float] | None = None,
+    fee_schedule_by_market: Mapping[str, Mapping[str, Any]] | None = None,
+    fee_calc_fn: Callable[
+        [float, float, Side | str, Mapping[str, Any]],
+        tuple[float, float],
+    ]
+    | None = None,
 ) -> PositionResult:
     """
     根据交易记录直接计算用户仓位（带浮点误差修正）
@@ -39,18 +63,29 @@ def calculate_position_from_trades(
 
     buy_events = []
     sell_events = []
+    total_original_size = 0.0
 
     def apply_fee(
-        size: float, price: float, fee_rate_bps: float, trader_side: str | None
-    ) -> float:
-        if (
-            not enable_fee_calc
-            or fee_rate_bps <= 0
-            or trader_side != "TAKER"
-        ):
-            return size
+        size: float,
+        price: float,
+        side: Side | str,
+        market_id: str | None,
+        trader_side: str | None,
+    ) -> tuple[float, float]:
+        fee_schedule = (
+            fee_schedule_by_market.get(market_id or "")
+            if fee_schedule_by_market
+            else None
+        )
+        if not enable_fee_calc or not fee_schedule:
+            return size, 0.0
+        taker_only = bool(fee_schedule.get("takerOnly", False))
+        if taker_only and trader_side != "TAKER":
+            return size, 0.0
         calc = fee_calc_fn or _default_fee_calc
-        return calc(size, price, fee_rate_bps)
+        return calc(size, price, side, fee_schedule)
+
+    total_fee_amount = 0.0
 
     # --- 1. 解析所有交易 ---
     for trade in trades:
@@ -61,24 +96,56 @@ def calculate_position_from_trades(
             if order.maker_address.upper() != user_address.upper():
                 continue
             is_maker_order = True
-            size = apply_fee(
-                order.size, order.price, order.fee_rate_bps, trade.trader_side
+            size, fee_amount = apply_fee(
+                order.size,
+                order.price,
+                order.side,
+                trade.market,
+                trade.trader_side,
             )
+            total_fee_amount += fee_amount
 
             if order.side == Side.BUY:
-                buy_events.append((size, order.price, trade.match_time))
+                buy_events.append(
+                    (size, order.price, trade.match_time, order.size * order.price)
+                )
+                total_original_size += order.size
             else:
-                sell_events.append((-size, order.price, trade.match_time))
+                sell_events.append(
+                    (
+                        -size,
+                        order.price,
+                        trade.match_time,
+                        size * order.price - fee_amount,
+                    )
+                )
+                total_original_size -= order.size
 
         # taker 部分
         if not is_maker_order and trade.maker_address.upper() == user_address.upper():
-            size = apply_fee(
-                trade.size, trade.price, trade.fee_rate_bps, trade.trader_side
+            size, fee_amount = apply_fee(
+                trade.size,
+                trade.price,
+                trade.side,
+                trade.market,
+                trade.trader_side,
             )
+            total_fee_amount += fee_amount
             if trade.side == Side.BUY:
-                buy_events.append((size, trade.price, trade.match_time))
+                buy_events.append(
+                    (size, trade.price, trade.match_time, trade.size * trade.price)
+                )
+                total_original_size += trade.size
             else:
-                sell_events.append((-size, trade.price, trade.match_time))
+                sell_events.append(
+                    (
+                        -size,
+                        trade.price,
+                        trade.match_time,
+                        size * trade.price - fee_amount,
+                    )
+                )
+                total_original_size -= trade.size
 
     # --- 2. 时间排序 ---
     all_events = sorted(buy_events + sell_events, key=lambda x: x[2])
@@ -87,51 +154,58 @@ def calculate_position_from_trades(
     buy_queue = deque()
     realized_pnl = 0.0
 
-    for size, price, _ in all_events:
+    for size, price, _, cash_amount in all_events:
         size = clean(size)  # ← 新增：修正
 
         if size > 0:
             # 买入加入队列
-            buy_queue.append([size, price])
+            unit_cost = cash_amount / size if size else price
+            buy_queue.append([size, unit_cost])
 
         else:
             # 卖出（size 为负）
             sell_size = clean(-size)
+            sell_price = cash_amount / sell_size if sell_size else price
 
             while sell_size > EPS and buy_queue:
                 lot_size, lot_price = buy_queue[0]
 
                 if lot_size <= sell_size + EPS:
                     # 完全消耗
-                    realized_pnl += (price - lot_price) * lot_size
+                    realized_pnl += (sell_price - lot_price) * lot_size
                     sell_size -= lot_size
                     buy_queue.popleft()
                 else:
                     # 部分消耗
-                    realized_pnl += (price - lot_price) * sell_size
+                    realized_pnl += (sell_price - lot_price) * sell_size
                     buy_queue[0][0] = clean(lot_size - sell_size)
                     sell_size = 0.0
 
             # 如果还有卖不完 → 变成空头
             if sell_size > EPS:
-                buy_queue.appendleft([-sell_size, price])
+                buy_queue.appendleft([-sell_size, sell_price])
 
     # --- 4. 计算最终持仓 ---
     total_size = clean(sum(q[0] for q in buy_queue))
+    original_size = clean(total_original_size)
     cost_basis = clean(sum(clean(q[0]) * q[1] for q in buy_queue))
 
     # 若因误差产生 0.0000003 的 ghost position → 完全清掉
     if abs(total_size) < EPS:
         total_size = 0.0
         cost_basis = 0.0
+    if abs(original_size) < EPS:
+        original_size = 0.0
 
     avg_price = cost_basis / total_size if total_size != 0 else 0.0
 
     return PositionResult(
         size=total_size,
+        original_size=original_size,
         avg_price=avg_price,
         realized_pnl=realized_pnl,
         amount=cost_basis,
+        fee_amount=total_fee_amount,
         is_long=total_size > 0,
         is_short=total_size < 0,
         details=PositionDetails(

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0/poly_position_watcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poly-position-watcher
-Version: 0.2.8
+Version: 0.3.0
 Summary: polymarket proxy wallet redeem
 Home-page: https://github.com/tosmart01/polymarket-position-watcher
 Author: pinbar
@@ -31,8 +31,9 @@ Dynamic: requires-python
 
 - WSS real-time tracking for `TRADE` and `ORDER` (positions + orders)
 - HTTP polling fallback for reliability
-- Optional fee calculation (toggle + custom formula)
-- Two sizes exposed: `size` for CLOB matched trades, `sellable_size` for on-chain confirmed trades
+- Optional fee calculation using market `feeSchedule`
+- Position fields for fill checks:
+  `size` (post-fee net size), `original_size` (pre-fee net size), `sellable_size` (on-chain confirmed size), `fee_amount` (accumulated fee amount)
 - Failed trades are detected and returned on positions (`has_failed`, `failed_trades`)
 
 **Note: WSS disconnects are auto-detected and reconnected.**
@@ -64,13 +65,21 @@ with PositionWatcherService(
     enable_http_fallback=True,  # Enable HTTP polling fallback
     add_init_positions_to_http=True,  # Auto-add condition_ids from init positions to HTTP monitoring
     enable_fee_calc=True,  # Optional: enable fee adjustments
-    # fee_calc_fn=custom_fee_fn,  # Optional: override fee formula
 ) as service:
+    service.set_market_fee_schedule(
+        "<condition_id>",
+        {"rate": 0.0175, "exponent": 1, "takerOnly": True, "rebateRate": 0.25},
+    )
+
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
     print(order)
+    if position:
+        print("size(post-fee):", position.size)
+        print("size(pre-fee):", position.original_size)
+        print("fee_amount:", position.fee_amount)
     service.show_positions(limit=10)
     service.show_orders(limit=10)
     
@@ -113,7 +122,9 @@ OrderMessage(
 UserPosition(
   price: 0.0,
   size: 0.0,
+  original_size: 0.0,
   volume: 0.0,
+  fee_amount: 0.0,
   sellable_size: 0.0,
   token_id: '',
   last_update: 0.0,
@@ -140,14 +151,20 @@ service.show_orders(limit=10)
 ## **⚠️ Fee notice (taker fee / maker rebate)**
 ---
 
-Some Polymarket markets enable taker fee / maker rebate. This library **fully supports fee calculation** and lets you control it:
+Some Polymarket markets enable taker fee / maker rebate. This library supports fee calculation from market `feeSchedule` data:
 
-- Enable with `enable_fee_calc=True` to apply fees using `feeRateBps` from trades/orders
-- Customize with `fee_calc_fn` if you need a different formula
+- Enable with `enable_fee_calc=True`
+- Register `condition_id -> feeSchedule` through `service.set_market_fee_schedule(...)` or `service.set_market_fee_schedules(...)`
+- Optionally override the fee handler with `fee_calc_fn`
 - Disable (default) if you prefer pre-fee positions
+- Returned position fields:
+  `size` = post-fee net size, `original_size` = pre-fee net size, `fee_amount` = accumulated fee amount
 
 Default fee formula (when `fee_calc_fn` is not provided):
-`fee = 0.25 * (p * (1 - p)) ** 2 * (fee_rate_bps / 1000)`, and `new_size = (1 - fee) * size`.
+`fee = size * price * rate * (price * (1 - price)) ** exponent`.
+
+On taker buys, the fee is deducted in shares, so `size` is reduced by `fee / price`.
+On taker sells, the fee is charged in USDC, so position size is unchanged and only `fee_amount` increases.
 
 ---
 
@@ -173,8 +190,9 @@ The HTTP fallback polling threads run persistently throughout the `with` stateme
 | `enable_http_fallback` | bool | False | Enable persistent HTTP polling threads as WebSocket fallback |
 | `http_poll_interval` | float | 3.0 | HTTP polling interval in seconds |
 | `add_init_positions_to_http` | bool | False | Automatically add condition IDs from initialized positions to HTTP monitoring |
-| `enable_fee_calc` | bool | False | Apply fee adjustments using `feeRateBps` from trades/orders |
-| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, fee_rate_bps) -> new_size` |
+| `enable_fee_calc` | bool | False | Apply fee adjustments using registered market `feeSchedule` data |
+| `market_fee_schedules` | mapping | None | Optional initial `condition_id -> feeSchedule` mapping |
+| `fee_calc_fn` | callable | None | Custom fee function: `(size, price, side, fee_schedule) -> (new_size, fee_amount)` |
 
 ### Environment Variables
 

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/poly_position_watcher.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ poly_position_watcher/common/logger.py
 poly_position_watcher/schema/__init__.py
 poly_position_watcher/schema/base.py
 poly_position_watcher/schema/common_model.py
-poly_position_watcher/schema/position_model.py
+poly_position_watcher/schema/position_model.py
+tests/test_trade_calculator.py

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "poly-position-watcher"
-version = "0.2.8"
+version = "0.3.0"
 description = "polymarket proxy wallet redeem"
 readme = "README.md"
 requires-python = ">=3.11"

{poly_position_watcher-0.2.8 → poly_position_watcher-0.3.0}/setup.py

@@ -24,7 +24,7 @@ for cache_dir in HERE.rglob("__pycache__"):
 
 setup(
     name=PROJECT.get("name", "poly-position-watcher"),
-    version=PROJECT.get("version", "0.2.8"),
+    version=PROJECT.get("version", "0.3.0"),
     description=PROJECT.get("description", ""),
     long_description=README_PATH.read_text(encoding="utf-8") if README_PATH.exists() else "",
     long_description_content_type="text/markdown",

poly_position_watcher-0.3.0/tests/test_trade_calculator.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import math
+import unittest
+
+from poly_position_watcher.common.enums import Side
+from poly_position_watcher.schema.position_model import TradeMessage
+from poly_position_watcher.trade_calculator import calculate_position_from_trades
+
+
+USER_ADDRESS = "0x123"
+MARKET_ID = "0xmarket"
+TOKEN_ID = "0xtoken"
+FEE_SCHEDULE = {
+    "rate": 0.0175,
+    "exponent": 1,
+    "takerOnly": True,
+    "rebateRate": 0.25,
+}
+
+
+def build_taker_trade(
+    *,
+    trade_id: str,
+    side: str,
+    size: float,
+    price: float,
+    match_time: int,
+) -> TradeMessage:
+    return TradeMessage(
+        type="TRADE",
+        event_type="trade",
+        asset_id=TOKEN_ID,
+        id=trade_id,
+        maker_orders=[],
+        transaction_hash=f"0xhash-{trade_id}",
+        market=MARKET_ID,
+        maker_address=USER_ADDRESS,
+        outcome="YES",
+        owner=USER_ADDRESS,
+        price=price,
+        side=side,
+        size=size,
+        status="CONFIRMED",
+        taker_order_id=f"0xorder-{trade_id}",
+        timestamp=match_time,
+        match_time=match_time,
+        last_update=match_time,
+        trade_owner=USER_ADDRESS,
+        trader_side="TAKER",
+        fee_rate_bps=0,
+        market_slug="test-market",
+    )
+
+
+def expected_fee(size: float, price: float, rate: float, exponent: float) -> float:
+    return round(size * price * rate * ((price * (1 - price)) ** exponent), 4)
+
+
+class TradeCalculatorFeeTests(unittest.TestCase):
+    def test_maker_trade_does_not_apply_taker_only_fee(self) -> None:
+        trade = TradeMessage(
+            type="TRADE",
+            event_type="trade",
+            asset_id="outer-asset-id",
+            id="maker-1",
+            maker_orders=[
+                {
+                    "order_id": "order-user",
+                    "owner": "owner-user",
+                    "maker_address": USER_ADDRESS,
+                    "matched_amount": "1947.37",
+                    "price": "0.57",
+                    "fee_rate_bps": "1000",
+                    "asset_id": TOKEN_ID,
+                    "outcome": "Up",
+                    "side": "BUY",
+                },
+                {
+                    "order_id": "order-other",
+                    "owner": "owner-other",
+                    "maker_address": "0xother",
+                    "matched_amount": "5",
+                    "price": "0.45",
+                    "fee_rate_bps": "1000",
+                    "asset_id": "other-token",
+                    "outcome": "Down",
+                    "side": "BUY",
+                },
+            ],
+            transaction_hash="0xhash-maker",
+            market=MARKET_ID,
+            maker_address="0xouter-maker",
+            outcome="OuterOutcome",
+            owner="outer-owner",
+            price=0.57,
+            side=Side.BUY.value,
+            size=1947.37,
+            status="CONFIRMED",
+            taker_order_id="0xtaker-order",
+            timestamp=1,
+            match_time=1,
+            last_update=1,
+            trade_owner="outer-owner",
+            trader_side="MAKER",
+            fee_rate_bps=1000,
+            market_slug="test-market",
+        )
+
+        result = calculate_position_from_trades(
+            [trade],
+            user_address=USER_ADDRESS,
+            enable_fee_calc=True,
+            fee_schedule_by_market={MARKET_ID: FEE_SCHEDULE},
+        )
+
+        self.assertTrue(math.isclose(result.fee_amount, 0.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.size, 1947.37, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(
+            math.isclose(result.original_size, 1947.37, rel_tol=0, abs_tol=1e-9)
+        )
+        self.assertTrue(
+            math.isclose(result.amount, 1947.37 * 0.57, rel_tol=0, abs_tol=1e-9)
+        )
+
+    def test_taker_buy_deducts_fee_in_shares(self) -> None:
+        trade = build_taker_trade(
+            trade_id="buy-1",
+            side=Side.BUY.value,
+            size=100.0,
+            price=0.25,
+            match_time=1,
+        )
+
+        result = calculate_position_from_trades(
+            [trade],
+            user_address=USER_ADDRESS,
+            enable_fee_calc=True,
+            fee_schedule_by_market={MARKET_ID: FEE_SCHEDULE},
+        )
+
+        fee_amount = expected_fee(100.0, 0.25, 0.0175, 1)
+        expected_size = 100.0 - fee_amount / 0.25
+
+        self.assertTrue(math.isclose(result.fee_amount, fee_amount, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.size, expected_size, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.original_size, 100.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.amount, 25.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(
+            math.isclose(result.avg_price, 25.0 / expected_size, rel_tol=0, abs_tol=1e-9)
+        )
+
+    def test_taker_sell_keeps_share_count_and_charges_usdc(self) -> None:
+        trade = build_taker_trade(
+            trade_id="sell-1",
+            side=Side.SELL.value,
+            size=100.0,
+            price=0.25,
+            match_time=1,
+        )
+
+        result = calculate_position_from_trades(
+            [trade],
+            user_address=USER_ADDRESS,
+            enable_fee_calc=True,
+            fee_schedule_by_market={MARKET_ID: FEE_SCHEDULE},
+        )
+
+        fee_amount = expected_fee(100.0, 0.25, 0.0175, 1)
+        net_proceeds = 100.0 * 0.25 - fee_amount
+
+        self.assertTrue(math.isclose(result.fee_amount, fee_amount, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.size, -100.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.original_size, -100.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.amount, -net_proceeds, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(math.isclose(result.avg_price, net_proceeds / 100.0, rel_tol=0, abs_tol=1e-9))
+
+    def test_round_trip_uses_net_sell_proceeds_for_realized_pnl(self) -> None:
+        buy_trade = build_taker_trade(
+            trade_id="buy-1",
+            side=Side.BUY.value,
+            size=100.0,
+            price=0.25,
+            match_time=1,
+        )
+        buy_fee = expected_fee(100.0, 0.25, 0.0175, 1)
+        net_buy_size = 100.0 - buy_fee / 0.25
+
+        sell_trade = build_taker_trade(
+            trade_id="sell-1",
+            side=Side.SELL.value,
+            size=net_buy_size,
+            price=0.4,
+            match_time=2,
+        )
+
+        result = calculate_position_from_trades(
+            [buy_trade, sell_trade],
+            user_address=USER_ADDRESS,
+            enable_fee_calc=True,
+            fee_schedule_by_market={MARKET_ID: FEE_SCHEDULE},
+        )
+
+        sell_fee = expected_fee(net_buy_size, 0.4, 0.0175, 1)
+        expected_realized_pnl = (net_buy_size * 0.4 - sell_fee) - 25.0
+
+        self.assertTrue(math.isclose(result.size, 0.0, rel_tol=0, abs_tol=1e-9))
+        self.assertTrue(
+            math.isclose(result.realized_pnl, expected_realized_pnl, rel_tol=0, abs_tol=1e-9)
+        )
+        self.assertTrue(
+            math.isclose(result.fee_amount, buy_fee + sell_fee, rel_tol=0, abs_tol=1e-9)
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()