Update trading configuration and enhance order placement logic with signed orders caching

config.py

@@ -10,5 +10,5 @@ TRADING_BPS_THRESHOLD = 10
 MAX_TRADING_BPS_THRESHOLD = 30
 MARKET_SESSION_SECONDS = 900
 TIMEZONE = "US/Eastern"
-MAX_TRADES = 2
+MAX_TRADES = 1
 PLACE_OPPOSITE_ORDER = True  # Hedge orders

main.py

@@ -77,7 +77,7 @@ async def main():
         up_ask_price = market_data["best_ask_price"]
 
         if not ((0.2 < up_ask_price < 0.35) or (0.65 < up_bid_price < 0.8)) or (
-            market_data["micro_vs_mid_bps"] > MAX_TRADING_BPS_THRESHOLD
+            abs(market_data["micro_vs_mid_bps"]) > MAX_TRADING_BPS_THRESHOLD
         ):
             continue
 
@@ -94,13 +94,13 @@ async def main():
                     up_token,
                     down_token,
                     "UP",
-                    up_bid_price,
+                    round(up_bid_price, 2),
                     size=5,
+                    signed_orders_cache=book.signed_orders_cache,
                 )
                 current_trades = increment_trades()
                 logger.info(
                     f"Placed UP anchor and hedge orders. Total trades: {current_trades}"
-                    f"market_data={market_data}"
                 )
 
             elif (trading_side == SIGNALES.DOWN) and up_trend:
@@ -108,13 +108,13 @@ async def main():
                     up_token,
                     down_token,
                     "DOWN",
-                    down_bid_price,
+                    round(down_bid_price, 2),
                     size=5,
+                    signed_orders_cache=book.signed_orders_cache,
                 )
                 current_trades = increment_trades()
                 logger.info(
                     f"Placed DOWN anchor and hedge orders. Total trades: {current_trades}"
-                    f"market_data={market_data}"
                 )
 
         await asyncio.sleep(0.01)

utils/clob_orders.py

@@ -26,7 +26,7 @@ async def cache_token_trading_infos(
 
 
 async def place_anchor_and_hedge(
-    up_token_id, down_token_id, anchor_side, price, size=5
+    up_token_id, down_token_id, anchor_side, price, size=5, signed_orders_cache=None
 ):
     if anchor_side == "UP":
         anchor_token_id = up_token_id
@@ -35,26 +35,41 @@ async def place_anchor_and_hedge(
         anchor_token_id = down_token_id
         hedge_token_id = up_token_id
 
-    asyncio.create_task(place_limit_order(anchor_token_id, price, size))
     asyncio.create_task(
-        place_limit_order(hedge_token_id, 1 - price - PROFIT_MARGIN, size)
+        place_limit_order(anchor_token_id, price, size, signed_orders_cache)
+    )
+    asyncio.create_task(
+        place_limit_order(
+            hedge_token_id,
+            round(1 - price - PROFIT_MARGIN, 2),
+            size,
+            signed_orders_cache,
+        )
     )
     logger.info(
         f"Placed anchor and hedge orders: Anchor Token ID={anchor_token_id}, Hedge Token ID={hedge_token_id}"
     )
 
 
-async def place_limit_order(token_id: str, price: float, size: int):
+async def place_limit_order(
+    token_id: str, price: float, size: int = 5, signed_orders_cache=None
+) -> str:
     client = get_client()
 
     try:
-        order_args = OrderArgs(
+        if signed_orders_cache and (token_id, price) in signed_orders_cache:
-            token_id=token_id,
+            signed_order = signed_orders_cache[(token_id, price)]
-            price=price,
+            logger.info(
-            size=size,
+                f"Using cached signed order for Token ID={token_id}, Price={price}"
-            side=BUY,
+            )
-        )
+        else:
-        signed_order = client.create_order(order_args)
+            order_args = OrderArgs(
+                token_id=token_id,
+                price=price,
+                size=size,
+                side=BUY,
+            )
+            signed_order = client.create_order(order_args)
         response = client.post_order(signed_order)
         logger.info(
             f"Placed limit order: Token ID={token_id}, Price={price}, Size={size}, ID={response['orderID']}"

utils/orderbook.py

@@ -8,6 +8,8 @@ import threading
 import websocket
 from enum import Enum
 from config import POLYMARKET_WS_MARKET_URL, TRADING_BPS_THRESHOLD
+from py_clob_client import OrderArgs
+from py_clob_client.order_builder.constants import BUY
 from utils.clob_client import get_client
 
 logger = logging.getLogger(__name__)
@@ -34,6 +36,8 @@ class OrderBook:
             "order_book": {"bids": [], "asks": []},
         }
 
+        self.signed_orders_cache = {}
+
         self.ws = None
         self.running = False
         self.thread = None
@@ -108,6 +112,7 @@ class OrderBook:
             target=lambda: asyncio.run(self._continuous_trading_monitor()), daemon=True
         )
         self.monitoring_thread.start()
+        asyncio.create_task(self.create_signed_orders_cache())
 
         logger.info("WebSocket price stream and trading monitor started")
 
@@ -208,6 +213,28 @@ class OrderBook:
 
         logger.info("Stopped continuous trading monitor")
 
+    async def create_signed_orders_cache(self):
+        start = time.time()
+        prices = [0.01]
+        while prices[-1] < 0.99:
+            prices.append(round(prices[-1] + 0.01, 2))
+
+        client = get_client()
+        for price in prices:
+            for token_id in [self.up_token_id, self.down_token_id]:
+                order_args = OrderArgs(
+                    token_id=token_id,
+                    price=price,
+                    size=5,
+                    side=BUY,
+                )
+                signed_order = client.create_order(order_args)
+                self.signed_orders_cache[(token_id, price)] = signed_order
+        end = time.time()
+        logger.info(
+            f"Pre-created signed orders cache for tokens in {round((end - start) * 1000)} milliseconds"
+        )
+
     def clear_screen(self):
         os.system("cls" if os.name == "nt" else "clear")