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

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -1,29 +1,68 @@
 from pydantic import BaseModel, ConfigDict, Field
+from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
 from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
     CollateralToken,
     HexAddress,
     HexBytes,
     OutcomeStr,
+    OutcomeToken,
+    Wei,
 )
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
-class SeerToken(BaseModel):
+class SwaprToken(BaseModel):
     id: HexBytes
     name: str
     symbol: str
 
+    @property
+    def address(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.id.hex())
 
-class SeerPool(BaseModel):
+
+class SwaprPool(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
     id: HexBytes
     liquidity: int
-    token0: SeerToken
-    token1: SeerToken
+    token0: SwaprToken
+    token1: SwaprToken
     token0Price: CollateralToken
     token1Price: CollateralToken
     sqrtPrice: int
+    totalValueLockedToken0: float
+    totalValueLockedToken1: float
+
+
+class SwaprSwap(BaseModel):
+    id: str  # It's like "0x73afd8f096096552d72a0b40ea66d2076be136c6a531e2f6b190d151a750271e#32" (note the #32) # web3-private-key-ok
+    recipient: HexAddress
+    sender: HexAddress
+    price: Wei
+    amount0: CollateralToken
+    amount1: CollateralToken
+    token0: SwaprToken
+    token1: SwaprToken
+    timestamp: int
+
+    @property
+    def timestamp_utc(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.timestamp)
+
+    @property
+    def added_to_pool(self) -> CollateralToken:
+        return self.amount0 if self.amount0 > 0 else self.amount1
+
+    @property
+    def withdrawn_from_pool(self) -> OutcomeToken:
+        return (
+            OutcomeToken(abs(self.amount0).value)
+            if self.amount0 < 0
+            else OutcomeToken(abs(self.amount1).value)
+        )
 
 
 class NewMarketEvent(BaseModel):
@@ -58,7 +97,3 @@ class CreateCategoricalMarketsParams(BaseModel):
     )  # typed as int for later .model_dump() usage (if using Wei, other keys also exported)
     opening_time: int = Field(..., alias="openingTime")
     token_names: list[str] = Field(..., alias="tokenNames")
-
-
-class SeerParentMarket(BaseModel):
-    id: HexBytes

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -0,0 +1,80 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    TxReceipt,
+    Wei,
+)
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    ExactInputSingleParams,
+)
+from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    SwaprRouterContract,
+)
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+
+
+class SwapPoolHandler:
+    def __init__(
+        self,
+        api_keys: APIKeys,
+        market_id: str,
+        collateral_token_address: ChecksumAddress,
+        seer_subgraph: SeerSubgraphHandler | None = None,
+    ):
+        self.api_keys = api_keys
+        self.market_id = market_id
+        self.collateral_token_address = collateral_token_address
+        self.seer_subgraph = seer_subgraph or SeerSubgraphHandler()
+
+    def _calculate_amount_out_minimum(
+        self,
+        amount_in: Wei,
+        token_in: ChecksumAddress,
+        token_out: ChecksumAddress,
+        buffer_pct: float = 0.05,
+    ) -> Wei:
+        price_manager = PriceManager.build(HexBytes(HexStr(self.market_id)))
+        value = price_manager.get_swapr_input_quote(
+            input_amount=amount_in, input_token=token_in, output_token=token_out
+        )
+        return value * (1 - buffer_pct)
+
+    def buy_or_sell_outcome_token(
+        self,
+        amount_in: Wei,
+        token_in: ChecksumAddress,
+        token_out: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        """Buys/sells outcome_tokens in exchange for collateral tokens"""
+        if self.collateral_token_address not in [token_in, token_out]:
+            raise ValueError(
+                f"trading outcome_token for a token different than collateral_token {self.collateral_token_address} is not supported. {token_in=} {token_out=}"
+            )
+
+        amount_out_minimum = self._calculate_amount_out_minimum(
+            amount_in=amount_in,
+            token_in=token_in,
+            token_out=token_out,
+        )
+
+        p = ExactInputSingleParams(
+            token_in=token_in,
+            token_out=token_out,
+            recipient=self.api_keys.bet_from_address,
+            amount_in=amount_in,
+            amount_out_minimum=amount_out_minimum,
+        )
+
+        tx_receipt = SwaprRouterContract().exact_input_single(
+            api_keys=self.api_keys, params=p, web3=web3
+        )
+
+        return tx_receipt

prediction_market_agent_tooling/tools/_generic_value.py

@@ -60,6 +60,10 @@ class _GenericValue(
         cls.parser = parser
 
     def __init__(self, value: InputValueType) -> None:
+        if isinstance(value, str) and (
+            value.startswith("0x") or value.startswith("-0x")
+        ):
+            value = int(value, 16)  # type: ignore[assignment] # mypy is confused but if `parser` below can process it, it should be fine, and if it cannot, it should be catched by mypy earlier than here.
         self.value: InternalValueType = self.parser(value)
         super().__init__({"value": self.value, "type": self.__class__.__name__})
 
@@ -187,9 +191,11 @@ class _GenericValue(
             raise TypeError("Cannot compare different types")
         return bool(self.value >= other.value)
 
-    def __eq__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:  # type: ignore
+    def __eq__(self: GenericValueType, other: GenericValueType | t.Literal[0] | None) -> bool:  # type: ignore
         if other == 0:
             other = self.zero()
+        if other is None:
+            return False
         if not isinstance(other, _GenericValue):
             raise TypeError("Cannot compare different types")
         if type(self) is not type(other):
@@ -239,7 +245,7 @@ class _GenericValue(
         cls, source_type: t.Any, handler: GetCoreSchemaHandler
     ) -> CoreSchema:
         # Support for Pydantic usage.
-        dt_schema = handler(str | int | float | dict)
+        dt_schema = handler(cls.parser | str | dict)
         return core_schema.no_info_after_validator_function(
             lambda x: cls(x["value"] if isinstance(x, dict) else x),
             dt_schema,

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,6 +1,27 @@
-from prediction_market_agent_tooling.gtypes import CollateralToken, OutcomeToken
+from enum import Enum
+from itertools import chain
+from typing import Callable
+
+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.market_fees import MarketFees
-from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
+from prediction_market_agent_tooling.tools.betting_strategies.utils import (
+    BinaryKellyBet,
+    CategoricalKellyBet,
+)
+from prediction_market_agent_tooling.tools.utils import check_not_none
+
+
+class KellyType(str, Enum):
+    SIMPLE = "simple"
+    FULL = "full"
 
 
 def check_is_valid_probability(probability: float) -> None:
@@ -13,7 +34,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 +60,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 +87,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 +121,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 +167,247 @@ 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(
+    market_probabilities: list[Probability],
+    estimated_probabilities: list[Probability],
+    confidence: float,
+    max_bet: CollateralToken,
+    fees: MarketFees,
+    allow_multiple_bets: bool,
+    allow_shorting: bool,
+    multicategorical: bool,
+    # investment amount, outcome index --> received outcome tokens
+    get_buy_token_amount: Callable[[CollateralToken, int], OutcomeToken],
+    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(market_probabilities) == len(
+        estimated_probabilities
+    ), "Mismatch in number of outcomes"
+    for p in chain(market_probabilities, estimated_probabilities, [confidence]):
+        check_is_valid_probability(p)
+
+    n = len(market_probabilities)
+    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 = get_buy_token_amount(CollateralToken(bets[i]), i)
+                payout += buy_result.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 = get_buy_token_amount(
+                        CollateralToken(abs(bets[i]) / (n - 1)), j
+                    )
+                    payout += buy_result.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