Implement progressive position sizing with max_size parameter

- Add max_size support to trading logic, defaulting to trade_size
- Continue quoting trade_size amounts until max_size is reached
- Implement progressive exit strategy: sell trade_size increments when at max_size
- Track both token positions for better exposure management
- Update buy conditions to use max_size instead of 0.9 * trade_size

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

poly_data/trading_utils.py

@@ -128,18 +128,45 @@ def round_up(number, decimals):
     factor = 10 ** decimals
     return math.ceil(number * factor) / factor
 
-def get_buy_sell_amount(position, bid_price, row):
+def get_buy_sell_amount(position, bid_price, row, other_token_position=0):
     buy_amount = 0
     sell_amount = 0
 
-    sell_amount = position
-    buy_amount = row['trade_size'] - position
+    # Get max_size, defaulting to trade_size if not specified
+    max_size = row.get('max_size', row['trade_size'])
+    trade_size = row['trade_size']
+    
+    # Calculate total exposure across both sides
+    total_exposure = position + other_token_position
+    
+    # If we haven't reached max_size on either side, continue building
+    if position < max_size:
+        # Continue quoting trade_size amounts until we reach max_size
+        remaining_to_max = max_size - position
+        buy_amount = min(trade_size, remaining_to_max)
+        
+        # Only sell if we have substantial position (to allow for exit when needed)
+        if position >= trade_size:
+            sell_amount = min(position, trade_size)
+        else:
+            sell_amount = 0
+    else:
+        # We've reached max_size, implement progressive exit strategy
+        # Always offer to sell trade_size amount when at max_size
+        sell_amount = min(position, trade_size)
+        
+        # Continue quoting to buy if total exposure warrants it
+        if total_exposure < max_size * 2:  # Allow some flexibility for market making
+            buy_amount = trade_size
+        else:
+            buy_amount = 0
 
+    # Ensure minimum order size compliance
     if buy_amount > 0.7 * row['min_size'] and buy_amount < row['min_size']:
         buy_amount = row['min_size']
 
-    if bid_price < 0.1:
-
+    # Apply multiplier for low-priced assets
+    if bid_price < 0.1 and buy_amount > 0:
         if row['multiplier'] != '':
             print(f"Multiplying buy amount by {int(row['multiplier'])}")
             buy_amount = buy_amount * int(row['multiplier'])

trading.py

@@ -161,6 +161,10 @@ async def perform_trade(market):
 
                 # Get market depth and price information
                 deets = get_best_bid_ask_deets(market, detail['name'], 100, 0.1)
+
+                #if deet has None for one these values below, call it with min size of 20
+                if deets['best_bid'] is None or deets['best_ask'] is None or deets['best_bid_size'] is None or deets['best_ask_size'] is None:
+                    deets = get_best_bid_ask_deets(market, detail['name'], 20, 0.1)
                 
                 # Extract all order book details
                 best_bid = deets['best_bid']
@@ -217,8 +221,12 @@ async def perform_trade(market):
                       f"avgPrice: {avgPrice}, Best Bid: {best_bid}, Best Ask: {best_ask}, "
                       f"Bid Price: {bid_price}, Ask Price: {ask_price}, Mid Price: {mid_price}")
 
+                # Get position for the opposite token to calculate total exposure
+                other_token = global_state.REVERSE_TOKENS[str(token)]
+                other_position = get_position(other_token)['size']
+                
                 # Calculate how much to buy or sell based on our position
-                buy_amount, sell_amount = get_buy_sell_amount(position, bid_price, row)
+                buy_amount, sell_amount = get_buy_sell_amount(position, bid_price, row, other_position)
 
                 # Prepare order object with all necessary information
                 order = {
@@ -231,7 +239,8 @@ async def perform_trade(market):
                     'row': row
                 }
             
-                print(f"Position: {position}, Trade Size: {row['trade_size']}, "
+                print(f"Position: {position}, Other Position: {other_position}, "
+                      f"Trade Size: {row['trade_size']}, Max Size: {max_size}, "
                       f"buy_amount: {buy_amount}, sell_amount: {sell_amount}")
 
                 # File to store risk management information for this market
@@ -298,11 +307,14 @@ async def perform_trade(market):
                         continue
 
                 # ------- BUY ORDER LOGIC -------
+                # Get max_size, defaulting to trade_size if not specified
+                max_size = row.get('max_size', row['trade_size'])
+                
                 # Only buy if:
-                # 1. Position is less than 90% of target size
+                # 1. Position is less than max_size (new logic)
                 # 2. Position is less than absolute cap (250)
                 # 3. Buy amount is above minimum size
-                if position < 0.9 * row['trade_size'] and position < 250 and buy_amount > 0 and buy_amount >= row['min_size']:
+                if position < max_size and position < 250 and buy_amount > 0 and buy_amount >= row['min_size']:
                     # Get reference price from market data
                     sheet_value = row['best_bid']
 
@@ -366,8 +378,8 @@ async def perform_trade(market):
                                     print(f"Sending Buy Order for {token} because better price. "
                                           f"Orders look like this: {orders['buy']}. Best Bid: {best_bid}")
                                     send_buy_order(order)
-                                # 2. Current position + orders is not enough to reach target
-                                elif position + orders['buy']['size'] < 0.95 * row['trade_size']:
+                                # 2. Current position + orders is not enough to reach max_size
+                                elif position + orders['buy']['size'] < 0.95 * max_size:
                                     print(f"Sending Buy Order for {token} because not enough position + size")
                                     send_buy_order(order)
                                 # 3. Our current order is too large and needs to be resized