Add max_price_impact parameter to KellyBettingStrategy

.env.example

@@ -1,4 +1,5 @@
 MANIFOLD_API_KEY=
 BET_FROM_PRIVATE_KEY=
 OPENAI_API_KEY=
-GRAPH_API_KEY=
+GRAPH_API_KEY=
+GOOGLE_APPLICATION_CREDENTIALS= #for loading secrets from GCP

examples/monitor/match_bets_with_langfuse_traces.py

@@ -1,19 +1,23 @@
 from datetime import datetime
 from typing import Any
 
+import hishel
+from dotenv import load_dotenv
+
+load_dotenv()
 import pandas as pd
 from langfuse import Langfuse
 from pydantic import BaseModel
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     BettingStrategy,
+    ProbabilisticAnswer,
+    TradeType,
     KellyBettingStrategy,
     MaxAccuracyBettingStrategy,
     MaxAccuracyWithKellyScaledBetsStrategy,
     MaxExpectedValueBettingStrategy,
-    ProbabilisticAnswer,
-    TradeType,
 )
 from prediction_market_agent_tooling.markets.data_models import ResolvedBet
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
@@ -91,9 +95,11 @@ def get_outcome_for_trace(
         # "DeployableThinkThoroughlyProphetResearchAgent": "pma-think-thoroughly-prophet-research",  # no bets!
         "DeployableKnownOutcomeAgent": "pma-knownoutcome",
     }
+
     agent_pkey_map = {
         k: get_private_key_from_gcp_secret(v) for k, v in agent_gcp_secret_map.items()
     }
+
     # Define strategies we want to test out
     strategies = [
         MaxAccuracyBettingStrategy(bet_amount=1),
@@ -108,8 +114,34 @@ def get_outcome_for_trace(
         MaxExpectedValueBettingStrategy(bet_amount=1),
         MaxExpectedValueBettingStrategy(bet_amount=2),
         MaxExpectedValueBettingStrategy(bet_amount=25),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.01),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.05),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.1),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.15),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.2),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.25),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.3),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.4),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.5),
+        KellyBettingStrategy(max_bet_amount=2, max_slippage=0.7),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.1),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.15),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.2),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.3),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.5),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.6),
+        KellyBettingStrategy(max_bet_amount=5, max_slippage=0.7),
+        KellyBettingStrategy(max_bet_amount=25, max_slippage=0.1),
+        KellyBettingStrategy(max_bet_amount=25, max_slippage=0.2),
+        KellyBettingStrategy(max_bet_amount=25, max_slippage=0.3),
+        KellyBettingStrategy(max_bet_amount=25, max_slippage=0.5),
+        KellyBettingStrategy(max_bet_amount=25, max_slippage=0.7),
     ]
 
+    storage = hishel.FileStorage(ttl=3600)
+    controller = hishel.Controller(force_cache=True)
+    httpx_client = hishel.CacheClient(storage=storage, controller=controller)
+
     overall_md = ""
 
     print("# Agent Bet vs Simulated Bet Comparison")
@@ -124,6 +156,7 @@ def get_outcome_for_trace(
             secret_key=api_keys.langfuse_secret_key.get_secret_value(),
             public_key=api_keys.langfuse_public_key,
             host=api_keys.langfuse_host,
+            httpx_client=httpx_client,
         )
 
         traces = get_traces_for_agent(

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -1,5 +1,10 @@
 from abc import ABC, abstractmethod
 
+import numpy as np
+from loguru import logger
+from scipy.optimize import minimize_scalar
+
+from prediction_market_agent_tooling.gtypes import xDai
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.data_models import (
     Currency,
@@ -10,10 +15,14 @@
     TradeType,
 )
 from prediction_market_agent_tooling.markets.omen.data_models import get_boolean_outcome
+from prediction_market_agent_tooling.markets.omen.omen import (
+    get_buy_outcome_token_amount,
+)
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
     get_kelly_bet_full,
     get_kelly_bet_simplified,
 )
+from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
@@ -134,8 +143,27 @@ def calculate_direction(market_p_yes: float, estimate_p_yes: float) -> bool:
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: float):
+    def __init__(self, max_bet_amount: float, max_slippage: float | None = None):
         self.max_bet_amount = max_bet_amount
+        self.max_price_impact = max_slippage
+
+    def _check_price_impact_ok_else_log(
+        self, buy_direction: bool, bet_size: float, market: AgentMarket
+    ) -> None:
+        slippage = self.calculate_slippage_for_bet_amount(
+            buy_direction,
+            bet_size,
+            market.outcome_token_pool["Yes"],
+            market.outcome_token_pool["No"],
+            0,
+        )
+
+        if slippage > self.max_price_impact and not np.isclose(
+            slippage, self.max_price_impact, self.max_price_impact / 100
+        ):
+            logger.info(
+                f"Slippage {slippage} deviates too much from self.max_slippage {self.max_price_impact}, market_id {market.id}"
+            )
 
     def calculate_trades(
         self,
@@ -165,9 +193,23 @@ def calculate_trades(
             )
         )
 
+        kelly_bet_size = kelly_bet.size
+        if self.max_price_impact:
+            # Adjust amount
+            max_slippage_bet_amount = self.calculate_bet_amount_for_price_impact(
+                market, kelly_bet, 0
+            )
+
+            # We just don't want Kelly size to extrapolate price_impact - hence we take the min.
+            kelly_bet_size = min(kelly_bet.size, max_slippage_bet_amount)
+
+            self._check_price_impact_ok_else_log(
+                kelly_bet.direction, kelly_bet_size, market
+            )
+
         amounts = {
             market.get_outcome_str_from_bool(kelly_bet.direction): TokenAmount(
-                amount=kelly_bet.size, currency=market.currency
+                amount=kelly_bet_size, currency=market.currency
             ),
         }
         target_position = Position(market_id=market.id, amounts=amounts)
@@ -176,13 +218,58 @@ def calculate_trades(
         )
         return trades
 
+    def calculate_slippage_for_bet_amount(
+        self, buy_direction: bool, bet_amount: float, yes: float, no: float, fee: float
+    ) -> float:
+        total_outcome_tokens = yes + no
+        expected_price = (
+            no / total_outcome_tokens if buy_direction else yes / total_outcome_tokens
+        )
+
+        tokens_bought = get_buy_outcome_token_amount(
+            bet_amount, buy_direction, yes, no, fee
+        )
+
+        actual_price = bet_amount / tokens_bought
+        # Slippage should be > 0 if we paid more than expected_price, and
+        # < 0 if we paid less than expected_price.
+        slippage = (actual_price - expected_price) / expected_price
+        return slippage
+
+    def calculate_bet_amount_for_price_impact(
+        self, market: AgentMarket, kelly_bet: SimpleBet, fee: float
+    ) -> float:
+        def calculate_price_impact_deviation_from_target_price_impact(b: xDai) -> float:
+            actual_slippage = self.calculate_slippage_for_bet_amount(
+                kelly_bet.direction, b, yes_outcome_pool_size, no_outcome_pool_size, fee
+            )
+            # translate in y
+            return abs(actual_slippage - self.max_price_impact)
+
+        yes_outcome_pool_size = market.outcome_token_pool[
+            market.get_outcome_str_from_bool(True)
+        ]
+        no_outcome_pool_size = market.outcome_token_pool[
+            market.get_outcome_str_from_bool(False)
+        ]
+
+        optimized_bet_amount = minimize_scalar(
+            calculate_price_impact_deviation_from_target_price_impact,
+            bounds=(min(yes_outcome_pool_size, no_outcome_pool_size) / 10, 1000),
+            method="bounded",
+            tol=1e-7,
+            options={"maxiter": 10000},
+        )
+        return optimized_bet_amount.x
+
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})(max_price_impact={self.max_price_impact})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: float = 10):
+    def __init__(self, max_bet_amount: float = 10, max_slippage: float | None = None):
         self.max_bet_amount = max_bet_amount
+        self.max_slippage = max_slippage
 
     def adjust_bet_amount(
         self, existing_position: Position | None, market: AgentMarket

prediction_market_agent_tooling/markets/data_models.py

@@ -130,7 +130,7 @@ class Trade(BaseModel):
 
 
 class PlacedTrade(Trade):
-    id: str
+    id: str | None = None
 
     @staticmethod
     def from_trade(trade: Trade, id: str) -> "PlacedTrade":

pyproject.toml

@@ -48,6 +48,7 @@ sqlmodel = "^0.0.21"
 psycopg2-binary = "^2.9.9"
 base58 = ">=1.0.2,<2.0"
 loky = "^3.4.1"
+hishel = "^0.0.31"
 
 [tool.poetry.extras]
 openai = ["openai"]

scripts/calc_slippage.py

@@ -0,0 +1,18 @@
+r_a = 10
+r_b = 10
+p_a = r_b / (r_a + r_b)
+# alice buys YES (n_a) with b=10
+X = 10
+n_a = X * (r_a + r_b) / (2 * r_b)
+n_b = X * (r_a + r_b) / (2 * r_a)
+n_swap = r_a - ((r_a * r_b) / (r_b + ((X * (r_b + r_a)) / (2 * r_a))))
+n_r = n_a + n_swap
+
+p_a_new = X / n_r
+slippage = (p_a_new - p_a) / p_a
+print(f" p_a {p_a} n_swap {n_swap} p_a_new {p_a_new} slippage {slippage}")
+
+# slippage = 0.3333
+s = 1 / 5
+bet_amount = p_a * (s + 1) * n_r
+print(f"bet_amount {bet_amount}")

tests/markets/omen/test_kelly.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+from prediction_market_agent_tooling.deploy.betting_strategy import KellyBettingStrategy
+
+
+def test_kelly_slippage_calculation1() -> None:
+    # First case from https://docs.gnosis.io/conditionaltokens/docs/introduction3/#an-example-with-cpmm
+    kelly = KellyBettingStrategy(max_bet_amount=1, max_slippage=0.5)
+    yes = 10
+    no = 10
+    bet_amount = 10
+    buy_direction = True
+    assert_slip_ok(bet_amount, buy_direction, yes, no, kelly)
+
+
+def test_kelly_slippage_calculation2() -> None:
+    kelly = KellyBettingStrategy(max_bet_amount=1, max_slippage=0.5)
+    # after first bet 10 xDAI on Yes, new yes/no
+    yes = 5
+    no = 20
+    bet_amount = 10
+    buy_direction = False
+    assert_slip_ok(bet_amount, buy_direction, yes, no, kelly)
+
+
+def assert_slip_ok(
+    bet_amount: float,
+    buy_direction: bool,
+    yes: float,
+    no: float,
+    kelly: KellyBettingStrategy,
+):
+    # expect
+    expected_price = yes / (yes + no)  # p_yes
+    tokens_bought = (no + bet_amount) - (
+        (yes * no) / (yes + bet_amount)
+    )  # 23.333 # x*y = k
+    actual_price = bet_amount / tokens_bought
+    expected_slip = (actual_price - expected_price) / expected_price
+    ####
+    slip = kelly.calculate_slippage_for_bet_amount(
+        buy_direction, bet_amount=bet_amount, yes=yes, no=no, fee=0
+    )
+    assert np.isclose(slip, expected_slip, rtol=0.01)
+
+    print(slip)