prediction-market-agent-tooling 0.67.4__py3-none-any.whl → 0.68.0__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -11,7 +11,7 @@ from pydantic_ai.exceptions import UnexpectedModelBehavior
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     BettingStrategy,
-    MultiCategoricalMaxAccuracyBettingStrategy,
+    CategoricalMaxAccuracyBettingStrategy,
     TradeType,
 )
 from prediction_market_agent_tooling.deploy.trade_interval import (
@@ -662,9 +662,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
         """
         total_amount = self.get_total_amount_to_bet(market)
-        return MultiCategoricalMaxAccuracyBettingStrategy(
-            max_position_amount=total_amount
-        )
+        return CategoricalMaxAccuracyBettingStrategy(max_position_amount=total_amount)
 
     def build_trades(
         self,

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -30,8 +30,13 @@ from prediction_market_agent_tooling.markets.omen.omen import (
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
     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
 
 
@@ -245,7 +250,7 @@ class BettingStrategy(ABC):
         return trades
 
 
-class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
     def __init__(self, max_position_amount: USD, take_profit: bool = True):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
@@ -308,8 +313,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
@@ -350,49 +358,52 @@ 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):
+class BinaryKellyBettingStrategy(BettingStrategy):
     def __init__(
         self,
         max_position_amount: USD,
         max_price_impact: float | None = None,
         take_profit: bool = True,
+        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
+        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
         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 market.outcome_token_pool is None or self.force_simplified_calculation:
             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
             )
@@ -403,7 +414,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,
             )
@@ -416,7 +427,7 @@ 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.
@@ -426,7 +437,6 @@ class KellyBettingStrategy(BettingStrategy):
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_position_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -436,7 +446,10 @@ 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,
+                kelly_bet.size,
+                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.
@@ -447,7 +460,9 @@ class KellyBettingStrategy(BettingStrategy):
         amounts = {
             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(
@@ -455,8 +470,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],
@@ -474,33 +489,43 @@ 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,
+        kelly_bet_size: CollateralToken,
+        direction: OutcomeStr,
+        max_price_impact: float,
     ) -> CollateralToken:
         def calculate_price_impact_deviation_from_target_price_impact(
             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=CollateralToken(bet_amount_collateral),
-                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(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet.size
+            return kelly_bet_size
 
-        pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
+        filtered_pool = {
+            outcome: pool_value
+            for outcome, pool_value in market.outcome_token_pool.items()
+            if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower()
+        }
+
+        pool_balances = [i.as_outcome_wei for i in filtered_pool.values()]
         # stay float for compatibility with `minimize_scalar`
-        total_pool_balance = sum([i.value for i in market.outcome_token_pool.values()])
+        total_pool_balance = sum([i.value for i in filtered_pool.values()])
 
         # The bounds below have been found to work heuristically.
         optimized_bet_amount = minimize_scalar(
@@ -513,7 +538,7 @@ class KellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_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}, force_simplified_calculation={self.force_simplified_calculation})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
@@ -529,40 +554,29 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
     def maximum_possible_bet_amount(self) -> USD:
         return self.max_position_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_position_amount + existing_position_total_amount
-
     def calculate_trades(
         self,
         existing_position: ExistingPosition | None,
         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 = BinaryKellyBettingStrategy(
+            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,
@@ -584,4 +598,118 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
+
+class CategoricalKellyBettingStrategy(BettingStrategy):
+    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,
+        force_simplified_calculation: bool = False,
+    ):
+        super().__init__(take_profit=take_profit)
+        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
+        self.force_simplified_calculation = force_simplified_calculation
+
+    @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 market.outcome_token_pool is None or self.force_simplified_calculation:
+            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(
+                outcome_pool_sizes=[
+                    market.outcome_token_pool[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,
+            )
+
+        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,
+                    best_kelly_bet.size,
+                    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}, force_simplified_calculation={self.force_simplified_calculation})"

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -2,7 +2,7 @@ import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
-    KellyBettingStrategy,
+    BinaryKellyBettingStrategy,
     TradeType,
 )
 from prediction_market_agent_tooling.gtypes import USD
@@ -93,7 +93,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = KellyBettingStrategy(max_position_amount=max_bond)
+        strategy = BinaryKellyBettingStrategy(max_position_amount=max_bond)
         required_trades = strategy.calculate_trades(
             existing_position=None,
             answer=self.get_job_answer(result),

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -601,7 +601,12 @@ class OmenBet(BaseModel):
             created_time=self.creation_datetime,
             market_question=self.title,
             market_id=self.fpmm.id,
-            market_outcome=self.fpmm.outcomes[self.outcomeIndex],
+            market_outcome=self.fpmm.outcomes[
+                check_not_none(
+                    self.fpmm.answer_index,
+                    "Should not be None if `is_resolved_with_valid_answer`.",
+                )
+            ],
             resolved_time=check_not_none(self.fpmm.finalized_datetime),
             profit=self.get_profit(),
         )

prediction_market_agent_tooling/markets/omen/omen.py

@@ -3,6 +3,7 @@ from collections import defaultdict
 from datetime import timedelta
 
 import tenacity
+from pydantic import BaseModel
 from tqdm import tqdm
 from web3 import Web3
 
@@ -1323,20 +1324,34 @@ def send_keeping_token_to_eoa_xdai(
         )
 
 
-def get_buy_outcome_token_amount(
+class BuyOutcomeResult(BaseModel):
+    outcome_tokens_received: OutcomeToken
+    new_pool_balances: list[OutcomeToken]
+
+
+def calculate_buy_outcome_token(
     investment_amount: CollateralToken,
     outcome_index: int,
     pool_balances: list[OutcomeToken],
     fees: MarketFees,
-) -> OutcomeToken:
+) -> BuyOutcomeResult:
     """
     Calculates the amount of outcome tokens received for a given investment
+    and returns the new pool balances after the purchase.
 
     Taken from https://github.com/gnosis/conditional-tokens-market-makers/blob/6814c0247c745680bb13298d4f0dd7f5b574d0db/contracts/FixedProductMarketMaker.sol#L264
     """
     if outcome_index >= len(pool_balances):
         raise ValueError("invalid outcome index")
 
+    new_pool_balances = pool_balances.copy()
+
+    if investment_amount == 0:
+        return BuyOutcomeResult(
+            outcome_tokens_received=OutcomeToken(0),
+            new_pool_balances=new_pool_balances,
+        )
+
     investment_amount_minus_fees = fees.get_after_fees(investment_amount)
     investment_amount_minus_fees_as_ot = OutcomeToken(
         investment_amount_minus_fees.value
@@ -1348,17 +1363,39 @@ def get_buy_outcome_token_amount(
     # Calculate the ending balance considering all other outcomes
     for i, pool_balance in enumerate(pool_balances):
         if i != outcome_index:
-            denominator = pool_balance + investment_amount_minus_fees_as_ot
+            new_pool_balances[i] = pool_balance + investment_amount_minus_fees_as_ot
             ending_outcome_balance = OutcomeToken(
-                (ending_outcome_balance * pool_balance / denominator)
+                (ending_outcome_balance * pool_balance / new_pool_balances[i])
             )
 
+    # Update the bought outcome's pool balance
+    new_pool_balances[outcome_index] = ending_outcome_balance
+
     if ending_outcome_balance <= 0:
         raise ValueError("must have non-zero balances")
 
-    result = (
+    outcome_tokens_received = (
         buy_token_pool_balance
         + investment_amount_minus_fees_as_ot
         - ending_outcome_balance
     )
-    return result
+
+    return BuyOutcomeResult(
+        outcome_tokens_received=outcome_tokens_received,
+        new_pool_balances=new_pool_balances,
+    )
+
+
+def get_buy_outcome_token_amount(
+    investment_amount: CollateralToken,
+    outcome_index: int,
+    pool_balances: list[OutcomeToken],
+    fees: MarketFees,
+) -> OutcomeToken:
+    result = calculate_buy_outcome_token(
+        investment_amount=investment_amount,
+        outcome_index=outcome_index,
+        pool_balances=pool_balances,
+        fees=fees,
+    )
+    return result.outcome_tokens_received

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -2,11 +2,15 @@ from cachetools import TTLCache, cached
 from pydantic import BaseModel
 from web3 import Web3
 
+from prediction_market_agent_tooling.deploy.constants import (
+    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
+)
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
     HexAddress,
     OutcomeStr,
+    OutcomeToken,
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
@@ -182,3 +186,67 @@ class PriceManager:
             normalized_prices[outcome] = new_price
 
         return normalized_prices
+
+    def build_initial_probs_from_pool(
+        self, model: SeerMarket, wrapped_tokens: list[ChecksumAddress]
+    ) -> tuple[dict[OutcomeStr, Probability], dict[OutcomeStr, OutcomeToken]]:
+        """
+        Builds a map of outcome to probability and outcome token pool.
+        """
+        probability_map = {}
+        outcome_token_pool = {}
+        wrapped_tokens_with_supply = [
+            (
+                token,
+                SeerSubgraphHandler().get_pool_by_token(
+                    token, model.collateral_token_contract_address_checksummed
+                ),
+            )
+            for token in wrapped_tokens
+        ]
+        wrapped_tokens_with_supply = [
+            (token, pool)
+            for token, pool in wrapped_tokens_with_supply
+            if pool is not None
+        ]
+
+        for token, pool in wrapped_tokens_with_supply:
+            if pool is None or pool.token1.id is None or pool.token0.id is None:
+                continue
+            if HexBytes(token) == HexBytes(pool.token1.id):
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken0)
+                    if pool.totalValueLockedToken0 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token0Price.value)
+            else:
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken1)
+                    if pool.totalValueLockedToken1 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token1Price.value)
+
+        for outcome in model.outcomes:
+            if outcome not in outcome_token_pool:
+                outcome_token_pool[outcome] = OutcomeToken(0)
+                logger.warning(
+                    f"Outcome {outcome} not found in outcome_token_pool for market {self.seer_market.url}."
+                )
+            if outcome not in probability_map:
+                if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower():
+                    raise PriceCalculationError(
+                        f"Couldn't get probability for {outcome} for market {self.seer_market.url}."
+                    )
+                else:
+                    probability_map[outcome] = Probability(0)
+        return probability_map, outcome_token_pool

prediction_market_agent_tooling/markets/seer/seer.py

@@ -411,10 +411,14 @@ class SeerAgentMarket(AgentMarket):
         must_have_prices: bool,
     ) -> t.Optional["SeerAgentMarket"]:
         price_manager = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
-
-        probability_map = {}
+        wrapped_tokens = [Web3.to_checksum_address(i) for i in model.wrapped_tokens]
         try:
-            probability_map = price_manager.build_probability_map()
+            (
+                probability_map,
+                outcome_token_pool,
+            ) = price_manager.build_initial_probs_from_pool(
+                model=model, wrapped_tokens=wrapped_tokens
+            )
         except PriceCalculationError as e:
             logger.info(
                 f"Error when calculating probabilities for market {model.id.hex()} - {e}"
@@ -437,9 +441,9 @@ class SeerAgentMarket(AgentMarket):
             condition_id=model.condition_id,
             url=model.url,
             close_time=model.close_time,
-            wrapped_tokens=[Web3.to_checksum_address(i) for i in model.wrapped_tokens],
+            wrapped_tokens=wrapped_tokens,
             fees=MarketFees.get_zero_fees(),
-            outcome_token_pool=None,
+            outcome_token_pool=outcome_token_pool,
             outcomes_supply=model.outcomes_supply,
             resolution=resolution,
             volume=None,
@@ -633,9 +637,9 @@ class SeerAgentMarket(AgentMarket):
                 amount_wei=amount_wei,
                 web3=web3,
             )
-            swap_pool_tx_hash = tx_receipt["transactionHash"].hex()
+            swap_pool_tx_hash = tx_receipt["transactionHash"]
             logger.info(f"TxHash is {swap_pool_tx_hash=}.")
-            return swap_pool_tx_hash
+            return swap_pool_tx_hash.hex()
 
     def place_bet(
         self,

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -352,6 +352,8 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             pools_field.token1.id,
             pools_field.token1.name,
             pools_field.token1.symbol,
+            pools_field.totalValueLockedToken0,
+            pools_field.totalValueLockedToken1,
         ]
         return fields
 

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -24,6 +24,8 @@ class SeerPool(BaseModel):
     token0Price: CollateralToken
     token1Price: CollateralToken
     sqrtPrice: int
+    totalValueLockedToken0: float
+    totalValueLockedToken1: float
 
 
 class NewMarketEvent(BaseModel):

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,6 +1,24 @@
-from prediction_market_agent_tooling.gtypes import CollateralToken, OutcomeToken
+from itertools import chain
+
+import numpy as np
+from scipy.optimize import minimize
+
+from prediction_market_agent_tooling.gtypes import (
+    CollateralToken,
+    OutcomeToken,
+    Probability,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
-from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
+from prediction_market_agent_tooling.markets.omen.omen import (
+    calculate_buy_outcome_token,
+)
+from prediction_market_agent_tooling.tools.betting_strategies.utils import (
+    BinaryKellyBet,
+    CategoricalKellyBet,
+)
+from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
 def check_is_valid_probability(probability: float) -> None:
@@ -13,7 +31,7 @@ def get_kelly_bet_simplified(
     market_p_yes: float,
     estimated_p_yes: float,
     confidence: float,
-) -> SimpleBet:
+) -> BinaryKellyBet:
     """
     Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
 
@@ -39,22 +57,24 @@ def get_kelly_bet_simplified(
     if estimated_p_yes > market_p_yes:
         bet_direction = True
         market_prob = market_p_yes
+        estimated_p = estimated_p_yes
     else:
         bet_direction = False
         market_prob = 1 - market_p_yes
+        estimated_p = 1 - estimated_p_yes
 
     # Handle the case where market_prob is 0
     if market_prob == 0:
         market_prob = 1e-10
 
-    edge = abs(estimated_p_yes - market_p_yes) * confidence
+    edge = abs(estimated_p - market_prob) * confidence
     odds = (1 / market_prob) - 1
     kelly_fraction = edge / odds
 
     # Ensure bet size is non-negative does not exceed the wallet balance
     bet_size = CollateralToken(min(kelly_fraction * max_bet.value, max_bet.value))
 
-    return SimpleBet(direction=bet_direction, size=bet_size)
+    return BinaryKellyBet(direction=bet_direction, size=bet_size)
 
 
 def get_kelly_bet_full(
@@ -64,7 +84,7 @@ def get_kelly_bet_full(
     confidence: float,
     max_bet: CollateralToken,
     fees: MarketFees,
-) -> SimpleBet:
+) -> BinaryKellyBet:
     """
     Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
 
@@ -98,7 +118,7 @@ def get_kelly_bet_full(
     check_is_valid_probability(confidence)
 
     if max_bet == 0:
-        return SimpleBet(size=CollateralToken(0), direction=True)
+        return BinaryKellyBet(size=CollateralToken(0), direction=True)
 
     x = yes_outcome_pool_size.value
     y = no_outcome_pool_size.value
@@ -144,7 +164,255 @@ def get_kelly_bet_full(
     kelly_bet_amount = numerator / denominator
 
     # Clip the bet size to max_bet to account for rounding errors.
-    return SimpleBet(
+    return BinaryKellyBet(
         direction=kelly_bet_amount > 0,
         size=CollateralToken(min(max_bet.value, abs(kelly_bet_amount))),
     )
+
+
+def get_kelly_bets_categorical_simplified(
+    market_probabilities: list[Probability],
+    estimated_probabilities: list[Probability],
+    confidence: float,
+    max_bet: CollateralToken,
+    fees: MarketFees,
+    allow_multiple_bets: bool,
+    allow_shorting: bool,
+    bet_precision: int = 6,
+) -> list[CategoricalKellyBet]:
+    """
+    Calculate Kelly bets for categorical markets using only market probabilities.
+    Returns a list of CategoricalKellyBet objects, one for each outcome.
+    Considers max_bet across all outcomes together.
+    Indicates both buying (long) and shorting (selling) by allowing negative bet sizes.
+    """
+    for p in chain(market_probabilities, estimated_probabilities, [confidence]):
+        check_is_valid_probability(p)
+    assert len(market_probabilities) == len(
+        estimated_probabilities
+    ), "Mismatch in number of outcomes"
+
+    f = 1 - fees.bet_proportion
+
+    total_kelly_fraction = 0.0
+    kelly_fractions = []
+
+    for i in range(len(market_probabilities)):
+        estimated_p = estimated_probabilities[i]
+        market_p = max(market_probabilities[i], 1e-10)
+
+        edge = (estimated_p - market_p) * confidence
+        odds = (1 / market_p) - 1
+        kelly_fraction = edge / odds * f
+
+        if not allow_shorting:
+            kelly_fraction = max(0, kelly_fraction)
+
+        kelly_fractions.append(kelly_fraction)
+        total_kelly_fraction += abs(kelly_fraction)
+
+    best_kelly_fraction_index = max(
+        range(len(kelly_fractions)), key=lambda i: abs(kelly_fractions[i])
+    )
+
+    bets = []
+    for i, kelly_fraction in enumerate(kelly_fractions):
+        if not allow_multiple_bets:
+            bet_size = (
+                kelly_fraction * max_bet.value if i == best_kelly_fraction_index else 0
+            )
+        elif allow_multiple_bets and total_kelly_fraction > 0:
+            bet_size = (kelly_fraction / total_kelly_fraction) * max_bet.value
+        else:
+            bet_size = 0.0
+        # Ensure bet_size is within [-max_bet.value, max_bet.value]
+        bet_size = max(-max_bet.value, min(bet_size, max_bet.value))
+        bets.append(
+            CategoricalKellyBet(
+                index=i, size=CollateralToken(round(bet_size, bet_precision))
+            )
+        )
+
+    return bets
+
+
+def get_kelly_bets_categorical_full(
+    outcome_pool_sizes: list[OutcomeToken],
+    estimated_probabilities: list[Probability],
+    confidence: float,
+    max_bet: CollateralToken,
+    fees: MarketFees,
+    allow_multiple_bets: bool,
+    allow_shorting: bool,
+    multicategorical: bool,
+    bet_precision: int = 6,
+) -> list[CategoricalKellyBet]:
+    """
+    Calculate Kelly bets for categorical markets using joint optimization over all outcomes,
+    splitting the max bet between all possible outcomes to maximize expected log utility.
+    Returns a list of CategoricalKellyBet objects, one for each outcome.
+    Handles both buying (long) and shorting (selling) by allowing negative bet sizes.
+    If the agent's probabilities are very close to the market's, returns all-zero bets.
+    multicategorical means that multiple outcomes could be selected as correct ones.
+    """
+    assert len(outcome_pool_sizes) == len(
+        estimated_probabilities
+    ), "Mismatch in number of outcomes"
+
+    market_probabilities = AgentMarket.compute_fpmm_probabilities(
+        [x.as_outcome_wei for x in outcome_pool_sizes]
+    )
+
+    for p in chain(market_probabilities, estimated_probabilities, [confidence]):
+        check_is_valid_probability(p)
+
+    n = len(outcome_pool_sizes)
+    max_bet_value = max_bet.value
+
+    if all(
+        abs(estimated_probabilities[i] - market_probabilities[i]) < 1e-3
+        for i in range(n)
+    ):
+        return [
+            CategoricalKellyBet(index=i, size=CollateralToken(0.0)) for i in range(n)
+        ]
+
+    def compute_payouts(bets: list[float]) -> list[float]:
+        payouts: list[float] = []
+        for i in range(n):
+            payout = 0.0
+            if bets[i] >= 0:
+                # If bet on i is positive, we buy outcome i
+                buy_result = calculate_buy_outcome_token(
+                    CollateralToken(bets[i]), i, outcome_pool_sizes, fees
+                )
+                payout += buy_result.outcome_tokens_received.value
+            else:
+                # If bet is negative, we "short" outcome i by buying all other outcomes
+                for j in range(n):
+                    if j == i:
+                        continue
+                    buy_result = calculate_buy_outcome_token(
+                        CollateralToken(abs(bets[i]) / (n - 1)),
+                        j,
+                        outcome_pool_sizes,
+                        fees,
+                    )
+                    payout += buy_result.outcome_tokens_received.value
+            payouts.append(payout)
+        return payouts
+
+    def adjust_prob(my_prob: float, market_prob: float) -> float:
+        # Based on the confidence, shrinks the predicted probability towards market's current probability.
+        return confidence * my_prob + (1 - confidence) * market_prob
+
+    # Use the simple version to estimate the initial bet vector.
+    x0 = np.array(
+        [
+            x.size.value  # Use simplified value as starting point
+            for x in get_kelly_bets_categorical_simplified(
+                market_probabilities=market_probabilities,
+                estimated_probabilities=estimated_probabilities,
+                confidence=confidence,
+                max_bet=max_bet,
+                fees=fees,
+                allow_multiple_bets=allow_multiple_bets,
+                allow_shorting=allow_shorting,
+                bet_precision=bet_precision,
+            )
+        ]
+    )
+
+    # Track the best solution found during optimization
+    best_solution_bets = None
+    best_solution_utility = float("-inf")
+
+    def neg_expected_log_utility(bets: list[float]) -> float:
+        """
+        Negative expected log utility for categorical Kelly betting.
+        This function is minimized to find the optimal bet allocation.
+        """
+        adj_probs = [
+            adjust_prob(estimated_probabilities[i], market_probabilities[i])
+            for i in range(n)
+        ]
+        payouts = compute_payouts(bets)
+
+        profits = [payout - abs(bet) for payout, bet in zip(payouts, bets)]
+
+        # Ensure profits are not too negative to avoid log(negative) or log(0)
+        # Use a small epsilon to prevent numerical instability
+        min_profit = -0.99  # Ensure 1 + profit > 0.01
+        profits = [max(profit, min_profit) for profit in profits]
+
+        # Expected log utility
+        expected_log_utility: float = sum(
+            adj_probs[i] * np.log(1 + profits[i]) for i in range(n)
+        )
+
+        # Track the best solution found so far
+        nonlocal best_solution_bets, best_solution_utility
+        if expected_log_utility > best_solution_utility:
+            best_solution_bets = np.array(bets)
+            best_solution_utility = expected_log_utility
+
+        # Return negative for minimization
+        return -expected_log_utility
+
+    constraints = [
+        # We can not bet more than `max_bet_value`
+        {
+            "type": "ineq",
+            "fun": lambda bets: max_bet_value - np.sum(np.abs(bets)),
+        },
+        # Each bet should not result in guaranteed loss
+        {
+            "type": "ineq",
+            "fun": lambda bets: [
+                payout
+                - (sum(abs(b) for b in bets) if not multicategorical else abs(bets[i]))
+                for i, payout in enumerate(compute_payouts(bets))
+            ],
+        },
+    ]
+
+    result = minimize(
+        neg_expected_log_utility,
+        x0,
+        method="SLSQP",
+        bounds=[
+            ((-max_bet_value if allow_shorting else 0), max_bet_value) for _ in range(n)
+        ],
+        constraints=constraints,
+        options={"maxiter": 10_000},
+    )
+
+    # This can sometimes happen, as long as it's occasional, it's should be fine to just use simplified version approximation.
+    if not result.success:
+        logger.warning(
+            f"Joint optimization failed: {result=} {x0=} {estimated_probabilities=} {confidence=} {market_probabilities=}"
+        )
+
+    # Use the best solution found during optimization, not just the final result (result.x).
+    # This is important because SLSQP may end on a worse solution due to numerical issues.
+    bet_vector = check_not_none(best_solution_bets) if result.success else x0
+
+    if not allow_multiple_bets:
+        # If we are not allowing multiple bets, we need to ensure only one bet is non-zero.
+        # We can do this by taking the maximum bet and setting all others to zero.
+        # We do this, instead of enforcing it in with additional constraint,
+        # because such hard constraint is problematic for the solver and results in almost always failing to optimize.
+        max_bet_index = np.argmax(np.abs(bet_vector))
+        max_bet_value = bet_vector[max_bet_index]
+
+        bet_vector = np.zeros_like(bet_vector)
+        bet_vector[max_bet_index] = max_bet_value
+
+    bets = [
+        CategoricalKellyBet(
+            index=i, size=CollateralToken(round(bet_vector[i], bet_precision))
+        )
+        for i in range(n)
+    ]
+
+    return bets

prediction_market_agent_tooling/tools/betting_strategies/utils.py

@@ -3,6 +3,11 @@ from pydantic import BaseModel
 from prediction_market_agent_tooling.gtypes import CollateralToken
 
 
-class SimpleBet(BaseModel):
+class BinaryKellyBet(BaseModel):
     direction: bool
     size: CollateralToken
+
+
+class CategoricalKellyBet(BaseModel):
+    index: int
+    size: CollateralToken

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -159,9 +159,6 @@ def get_trace_for_bet(
             not in WRAPPED_XDAI_CONTRACT_ADDRESS
         ):
             # TODO: We need to compute bet amount token in USD here, but at the time of bet placement!
-            logger.warning(
-                "This currently works only for WXDAI markets, because we need to compare against USD value."
-            )
             continue
         # Cannot use exact comparison due to gas fees
         if (

prediction_market_agent_tooling/tools/web3_utils.py

@@ -9,6 +9,7 @@ from eth_typing import URI
 from eth_utils.currency import MAX_WEI, MIN_WEI
 from pydantic.types import SecretStr
 from safe_eth.eth import EthereumClient
+from safe_eth.eth.ethereum_client import TxSpeed
 from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
@@ -269,6 +270,7 @@ def send_function_on_contract_tx_using_safe(
     tx_hash, tx = safe_tx.execute(
         from_private_key.get_secret_value(),
         tx_nonce=eoa_nonce,
+        eip1559_speed=TxSpeed.FAST,
     )
     receipt_tx = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)
     check_tx_receipt(receipt_tx)

{prediction_market_agent_tooling-0.67.4.dist-info → prediction_market_agent_tooling-0.68.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.67.4
+Version: 0.68.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.67.4.dist-info → prediction_market_agent_tooling-0.68.0.dist-info}/RECORD

@@ -27,9 +27,9 @@ prediction_market_agent_tooling/benchmark/utils.py,sha256=vmVTQLER8I7MM_bHFiavrN
 prediction_market_agent_tooling/chains.py,sha256=1qQstoqXMwqwM7k-KH7MjMz8Ei-D83KZByvDbCZpAxs,116
 prediction_market_agent_tooling/config.py,sha256=-kJfdDr-m0R-tGZ1KRI-hJJk0mXDt142CAlvwaJ2N2I,11778
 prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=VY23h324VKIVkevj1B1O-zL1eEp9AElmcfn6SwYDUSc,14246
-prediction_market_agent_tooling/deploy/agent.py,sha256=eFiOaBgaEcUuxUNnqRdXrWen3lEeyhzM9EzLY4NY07Q,30380
+prediction_market_agent_tooling/deploy/agent.py,sha256=N0lbYOfxv3QsmfyteT_xisEg8jEwFujUe1ZsM6WvtTY,30348
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=N3asdTTNA1i72Fpob1C7rffwDoV-ghnjrojPBxYq4Cw,21248
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=E_0P8MFBtm50OT9BCAy_ZSHW80skDPtSr-vgGZqNjDs,26584
 prediction_market_agent_tooling/deploy/constants.py,sha256=iobTlZpQD6_2UL9TfoElAnBEbqzIIAKZSsAoMCGhwmA,331
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=OsPboCFGiZKsvGyntGZHwdqPlLTthITkNF5rJFvGgU8,2582
@@ -38,7 +38,7 @@ prediction_market_agent_tooling/deploy/trade_interval.py,sha256=Xk9j45alQ_vrasGv
 prediction_market_agent_tooling/gtypes.py,sha256=bUIZfZIGvIi3aiZNu5rVE9kRevw8sfMa4bcze6QeBg8,6058
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=DoZ9dlvVhpNrnINiR1uy6YUOsuzI_L-avBt362y5xXM,2467
-prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=lCymxn0iH4xDmqouTP2LMORoGCiTzlK1_yqYtx1Njj4,5132
+prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=7hCy0iJD9oDmfZVlsDqOc4yCwDhUxvzjgtJzkbvFHu4,5144
 prediction_market_agent_tooling/loggers.py,sha256=o1HyvwtK1DbuC0YWQwJNqzXLLbSC41gNBkEUxiAziEg,5796
 prediction_market_agent_tooling/logprobs_parser.py,sha256=DBlBQtWX8_URXhzTU3YWIPa76Zx3QDHlx1ARqbgJsVI,5008
 prediction_market_agent_tooling/markets/agent_market.py,sha256=AvIJdeu4LAMtxAvQIRZktrbUYOczb3kditVVUGyF5EU,21289
@@ -58,8 +58,8 @@ prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=WjPt0MKe
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=kM0U0k90YfLE82ra53JAoCR9uIc9wm4B8l32hLw5imU,5312
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/cow_contracts.py,sha256=sFaW82u_haL4nze8fjTmnQsOuV0OecunQlAhh1OAw0w,1091
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=RsBYSbM4deA6Os4kQ3egH3HvwT80tQho6T1yyoATCMs,31103
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=9ynjn_UL48ach_GQt-TdcrY4ut1gCObkRCb8adePtHA,50700
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=K8BmRVAg4HBvtbrTGukq3OopegFQZKg8aD6eS5X9i4A,31271
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=5FJTpeY8LiIkIZQN1hcHGMVugrdycWW-3iIBjQqFnSY,51809
 prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=XtRk4vpxwUYkTndfjlcmghA-NOIneV8zdHFdyI7tHhM,487
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=27-HRngTqfk_wgvttB3GeVHhy_O2YZcz9izo9OufOI0,29991
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=D-ubf_LumHs_c5rBAAntQ8wGKprtO2V1JZeedmChNIE,11035
@@ -72,18 +72,18 @@ prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.p
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=A_diygWKYyp4WHbxAlAVAuC0S0ZqbEKE80wxL6mxHKQ,1275
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=d8J-hgUmGGhhv41u816O7xvBsi9m-TginULvj82hf_g,6681
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
-prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=PZf6-6zc6DvH1u65wHWyeD55lgG-UGnN_xzBMvrb3ug,7120
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=i_a7VtAogk3NvLWCgLjF9EqK-C1AChuEaDpl06fsJYc,28861
+prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=kL9yNM-4JDmQ3MHGJQCGC508gVNsf89JkajjUXj_sko,10001
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=6oiPoa8qd6WF4_G0uVckS97gmC0YP5kv-iiw0vKna_s,29034
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=JqfQNFSRWREPw6pQGpJoh-No5ZlKwmTiALJiAYEuvW8,5516
-prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=Ta4wb-P42Q0_GJfAtHkTjRUlknxwgHmjwdUqrgfHi0s,17133
-prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=7szvK5we3LF38UthWHg5V3LD6C137O5_WMEcP9Dwl8w,1763
+prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=9a1LAoSDg2mUE4-U0rq2KUSRVAn4A0GbP8b0fr5Mmbg,17229
+prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=VREm8bR-gPY06ODFJsaiSMinYgN64q5dC6DFckMY6oA,1831
 prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=k_sCEJZLroVDjOVkZ084VKJGNODLGjBGezhsWEZvlH4,3528
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/_generic_value.py,sha256=pD_PI13lpPp1gFoljHwa_Lzlp-u2pu0m-Z7LcxwDM2U,10618
 prediction_market_agent_tooling/tools/balances.py,sha256=Osab21btfJDw2Y-jT_TV-KHGrseCRxcsYeW6WcOMB8E,1050
-prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=duylr4I06L0-Vpeomatzt3_dxs6bijt41TJPwm1YjRg,4873
+prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=C1rWbj88gPsBYVpKSAoJgZ1iVfOL2YJ5tXnvqIxmMKk,14716
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
-prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=68zFWUj43GUaSpOPowVrbI-t6qbCE29RsVHNzCVuJ9U,175
+prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=MpS3FOMn0C7nbmbQRUT9QwSh3UzzsgGczP91iSMr9wo,261
 prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=rZIGhgijquwwPtp_qncSAPR1SDF2XxIVZL1ir0fgzWw,12127
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjqeAebu5T7ftRnlkxiL02IC-MxCfDB80x7w,1506
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
@@ -104,7 +104,7 @@ prediction_market_agent_tooling/tools/ipfs/ipfs_handler.py,sha256=CTTMfTvs_8PH4k
 prediction_market_agent_tooling/tools/is_invalid.py,sha256=ArYgPqZApRwIPXwBmTdz7d-7ynP856GLaeCcIl9tV08,5334
 prediction_market_agent_tooling/tools/is_predictable.py,sha256=RNwVH31qpHtg2UWdeMZoFOpMsKgE-aKmcc3Uj6_dK-A,6909
 prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_AeDVhRzLMaQLxH3kxDu3L8,1153
-prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=7cyGcin2-fhhp_wxAGA_uzpEUUbI8lTud3MJndjYnoM,6795
+prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=D_AzGvEg-YXc0xhYGALGPnmtQqeNyNxkP0SWMCRQW3M,6644
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/omen/sell_positions.py,sha256=Q4oI7_QI3AkyxlH10VvxDahYVrphQa1Wnox2Ce_cf_k,2452
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
@@ -128,9 +128,9 @@ prediction_market_agent_tooling/tools/tokens/token_utils.py,sha256=fhs-FH9m9IbzG
 prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMDAfztcq0Nv2ascSrCquF1f8,3115
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=mbOGoWKalNIm7M2K51TEPGwU9oVp1Z6SPsFaBgbn6ws,7397
-prediction_market_agent_tooling/tools/web3_utils.py,sha256=0r26snqCXGdLKCWA8jpe7DV8x2NPYWZwOy4oyKyDCYk,12615
-prediction_market_agent_tooling-0.67.4.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.67.4.dist-info/METADATA,sha256=jEFepq9cqrzVIqjTyZODBnvEJ9jJGREtzIqKd05YrLE,8770
-prediction_market_agent_tooling-0.67.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.67.4.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.67.4.dist-info/RECORD,,
+prediction_market_agent_tooling/tools/web3_utils.py,sha256=dBRlDcq532fkq6mRrvDlafx8u0pKdbgkfbDdCMGqhR4,12700
+prediction_market_agent_tooling-0.68.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.68.0.dist-info/METADATA,sha256=ic8wMeKZRZRaQPKHVW4wkzZ0FKIqBMjYqGHTVRCdcuE,8770
+prediction_market_agent_tooling-0.68.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.68.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.68.0.dist-info/RECORD,,