prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -1,12 +1,11 @@
 from abc import ABC, abstractmethod
 from typing import Sequence
 
+import numpy as np
 from scipy.optimize import minimize_scalar
 
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
-from prediction_market_agent_tooling.deploy.constants import (
-    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
-)
+from prediction_market_agent_tooling.deploy.constants import is_invalid_outcome
 from prediction_market_agent_tooling.gtypes import (
     USD,
     CollateralToken,
@@ -15,7 +14,11 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket, MarketFees
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    MarketFees,
+    QuestionType,
+)
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     ExistingPosition,
@@ -23,14 +26,21 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
+from prediction_market_agent_tooling.markets.market_type import MarketType
 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 (
+    KellyType,
     get_kelly_bet_full,
     get_kelly_bet_simplified,
+    get_kelly_bets_categorical_full,
+    get_kelly_bets_categorical_simplified,
+)
+from prediction_market_agent_tooling.tools.betting_strategies.utils import (
+    BinaryKellyBet,
+    CategoricalKellyBet,
 )
-from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
@@ -39,6 +49,21 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    supported_question_types: set[QuestionType]
+    supported_market_types: set[MarketType]
+
+    def __init__(self, take_profit: bool = True) -> None:
+        self.take_profit = take_profit
+
+    def is_market_supported(self, market: AgentMarket) -> bool:
+        if market.question_type not in self.supported_question_types:
+            return False
+
+        if MarketType.from_market(market) not in self.supported_market_types:
+            return False
+
+        return True
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -80,7 +105,7 @@ class BettingStrategy(ABC):
 
                 if outcome_tokens_to_get_in_usd <= trade.amount:
                     raise GuaranteedLossError(
-                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
+                        f"Trade {trade=} on market {market.url=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
                     )
 
             clean_trades.append(trade)
@@ -94,6 +119,76 @@ class BettingStrategy(ABC):
         )
         return trades
 
+    @staticmethod
+    def cap_to_profitable_bet_amount(
+        market: AgentMarket,
+        bet_amount: USD,
+        outcome: OutcomeStr,
+        iters: int = 10,
+    ) -> USD:
+        """
+        Use a binary search (tree-based search) to efficiently find the largest profitable bet amount.
+        """
+        # First, try it with the desired amount right away.
+        if (
+            market.get_in_usd(
+                check_not_none(
+                    market.get_buy_token_amount(bet_amount, outcome)
+                ).as_token
+            )
+            > bet_amount
+        ):
+            return bet_amount
+
+        # If it wasn't profitable, try binary search to find the highest, but profitable, amount.
+        lower = USD(0)
+        # It doesn't make sense to try to bet more than the liquidity itself, so override it as maximal value if it's lower.
+        upper = min(bet_amount, market.get_in_usd(market.get_liquidity()))
+        best_profitable = USD(0)
+
+        for _ in range(iters):
+            mid = (lower + upper) / 2
+            potential_outcome_value = market.get_in_usd(
+                check_not_none(market.get_buy_token_amount(mid, outcome)).as_token
+            )
+
+            if potential_outcome_value > mid:
+                # Profitable, try higher
+                best_profitable = mid
+                lower = mid
+
+            else:
+                # Not profitable, try lower
+                upper = mid
+
+            # If the search interval is very small, break early
+            if float(upper - lower) < 1e-8:
+                break
+
+        if np.isclose(best_profitable.value, 0):
+            best_profitable = USD(0)
+
+        return best_profitable
+
+    @staticmethod
+    def cap_to_profitable_position(
+        market: AgentMarket,
+        existing_position: USD,
+        wanted_position: USD,
+        outcome_to_bet_on: OutcomeStr,
+    ) -> USD:
+        # If the wanted position is lower, it means the agent is gonna sell and that's profitable always.
+        if wanted_position > existing_position:
+            difference = wanted_position - existing_position
+            # Cap the difference we would like to buy to a profitable one.
+            capped_difference = BettingStrategy.cap_to_profitable_bet_amount(
+                market, difference, outcome_to_bet_on
+            )
+            # Lowered the actual wanted position such that it remains profitable.
+            wanted_position = existing_position + capped_difference
+
+        return wanted_position
+
     def _build_rebalance_trades_from_positions(
         self,
         existing_position: ExistingPosition | None,
@@ -138,10 +233,22 @@ class BettingStrategy(ABC):
             )
 
             diff_amount = target_amount - existing_amount
+
             if diff_amount == 0:
                 continue
 
             trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
+
+            # We work with positions, so imagine following scenario: Agent invested $10 when probs were 50:50,
+            # now the probs are 99:1 and his initial $10 is worth $100.
+            # If `take_profit` is set to False, agent won't sell the $90 to get back to the $10 position.
+            if (
+                not self.take_profit
+                and target_amount > 0
+                and trade_type == TradeType.SELL
+            ):
+                continue
+
             trade = Trade(
                 amount=abs(diff_amount),
                 outcome=outcome,
@@ -159,13 +266,21 @@ class BettingStrategy(ABC):
         return trades
 
 
-class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: USD):
-        self.bet_amount = bet_amount
+class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+    supported_question_types = {
+        QuestionType.BINARY,
+        QuestionType.CATEGORICAL,
+        QuestionType.SCALAR,
+    }
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(self, max_position_amount: USD, take_profit: bool = True):
+        super().__init__(take_profit=take_profit)
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def calculate_direction(
@@ -185,7 +300,7 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
     ) -> OutcomeStr:
         # We get the first direction which is != direction.
         other_direction = [i for i in outcomes if i.lower() != direction.lower()][0]
-        if INVALID_OUTCOME_LOWERCASE_IDENTIFIER in other_direction.lower():
+        if is_invalid_outcome(other_direction):
             raise ValueError("Invalid outcome found as opposite direction. Exitting.")
         return other_direction
 
@@ -196,11 +311,23 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         """We place bet on only one outcome."""
-
         outcome_to_bet_on = self.calculate_direction(market, answer)
 
+        # Will be lowered if the amount that we would need to buy would be unprofitable.
+        actual_wanted_position = BettingStrategy.cap_to_profitable_position(
+            market,
+            (
+                existing_position.amounts_current.get(outcome_to_bet_on, USD(0))
+                if existing_position
+                else USD(0)
+            ),
+            self.max_position_amount,
+            outcome_to_bet_on,
+        )
+
         target_position = Position(
-            market_id=market.id, amounts_current={outcome_to_bet_on: self.bet_amount}
+            market_id=market.id,
+            amounts_current={outcome_to_bet_on: actual_wanted_position},
         )
         trades = self._build_rebalance_trades_from_positions(
             existing_position=existing_position,
@@ -209,8 +336,11 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         )
         return trades
 
+    def __repr__(self) -> str:
+        return f"CategoricalMaxAccuracyBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
 
-class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy):
+class MaxExpectedValueBettingStrategy(CategoricalMaxAccuracyBettingStrategy):
     @staticmethod
     def calculate_direction(
         market: AgentMarket, answer: CategoricalProbabilisticAnswer
@@ -251,43 +381,54 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
         return best_outcome
 
+    def __repr__(self) -> str:
+        return f"MaxExpectedValueBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
 
-class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD, max_price_impact: float | None = None):
-        self.max_bet_amount = max_bet_amount
+class _BinaryKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+
+    def __init__(
+        self,
+        kelly_type: KellyType,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
+        self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
-    @staticmethod
     def get_kelly_bet(
+        self,
         market: AgentMarket,
-        max_bet_amount: USD,
         direction: OutcomeStr,
         other_direction: OutcomeStr,
         answer: CategoricalProbabilisticAnswer,
         override_p_yes: float | None = None,
-    ) -> SimpleBet:
+    ) -> BinaryKellyBet:
+        if not market.is_binary:
+            raise ValueError("This strategy is usable only with binary markets.")
+
         estimated_p_yes = (
             answer.probability_for_market_outcome(direction)
             if not override_p_yes
             else override_p_yes
         )
 
-        if not market.is_binary:
-            # use Kelly simple, since Kelly full only supports 2 outcomes
-
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bet = get_kelly_bet_simplified(
-                max_bet=market.get_usd_in_token(max_bet_amount),
+                max_bet=market.get_usd_in_token(self.max_position_amount),
                 market_p_yes=market.probability_for_market_outcome(direction),
                 estimated_p_yes=estimated_p_yes,
                 confidence=answer.confidence,
             )
         else:
-            # We consider only binary markets, since the Kelly strategy is not yet implemented
-            # for markets with more than 2 outcomes (https://github.com/gnosis/prediction-market-agent-tooling/issues/671).
             direction_to_bet_pool_size = market.get_outcome_token_pool_by_outcome(
                 direction
             )
@@ -298,7 +439,7 @@ class KellyBettingStrategy(BettingStrategy):
                 yes_outcome_pool_size=direction_to_bet_pool_size,
                 no_outcome_pool_size=other_direction_pool_size,
                 estimated_p_yes=estimated_p_yes,
-                max_bet=market.get_usd_in_token(max_bet_amount),
+                max_bet=market.get_usd_in_token(self.max_position_amount),
                 confidence=answer.confidence,
                 fees=market.fees,
             )
@@ -311,17 +452,16 @@ class KellyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         # We consider the p_yes as the direction with highest probability.
-        direction = MultiCategoricalMaxAccuracyBettingStrategy.calculate_direction(
+        direction = CategoricalMaxAccuracyBettingStrategy.calculate_direction(
             market, answer
         )
         # We get the first direction which is != direction.
         other_direction = [i for i in market.outcomes if i != direction][0]
-        if INVALID_OUTCOME_LOWERCASE_IDENTIFIER in other_direction.lower():
+        if is_invalid_outcome(other_direction):
             raise ValueError("Invalid outcome found as opposite direction. Exitting.")
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_bet_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -331,15 +471,24 @@ class KellyBettingStrategy(BettingStrategy):
         if self.max_price_impact:
             # Adjust amount
             max_price_impact_bet_amount = self.calculate_bet_amount_for_price_impact(
-                market, kelly_bet, direction=direction
+                market,
+                direction=direction,
+                max_price_impact=self.max_price_impact,
             )
 
             # We just don't want Kelly size to extrapolate price_impact - hence we take the min.
             kelly_bet_size = min(kelly_bet.size, max_price_impact_bet_amount)
 
         bet_outcome = direction if kelly_bet.direction else other_direction
+
         amounts = {
-            bet_outcome: market.get_token_in_usd(kelly_bet_size),
+            bet_outcome: (
+                BettingStrategy.cap_to_profitable_bet_amount(
+                    market, market.get_token_in_usd(kelly_bet_size), bet_outcome
+                )
+                if kelly_bet_size > 0
+                else USD(0)
+            ),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
@@ -347,8 +496,8 @@ class KellyBettingStrategy(BettingStrategy):
         )
         return trades
 
+    @staticmethod
     def calculate_price_impact_for_bet_amount(
-        self,
         outcome_idx: int,
         bet_amount: CollateralToken,
         pool_balances: list[OutcomeWei],
@@ -366,29 +515,31 @@ class KellyBettingStrategy(BettingStrategy):
         price_impact = (actual_price - expected_price) / expected_price
         return price_impact
 
+    @staticmethod
     def calculate_bet_amount_for_price_impact(
-        self, market: AgentMarket, kelly_bet: SimpleBet, direction: OutcomeStr
+        market: AgentMarket,
+        direction: OutcomeStr,
+        max_price_impact: float,
     ) -> CollateralToken:
         def calculate_price_impact_deviation_from_target_price_impact(
-            bet_amount_usd: float,  # Needs to be float because it's used in minimize_scalar internally.
+            bet_amount_collateral: float,  # Needs to be float because it's used in minimize_scalar internally.
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
-            price_impact = self.calculate_price_impact_for_bet_amount(
-                outcome_idx=outcome_idx,
-                bet_amount=market.get_usd_in_token(USD(bet_amount_usd)),
-                pool_balances=pool_balances,
-                fees=market.fees,
+            price_impact = (
+                _BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
+                    outcome_idx=outcome_idx,
+                    bet_amount=CollateralToken(bet_amount_collateral),
+                    pool_balances=pool_balances,
+                    fees=market.fees,
+                )
             )
             # We return abs for the algorithm to converge to 0 instead of the min (and possibly negative) value.
-
-            max_price_impact = check_not_none(self.max_price_impact)
             return abs(price_impact - max_price_impact)
 
         if not market.outcome_token_pool:
-            logger.warning(
+            raise ValueError(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet.size
 
         pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
         # stay float for compatibility with `minimize_scalar`
@@ -399,30 +550,64 @@ class KellyBettingStrategy(BettingStrategy):
             calculate_price_impact_deviation_from_target_price_impact,
             bounds=(0, 1000 * total_pool_balance),
             method="bounded",
-            tol=1e-11,
+            tol=1e-13,
             options={"maxiter": 10000},
         )
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount}, max_price_impact={self.max_price_impact})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit})"
+
+
+class SimpleBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            take_profit=take_profit,
+        )
+
+
+class FullBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    # Supports only OMEN because it uses closed-form formula derived from a binary FPMM.
+    supported_market_types = {MarketType.OMEN}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            take_profit=take_profit,
+        )
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD):
-        self.max_bet_amount = max_bet_amount
+    supported_question_types = {QuestionType.BINARY}
+    supported_market_types = {MarketType.OMEN}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit)
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
-
-    def adjust_bet_amount(
-        self, existing_position: ExistingPosition | None, market: AgentMarket
-    ) -> USD:
-        existing_position_total_amount = (
-            existing_position.total_amount_current if existing_position else USD(0)
-        )
-        return self.max_bet_amount + existing_position_total_amount
+        return self.max_position_amount
 
     def calculate_trades(
         self,
@@ -430,26 +615,23 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         answer: CategoricalProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount_usd = self.adjust_bet_amount(existing_position, market)
-
         outcome = get_most_probable_outcome(answer.probabilities)
 
-        direction = MultiCategoricalMaxAccuracyBettingStrategy.calculate_direction(
+        direction = CategoricalMaxAccuracyBettingStrategy.calculate_direction(
             market, answer
         )
         # We get the first direction which is != direction.
-        other_direction = (
-            MultiCategoricalMaxAccuracyBettingStrategy.get_other_direction(
-                outcomes=market.outcomes, direction=direction
-            )
+        other_direction = CategoricalMaxAccuracyBettingStrategy.get_other_direction(
+            outcomes=market.outcomes, direction=direction
         )
 
         # We ignore the direction nudge given by Kelly, hence we assume we have a perfect prediction.
         estimated_p_yes = 1.0
 
-        kelly_bet = KellyBettingStrategy.get_kelly_bet(
+        kelly_bet = FullBinaryKellyBettingStrategy(
+            max_position_amount=self.max_position_amount
+        ).get_kelly_bet(
             market=market,
-            max_bet_amount=adjusted_bet_amount_usd,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -471,4 +653,166 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
+
+class _CategoricalKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY, QuestionType.CATEGORICAL}
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(
+        self,
+        kelly_type: KellyType,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
+        self.max_position_amount = max_position_amount
+        self.max_price_impact = max_price_impact
+        self.allow_multiple_bets = allow_multiple_bets
+        self.allow_shorting = allow_shorting
+        self.multicategorical = multicategorical
+
+    @property
+    def maximum_possible_bet_amount(self) -> USD:
+        return self.max_position_amount
+
+    def get_kelly_bets(
+        self,
+        market: AgentMarket,
+        max_bet_amount: USD,
+        answer: CategoricalProbabilisticAnswer,
+    ) -> list[CategoricalKellyBet]:
+        max_bet = market.get_usd_in_token(max_bet_amount)
+
+        if self.kelly_type == KellyType.SIMPLE:
+            kelly_bets = get_kelly_bets_categorical_simplified(
+                market_probabilities=[market.probabilities[o] for o in market.outcomes],
+                estimated_probabilities=[
+                    answer.probability_for_market_outcome(o) for o in market.outcomes
+                ],
+                confidence=answer.confidence,
+                max_bet=max_bet,
+                fees=market.fees,
+                allow_multiple_bets=self.allow_multiple_bets,
+                allow_shorting=self.allow_shorting,
+            )
+
+        else:
+            kelly_bets = get_kelly_bets_categorical_full(
+                market_probabilities=[
+                    market.probability_for_market_outcome(o) for o in market.outcomes
+                ],
+                estimated_probabilities=[
+                    answer.probability_for_market_outcome(o) for o in market.outcomes
+                ],
+                confidence=answer.confidence,
+                max_bet=max_bet,
+                fees=market.fees,
+                allow_multiple_bets=self.allow_multiple_bets,
+                allow_shorting=self.allow_shorting,
+                multicategorical=self.multicategorical,
+                get_buy_token_amount=lambda bet_amount, outcome_index: check_not_none(
+                    market.get_buy_token_amount(
+                        bet_amount, market.get_outcome_str(outcome_index)
+                    )
+                ),
+            )
+
+        return kelly_bets
+
+    def calculate_trades(
+        self,
+        existing_position: ExistingPosition | None,
+        answer: CategoricalProbabilisticAnswer,
+        market: AgentMarket,
+    ) -> list[Trade]:
+        kelly_bets = self.get_kelly_bets(
+            market=market,
+            max_bet_amount=self.max_position_amount,
+            answer=answer,
+        )
+
+        # TODO: Allow shorting in BettingStrategy._build_rebalance_trades_from_positions.
+        # In binary implementation, we simply flip the direction in case of negative bet, for categorical outcome, we need to implement shorting.
+        kelly_bets = [bet for bet in kelly_bets if bet.size > 0]
+        if not kelly_bets:
+            return []
+
+        # TODO: Allow betting on multiple outcomes.
+        # Categorical kelly could suggest to bet on multiple outcomes, but we only consider the first one for now (limitation of BettingStrategy `trades` creation).
+        # Also, this could maybe work for multi-categorical markets as well, but it wasn't benchmarked for it.
+        best_kelly_bet = max(kelly_bets, key=lambda x: abs(x.size))
+
+        if self.max_price_impact:
+            # Adjust amount
+            max_price_impact_bet_amount = (
+                _BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
+                    market,
+                    direction=market.get_outcome_str(best_kelly_bet.index),
+                    max_price_impact=self.max_price_impact,
+                )
+            )
+            # We just don't want Kelly size to extrapolate price_impact - hence we take the min.
+            best_kelly_bet.size = min(best_kelly_bet.size, max_price_impact_bet_amount)
+
+        amounts = {
+            market.outcomes[best_kelly_bet.index]: market.get_token_in_usd(
+                best_kelly_bet.size
+            ),
+        }
+        target_position = Position(market_id=market.id, amounts_current=amounts)
+        trades = self._build_rebalance_trades_from_positions(
+            existing_position, target_position, market=market
+        )
+
+        return trades
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit})"
+
+
+class SimpleCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )
+
+
+class FullCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )