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

prediction_market_agent_tooling/markets/polymarket/data_models.py

@@ -59,16 +59,18 @@ class PolymarketGammaResponseDataItem(BaseModel):
     id: str
     slug: str
     volume: float | None = None
-    startDate: DatetimeUTC
+    startDate: DatetimeUTC | None = None
     endDate: DatetimeUTC | None = None
     liquidity: float | None = None
     liquidityClob: float | None = None
     title: str
-    description: str
+    description: str | None = None
     archived: bool
     closed: bool
     active: bool
-    markets: list[PolymarketGammaMarket]
+    markets: list[
+        PolymarketGammaMarket
+    ] | None = None  # Some Polymarket markets have missing markets field. We skip these markets manually when retrieving.
     tags: list[PolymarketGammaTag]
 
     @property

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -7,6 +7,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     Probability,
 )
+from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     ConditionalFilterType,
@@ -31,6 +32,7 @@ from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_hand
     PolymarketSubgraphHandler,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
 class PolymarketAgentMarket(AgentMarket):
@@ -69,9 +71,11 @@ class PolymarketAgentMarket(AgentMarket):
         ]
         # For a binary market, there should be exactly one payout numerator greater than 0.
         if len(payout_numerator_indices_gt_0) != 1:
-            raise ValueError(
-                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators}"
+            # These cases involve multi-categorical resolution (to be implemented https://github.com/gnosis/prediction-market-agent-tooling/issues/770)
+            logger.warning(
+                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators} for condition_id {condition_id.hex()}"
             )
+            return Resolution(outcome=None, invalid=False)
 
         # we return the only payout numerator greater than 0 as resolution
         resolved_outcome = outcomes[payout_numerator_indices_gt_0[0]]
@@ -83,16 +87,16 @@ class PolymarketAgentMarket(AgentMarket):
         condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
     ) -> "PolymarketAgentMarket":
         # If len(model.markets) > 0, this denotes a categorical market.
-
-        outcomes = model.markets[0].outcomes_list
-        outcome_prices = model.markets[0].outcome_prices
+        markets = check_not_none(model.markets)
+        outcomes = markets[0].outcomes_list
+        outcome_prices = markets[0].outcome_prices
         if not outcome_prices:
             # We give random prices
             outcome_prices = [0.5, 0.5]
         probabilities = {o: Probability(op) for o, op in zip(outcomes, outcome_prices)}
 
         resolution = PolymarketAgentMarket.build_resolution_from_condition(
-            condition_id=model.markets[0].conditionId,
+            condition_id=markets[0].conditionId,
             condition_model_dict=condition_model_dict,
             outcomes=outcomes,
         )
@@ -164,7 +168,11 @@ class PolymarketAgentMarket(AgentMarket):
         )
 
         condition_models = PolymarketSubgraphHandler().get_conditions(
-            condition_ids=[market.markets[0].conditionId for market in markets]
+            condition_ids=[
+                market.markets[0].conditionId
+                for market in markets
+                if market.markets is not None
+            ]
         )
         condition_models_dict = {c.id: c for c in condition_models}
 

prediction_market_agent_tooling/markets/seer/seer.py

@@ -2,6 +2,7 @@ import asyncio
 import typing as t
 from datetime import timedelta
 
+import cachetools
 from cowdao_cowpy.common.api.errors import UnexpectedResponseError
 from eth_typing import ChecksumAddress
 from web3 import Web3
@@ -99,6 +100,11 @@ from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
 SEER_TINY_BET_AMOUNT = USD(0.1)
 
 
+SHARED_CACHE: cachetools.TTLCache[t.Hashable, t.Any] = cachetools.TTLCache(
+    maxsize=256, ttl=10 * 60
+)
+
+
 class SeerAgentMarket(AgentMarket):
     wrapped_tokens: list[ChecksumAddress]
     creator: HexAddress
@@ -541,6 +547,7 @@ class SeerAgentMarket(AgentMarket):
         liquidity = self.get_liquidity_for_outcome(outcome)
         return liquidity > self.minimum_market_liquidity_required
 
+    @cachetools.cached(cache=SHARED_CACHE, key=lambda self: f"has_liquidity_{self.id}")
     def has_liquidity(self) -> bool:
         # We define a market as having liquidity if it has liquidity for all outcomes except for the invalid (index -1)
         return all(
@@ -594,7 +601,7 @@ class SeerAgentMarket(AgentMarket):
                     f"Expected exactly 1 trade from {order_metadata=}, but got {len(trades)=}."
                 )
             cow_tx_hash = trades[0].txHash
-            logger.info(f"TxHash for {order_metadata.uid.root=} is {cow_tx_hash=}.")
+            logger.info(f"TxHash is {cow_tx_hash=} for {order_metadata.uid.root=}.")
             return cow_tx_hash.hex()
 
         except (
@@ -626,7 +633,9 @@ class SeerAgentMarket(AgentMarket):
                 amount_wei=amount_wei,
                 web3=web3,
             )
-            return tx_receipt["transactionHash"].hex()
+            swap_pool_tx_hash = tx_receipt["transactionHash"].hex()
+            logger.info(f"TxHash is {swap_pool_tx_hash=}.")
+            return swap_pool_tx_hash
 
     def place_bet(
         self,

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -71,7 +71,10 @@ class SwapPoolHandler:
         price_outcome_token = PriceManager.build(
             HexBytes(HexStr(self.market_id))
         ).get_token_price_from_pools(token=outcome_token)
-        if not price_outcome_token:
+        if (
+            not price_outcome_token
+            or not price_outcome_token.priceOfCollateralInAskingToken
+        ):
             raise ValueError(
                 f"Could not find price for {outcome_token=} and {self.collateral_token_address}"
             )

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/hexbytes_custom.py

@@ -60,6 +60,15 @@ class HexBytes(HexBytesBase, BaseHex):
         value = hex_str[2:] if hex_str.startswith("0x") else hex_str
         return super().fromhex(value)
 
+    def hex(
+        self,
+        sep: t.Union[str, bytes] | None = None,
+        bytes_per_sep: t.SupportsIndex = 1,
+    ) -> str:
+        """We enforce a 0x prefix."""
+        x = super().hex(sep, bytes_per_sep)  # type: ignore[arg-type]
+        return x if x.startswith("0x") else "0x" + x
+
     @classmethod
     def __eth_pydantic_validate__(
         cls, value: t.Any, info: ValidationInfo | None = None

prediction_market_agent_tooling/tools/httpx_cached_client.py

@@ -1,15 +1,17 @@
+from datetime import timedelta
+
 import hishel
 import httpx
 
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 
-ONE_DAY_IN_SECONDS = 60 * 60 * 24
+ONE_DAY = timedelta(days=1)
 
 
 class HttpxCachedClient(metaclass=SingletonMeta):
-    def __init__(self, ttl: int = ONE_DAY_IN_SECONDS) -> None:
+    def __init__(self, ttl: timedelta = ONE_DAY) -> None:
         storage = hishel.FileStorage(
-            ttl=ttl,
+            ttl=ttl.total_seconds(),
             check_ttl_every=60,
         )
         controller = hishel.Controller(force_cache=True)

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -68,6 +68,7 @@ def get_traces_for_agent(
     client: Langfuse,
     to_timestamp: DatetimeUTC | None = None,
     tags: str | list[str] | None = None,
+    limit: int | None = None,
 ) -> list[TraceWithDetails]:
     """
     Fetch agent traces using pagination
@@ -98,6 +99,9 @@ def get_traces_for_agent(
         if has_output:
             agent_traces = [t for t in agent_traces if t.output is not None]
         all_agent_traces.extend(agent_traces)
+        if limit is not None and len(all_agent_traces) >= limit:
+            all_agent_traces = all_agent_traces[:limit]
+            break
     return all_agent_traces
 
 
@@ -155,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/singleton.py

@@ -8,16 +8,21 @@ class SingletonMeta(type, t.Generic[_T]):
     The Singleton class can be implemented in different ways in Python. Some
     possible methods include: base class, decorator, metaclass. We will use the
     metaclass because it is best suited for this purpose.
+
+    This version creates a unique instance for each unique set of __init__ arguments.
     """
 
-    _instances: dict[t.Any, _T] = {}
+    _instances: dict[
+        tuple[t.Any, tuple[t.Any, ...], tuple[tuple[str, t.Any], ...]], _T
+    ] = {}
 
     def __call__(self, *args: t.Any, **kwargs: t.Any) -> _T:
         """
-        Possible changes to the value of the `__init__` argument do not affect
-        the returned instance.
+        Different __init__ arguments will result in different instances.
         """
-        if self not in self._instances:
+        # Create a key based on the class, args, and kwargs (sorted for consistency)
+        key = (self, args, tuple(sorted(kwargs.items())))
+        if key not in self._instances:
             instance = super().__call__(*args, **kwargs)
-            self._instances[self] = instance
-        return self._instances[self]
+            self._instances[key] = instance
+        return self._instances[key]

{prediction_market_agent_tooling-0.67.3.dist-info → prediction_market_agent_tooling-0.67.4.dev992.dist-info}/METADATA

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