prediction-market-agent-tooling 0.68.1__py3-none-any.whl → 0.69.0__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -630,7 +630,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         api_keys = APIKeys()
 
         # Get the strategy to know how much it will bet.
-        strategy = self.get_betting_strategy(market)
+        strategy = self.get_betting_strategy_supported(market)
         # Have a little bandwidth after the bet.
         min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
 
@@ -658,13 +658,24 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         total_amount = self.get_total_amount_to_bet(market)
         return CategoricalMaxAccuracyBettingStrategy(max_position_amount=total_amount)
 
+    def get_betting_strategy_supported(self, market: AgentMarket) -> BettingStrategy:
+        """
+        Use this class internally to assert that the configured betting strategy works with the given market.
+        """
+        strategy = self.get_betting_strategy(market=market)
+        if not strategy.is_market_supported(market):
+            raise ValueError(
+                f"Market {market.url} is not supported by the strategy {strategy}."
+            )
+        return strategy
+
     def build_trades(
         self,
         market: AgentMarket,
         answer: CategoricalProbabilisticAnswer,
         existing_position: ExistingPosition | None,
     ) -> list[Trade]:
-        strategy = self.get_betting_strategy(market=market)
+        strategy = self.get_betting_strategy_supported(market=market)
         trades = strategy.calculate_trades(existing_position, answer, market)
         return trades
 

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -16,7 +16,11 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket, MarketFees
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    MarketFees,
+    QuestionType,
+)
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     ExistingPosition,
@@ -24,10 +28,12 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
+from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import (
     get_buy_outcome_token_amount,
 )
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
+    KellyType,
     get_kelly_bet_full,
     get_kelly_bet_simplified,
     get_kelly_bets_categorical_full,
@@ -45,9 +51,21 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    supported_question_types: set[QuestionType]
+    supported_market_types: set[MarketType]
+
     def __init__(self, take_profit: bool = True) -> None:
         self.take_profit = take_profit
 
+    def is_market_supported(self, market: AgentMarket) -> bool:
+        if market.question_type not in self.supported_question_types:
+            return False
+
+        if MarketType.from_market(market) not in self.supported_market_types:
+            return False
+
+        return True
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -251,6 +269,13 @@ class BettingStrategy(ABC):
 
 
 class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+    supported_question_types = {
+        QuestionType.BINARY,
+        QuestionType.CATEGORICAL,
+        QuestionType.SCALAR,
+    }
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(self, max_position_amount: USD, take_profit: bool = True):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
@@ -362,18 +387,20 @@ class MaxExpectedValueBettingStrategy(CategoricalMaxAccuracyBettingStrategy):
         return f"MaxExpectedValueBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class BinaryKellyBettingStrategy(BettingStrategy):
+class _BinaryKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None = None,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -396,7 +423,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             else override_p_yes
         )
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bet = get_kelly_bet_simplified(
                 max_bet=market.get_usd_in_token(self.max_position_amount),
                 market_p_yes=market.probability_for_market_outcome(direction),
@@ -447,7 +474,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             # Adjust amount
             max_price_impact_bet_amount = self.calculate_bet_amount_for_price_impact(
                 market,
-                kelly_bet.size,
                 direction=direction,
                 max_price_impact=self.max_price_impact,
             )
@@ -492,7 +518,6 @@ class BinaryKellyBettingStrategy(BettingStrategy):
     @staticmethod
     def calculate_bet_amount_for_price_impact(
         market: AgentMarket,
-        kelly_bet_size: CollateralToken,
         direction: OutcomeStr,
         max_price_impact: float,
     ) -> CollateralToken:
@@ -501,7 +526,7 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
             price_impact = (
-                BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
+                _BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
                     outcome_idx=outcome_idx,
                     bet_amount=CollateralToken(bet_amount_collateral),
                     pool_balances=pool_balances,
@@ -512,20 +537,13 @@ class BinaryKellyBettingStrategy(BettingStrategy):
             return abs(price_impact - max_price_impact)
 
         if not market.outcome_token_pool:
-            logger.warning(
+            raise ValueError(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet_size
-
-        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()]
+        pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
         # stay float for compatibility with `minimize_scalar`
-        total_pool_balance = sum([i.value for i in filtered_pool.values()])
+        total_pool_balance = sum([i.value for i in market.outcome_token_pool.values()])
 
         # The bounds below have been found to work heuristically.
         optimized_bet_amount = minimize_scalar(
@@ -538,10 +556,47 @@ class BinaryKellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        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})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit})"
+
+
+class SimpleBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            take_profit=take_profit,
+        )
+
+
+class FullBinaryKellyBettingStrategy(_BinaryKellyBettingStrategy):
+    # Supports only OMEN because it uses closed-form formula derived from a binary FPMM.
+    supported_market_types = {MarketType.OMEN}
+
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            take_profit=take_profit,
+        )
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY}
+    supported_market_types = {MarketType.OMEN}
+
     def __init__(
         self,
         max_position_amount: USD,
@@ -573,7 +628,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         # We ignore the direction nudge given by Kelly, hence we assume we have a perfect prediction.
         estimated_p_yes = 1.0
 
-        kelly_bet = BinaryKellyBettingStrategy(
+        kelly_bet = FullBinaryKellyBettingStrategy(
             max_position_amount=self.max_position_amount
         ).get_kelly_bet(
             market=market,
@@ -601,24 +656,27 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
 
 
-class CategoricalKellyBettingStrategy(BettingStrategy):
+class _CategoricalKellyBettingStrategy(BettingStrategy):
+    supported_question_types = {QuestionType.BINARY, QuestionType.CATEGORICAL}
+    supported_market_types = {x for x in MarketType if x.is_trading_market}
+
     def __init__(
         self,
+        kelly_type: KellyType,
         max_position_amount: USD,
         max_price_impact: float | None,
         allow_multiple_bets: bool,
         allow_shorting: bool,
         multicategorical: bool,
         take_profit: bool = True,
-        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
+        self.kelly_type = kelly_type
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
         self.allow_multiple_bets = allow_multiple_bets
         self.allow_shorting = allow_shorting
         self.multicategorical = multicategorical
-        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
@@ -632,7 +690,7 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
     ) -> list[CategoricalKellyBet]:
         max_bet = market.get_usd_in_token(max_bet_amount)
 
-        if market.outcome_token_pool is None or self.force_simplified_calculation:
+        if self.kelly_type == KellyType.SIMPLE:
             kelly_bets = get_kelly_bets_categorical_simplified(
                 market_probabilities=[market.probabilities[o] for o in market.outcomes],
                 estimated_probabilities=[
@@ -647,8 +705,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
 
         else:
             kelly_bets = get_kelly_bets_categorical_full(
-                outcome_pool_sizes=[
-                    market.outcome_token_pool[o] for o in market.outcomes
+                market_probabilities=[
+                    market.probability_for_market_outcome(o) for o in market.outcomes
                 ],
                 estimated_probabilities=[
                     answer.probability_for_market_outcome(o) for o in market.outcomes
@@ -659,6 +717,11 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
                 allow_multiple_bets=self.allow_multiple_bets,
                 allow_shorting=self.allow_shorting,
                 multicategorical=self.multicategorical,
+                get_buy_token_amount=lambda bet_amount, outcome_index: check_not_none(
+                    market.get_buy_token_amount(
+                        bet_amount, market.get_outcome_str(outcome_index)
+                    )
+                ),
             )
 
         return kelly_bets
@@ -689,9 +752,8 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         if self.max_price_impact:
             # Adjust amount
             max_price_impact_bet_amount = (
-                BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
+                _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,
                 )
@@ -712,4 +774,45 @@ class CategoricalKellyBettingStrategy(BettingStrategy):
         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})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit})"
+
+
+class SimpleCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.SIMPLE,
+            max_position_amount=max_position_amount,
+            max_price_impact=None,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )
+
+
+class FullCategoricalKellyBettingStrategy(_CategoricalKellyBettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+    ):
+        super().__init__(
+            kelly_type=KellyType.FULL,
+            max_position_amount=max_position_amount,
+            max_price_impact=max_price_impact,
+            allow_multiple_bets=allow_multiple_bets,
+            allow_shorting=allow_shorting,
+            multicategorical=multicategorical,
+            take_profit=take_profit,
+        )

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,10 +1,6 @@
 import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.deploy.betting_strategy import (
-    BinaryKellyBettingStrategy,
-    TradeType,
-)
 from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import ProcessedMarket
@@ -92,20 +88,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return processed_traded_market
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
+        raise NotImplementedError("TODO: Refactor to avoid circular imports.")
         # 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 = BinaryKellyBettingStrategy(max_position_amount=max_bond)
-        required_trades = strategy.calculate_trades(
-            existing_position=None,
-            answer=self.get_job_answer(result),
-            market=self,
-        )
-        assert (
-            len(required_trades) == 1
-        ), f"Shouldn't process same job twice: {required_trades}"
-        trade = required_trades[0]
-        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-        assert trade.outcome, "Should buy only YES on job markets."
-        return required_trades[0]
+        # strategy = FullBinaryKellyBettingStrategy(max_position_amount=max_bond)
+        # required_trades = strategy.calculate_trades(
+        #     existing_position=None,
+        #     answer=self.get_job_answer(result),
+        #     market=self,
+        # )
+        # assert (
+        #     len(required_trades) == 1
+        # ), f"Shouldn't process same job twice: {required_trades}"
+        # trade = required_trades[0]
+        # assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        # assert trade.outcome, "Should buy only YES on job markets."
+        # return required_trades[0]
 
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":

prediction_market_agent_tooling/markets/agent_market.py

@@ -188,6 +188,17 @@ class AgentMarket(BaseModel):
             f"Could not find probability for market outcome {market_outcome}"
         )
 
+    @property
+    def question_type(self) -> QuestionType:
+        if self.is_binary:
+            return QuestionType.BINARY
+
+        elif self.is_scalar:
+            return QuestionType.SCALAR
+
+        else:
+            return QuestionType.CATEGORICAL
+
     @property
     def is_binary(self) -> bool:
         # 3 outcomes can also be binary if 3rd outcome is invalid (Seer)

prediction_market_agent_tooling/markets/markets.py

@@ -31,6 +31,10 @@ class MarketType(str, Enum):
     METACULUS = "metaculus"
     SEER = "seer"
 
+    @staticmethod
+    def from_market(market: AgentMarket) -> "MarketType":
+        return AGENT_MARKET_TO_MARKET_TYPE[type(market)]
+
     @property
     def market_class(self) -> type[AgentMarket]:
         if self not in MARKET_TYPE_TO_AGENT_MARKET:
@@ -43,6 +47,15 @@ class MarketType(str, Enum):
             raise ValueError(f"Unknown market type: {self}")
         return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
 
+    @property
+    def is_trading_market(self) -> bool:
+        return self in [
+            MarketType.OMEN,
+            MarketType.POLYMARKET,
+            MarketType.SEER,
+            MarketType.MANIFOLD,
+        ]
+
     @property
     def is_blockchain_market(self) -> bool:
         return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
@@ -56,6 +69,9 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.SEER: SeerAgentMarket,
 }
 
+AGENT_MARKET_TO_MARKET_TYPE: dict[type[AgentMarket], MarketType] = {
+    v: k for k, v in MARKET_TYPE_TO_AGENT_MARKET.items()
+}
 
 JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
     MarketType.OMEN: OmenJobAgentMarket,

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,5 +1,6 @@
 import typing as t
 from datetime import timedelta
+from enum import Enum
 from typing import Annotated
 from urllib.parse import urljoin
 
@@ -139,11 +140,6 @@ class SeerMarket(BaseModel):
             for token in self.wrapped_tokens
         ]
 
-    @property
-    def is_binary(self) -> bool:
-        # 3 because Seer has also third, `Invalid` outcome.
-        return len(self.outcomes) == 3
-
     @property
     def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
         return Web3.to_checksum_address(self.collateral_token)
@@ -188,3 +184,42 @@ class ExactInputSingleParams(BaseModel):
     limit_sqrt_price: Wei = Field(
         alias="limitSqrtPrice", default_factory=lambda: Wei(0)
     )  # 0 for convenience, we also don't expect major price shifts
+
+
+class SeerTransactionType(str, Enum):
+    SWAP = "swap"
+    SPLIT = "split"
+
+
+class SeerTransaction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    market_name: str = Field(alias="marketName")
+    market_id: HexBytes = Field(alias="marketId")
+    type: SeerTransactionType
+    block_number: int = Field(alias="blockNumber")
+    transaction_hash: HexBytes = Field(alias="transactionHash")
+    collateral: HexAddress
+    collateral_symbol: str = Field(alias="collateralSymbol")
+
+    token_in: HexAddress = Field(alias="tokenIn")
+    token_out: HexAddress = Field(alias="tokenOut")
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out: Wei = Field(alias="amountOut")
+    token_in_symbol: str = Field(alias="tokenInSymbol")
+    token_out_symbol: str = Field(alias="tokenOutSymbol")
+    timestamp: int | None = None
+
+    amount: Wei | None = None
+
+    @property
+    def timestamp_dt(self) -> DatetimeUTC | None:
+        return DatetimeUTC.to_datetime_utc(self.timestamp) if self.timestamp else None
+
+    @property
+    def token_in_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_in)
+
+    @property
+    def token_out_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_out)

prediction_market_agent_tooling/markets/seer/seer.py

@@ -35,6 +35,7 @@ from prediction_market_agent_tooling.markets.blockchain_utils import store_trade
 from prediction_market_agent_tooling.markets.data_models import (
     ExistingPosition,
     Resolution,
+    ResolvedBet,
 )
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import (
@@ -56,6 +57,7 @@ from prediction_market_agent_tooling.markets.seer.exceptions import (
     PriceCalculationError,
 )
 from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_api import get_seer_transactions
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     GnosisRouter,
     SeerMarketFactory,
@@ -81,7 +83,6 @@ from prediction_market_agent_tooling.tools.cow.cow_order import (
     OrderStatusError,
     get_orders_by_owner,
     get_trades_by_order_uid,
-    get_trades_by_owner,
     swap_tokens_waiting,
     wait_for_order_completion,
 )
@@ -272,10 +273,12 @@ class SeerAgentMarket(AgentMarket):
         """
         We filter the markets using previous trades by the user so that we don't have to process all Seer markets.
         """
-        trades_by_user = get_trades_by_owner(api_keys.bet_from_address)
+        trades_by_user = get_seer_transactions(
+            api_keys.bet_from_address, RPCConfig().CHAIN_ID
+        )
 
-        traded_tokens = {t.buyToken for t in trades_by_user}.union(
-            [t.sellToken for t in trades_by_user]
+        traded_tokens = {t.token_in_checksum for t in trades_by_user}.union(
+            [t.token_out_checksum for t in trades_by_user]
         )
         filtered_markets: list[SeerMarket] = []
         for market in markets:
@@ -313,19 +316,43 @@ class SeerAgentMarket(AgentMarket):
             for market in filtered_markets
             if market.is_redeemable(owner=api_keys.bet_from_address, web3=web3)
         ]
+        logger.info(f"Got {len(markets_to_redeem)} markets to redeem on Seer.")
 
         gnosis_router = GnosisRouter()
         for market in markets_to_redeem:
             try:
+                # GnosisRouter needs approval to use our outcome tokens
+                for i, token in enumerate(market.wrapped_tokens):
+                    ContractERC20OnGnosisChain(
+                        address=Web3.to_checksum_address(token)
+                    ).approve(
+                        api_keys,
+                        for_address=gnosis_router.address,
+                        amount_wei=market_balances[market.id][i].as_wei,
+                        web3=web3,
+                    )
+
+                # We can only ask for redeem of outcome tokens on correct outcomes
+                # TODO: Implement more complex use-cases: https://github.com/gnosis/prediction-market-agent-tooling/issues/850
+                amounts_to_redeem = [
+                    (amount if numerator > 0 else OutcomeWei(0))
+                    for amount, numerator in zip(
+                        market_balances[market.id], market.payout_numerators
+                    )
+                ]
+
+                # Redeem!
                 params = RedeemParams(
                     market=Web3.to_checksum_address(market.id),
                     outcome_indices=list(range(len(market.payout_numerators))),
-                    amounts=market_balances[market.id],
+                    amounts=amounts_to_redeem,
                 )
                 gnosis_router.redeem_to_base(api_keys, params=params, web3=web3)
-                logger.info(f"Redeemed market {market.id.to_0x_hex()}")
-            except Exception as e:
-                logger.error(f"Failed to redeem market {market.id.to_0x_hex()}, {e}")
+                logger.info(f"Redeemed market {market.url}.")
+            except Exception:
+                logger.exception(
+                    f"Failed to redeem market {market.url}, {market.outcomes}, with amounts {market_balances[market.id]} and payout numerators {market.payout_numerators}, and wrapped tokens {market.wrapped_tokens}."
+                )
 
         # GnosisRouter withdraws sDai into wxDAI/xDai on its own, so no auto-withdraw needed by us.
 
@@ -464,6 +491,15 @@ class SeerAgentMarket(AgentMarket):
 
         return market
 
+    @staticmethod
+    def get_resolved_bets_made_since(
+        better_address: ChecksumAddress,
+        start_time: DatetimeUTC,
+        end_time: DatetimeUTC | None,
+    ) -> list[ResolvedBet]:
+        # TODO: https://github.com/gnosis/prediction-market-agent-tooling/issues/841
+        raise NotImplementedError()
+
     @staticmethod
     def get_markets(
         limit: int,

prediction_market_agent_tooling/markets/seer/seer_api.py

@@ -0,0 +1,28 @@
+import httpx
+
+from prediction_market_agent_tooling.gtypes import ChainID, ChecksumAddress
+from prediction_market_agent_tooling.markets.seer.data_models import SeerTransaction
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+
+
+def get_seer_transactions(
+    account: ChecksumAddress,
+    chain_id: ChainID,
+    start_time: DatetimeUTC | None = None,
+    end_time: DatetimeUTC | None = None,
+    timeout: int = 60,  # The endpoint is pretty slow to respond atm.
+) -> list[SeerTransaction]:
+    url = "https://app.seer.pm/.netlify/functions/get-transactions"
+    params: dict[str, str | int] = {
+        "account": account,
+        "chainId": chain_id,
+        "startTime": to_int_timestamp(start_time) if start_time else 0,
+        "endTime": to_int_timestamp(end_time if end_time else utcnow()),
+    }
+    response = httpx.get(url, params=params, timeout=timeout)
+    response.raise_for_status()
+    response_json = response.json()
+
+    transactions = [SeerTransaction.model_validate(tx) for tx in response_json]
+    return transactions

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -29,10 +29,17 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
     SeerMarketQuestions,
     SeerMarketWithQuestions,
 )
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    SeerPool,
+    SwaprSwap,
+)
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
-from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+from prediction_market_agent_tooling.tools.utils import (
+    DatetimeUTC,
+    to_int_timestamp,
+    utcnow,
+)
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
 
@@ -328,8 +335,8 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         ]
         return fields
 
-    def get_market_by_wrapped_token(self, token: ChecksumAddress) -> SeerMarket:
-        where_stms = {"wrappedTokens_contains": [token]}
+    def get_market_by_wrapped_token(self, tokens: list[ChecksumAddress]) -> SeerMarket:
+        where_stms = {"wrappedTokens_contains": tokens}
         markets_field = self.seer_subgraph.Query.markets(
             where=unwrap_generic_value(where_stms)
         )
@@ -341,22 +348,27 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             )
         return markets[0]
 
-    def _get_fields_for_pools(self, pools_field: FieldPath) -> list[FieldPath]:
-        fields = [
-            pools_field.id,
-            pools_field.liquidity,
-            pools_field.sqrtPrice,
-            pools_field.token0Price,
-            pools_field.token1Price,
-            pools_field.token0.id,
-            pools_field.token0.name,
-            pools_field.token0.symbol,
-            pools_field.token1.id,
-            pools_field.token1.name,
-            pools_field.token1.symbol,
-            pools_field.totalValueLockedToken0,
-            pools_field.totalValueLockedToken1,
+    def _get_fields_for_seer_token(self, fields: FieldPath) -> list[FieldPath]:
+        return [
+            fields.id,
+            fields.name,
+            fields.symbol,
         ]
+
+    def _get_fields_for_pools(self, pools_field: FieldPath) -> list[FieldPath]:
+        fields = (
+            [
+                pools_field.id,
+                pools_field.liquidity,
+                pools_field.sqrtPrice,
+                pools_field.token0Price,
+                pools_field.token1Price,
+                pools_field.totalValueLockedToken0,
+                pools_field.totalValueLockedToken1,
+            ]
+            + self._get_fields_for_seer_token(pools_field.token0)
+            + self._get_fields_for_seer_token(pools_field.token1)
+        )
         return fields
 
     def get_pool_by_token(
@@ -396,6 +408,41 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             return pools[0]
         return None
 
+    def _get_fields_for_swaps(self, swaps_field: FieldPath) -> list[FieldPath]:
+        fields = (
+            [
+                swaps_field.id,
+                swaps_field.pool.id,
+                swaps_field.sender,
+                swaps_field.recipient,
+                swaps_field.price,
+                swaps_field.amount0,
+                swaps_field.amount1,
+                swaps_field.timestamp,
+            ]
+            + self._get_fields_for_seer_token(swaps_field.token0)
+            + self._get_fields_for_seer_token(swaps_field.token1)
+        )
+        return fields
+
+    def get_swaps(
+        self,
+        recipient: ChecksumAddress,
+        timestamp_gt: DatetimeUTC | None = None,
+        timestamp_lt: DatetimeUTC | None = None,
+    ) -> list[SwaprSwap]:
+        where_argument: dict[str, Any] = {"recipient": recipient.lower()}
+        if timestamp_gt is not None:
+            where_argument["timestamp_gt"] = to_int_timestamp(timestamp_gt)
+        if timestamp_lt is not None:
+            where_argument["timestamp_lt"] = to_int_timestamp(timestamp_lt)
+
+        swaps_field = self.swapr_algebra_subgraph.Query.swaps(where=where_argument)
+        fields = self._get_fields_for_swaps(swaps_field)
+        swaps = self.do_query(fields=fields, pydantic_model=SwaprSwap)
+
+        return swaps
+
 
 class SeerQuestionsCache(metaclass=SingletonMeta):
     """A singleton cache for storing and retrieving Seer market questions.

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -1,12 +1,17 @@
 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):
@@ -14,6 +19,10 @@ class SeerToken(BaseModel):
     name: str
     symbol: str
 
+    @property
+    def address(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.id.hex())
+
 
 class SeerPool(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
@@ -28,6 +37,62 @@ class SeerPool(BaseModel):
     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: SeerToken
+    token1: SeerToken
+    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 SeerSwap(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: SeerToken
+    token1: SeerToken
+    timestamp: int
+
+    @property
+    def timestamp_utc(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.timestamp)
+
+    @property
+    def buying_collateral_amount(self) -> CollateralToken:
+        return self.amount0 if self.amount0 > 0 else self.amount1
+
+    @property
+    def received_shares_amount(self) -> OutcomeToken:
+        return (
+            OutcomeToken(abs(self.amount0).value)
+            if self.amount0 < 0
+            else OutcomeToken(abs(self.amount1).value)
+        )
+
+
 class NewMarketEvent(BaseModel):
     market: HexAddress
     marketName: str

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,4 +1,6 @@
+from enum import Enum
 from itertools import chain
+from typing import Callable
 
 import numpy as np
 from scipy.optimize import minimize
@@ -9,11 +11,7 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
-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,
@@ -21,6 +19,11 @@ from prediction_market_agent_tooling.tools.betting_strategies.utils import (
 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:
     if not 0 <= probability <= 1:
         raise ValueError("Probability must be between 0 and 1")
@@ -237,7 +240,7 @@ def get_kelly_bets_categorical_simplified(
 
 
 def get_kelly_bets_categorical_full(
-    outcome_pool_sizes: list[OutcomeToken],
+    market_probabilities: list[Probability],
     estimated_probabilities: list[Probability],
     confidence: float,
     max_bet: CollateralToken,
@@ -245,6 +248,8 @@ def get_kelly_bets_categorical_full(
     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]:
     """
@@ -255,18 +260,13 @@ def get_kelly_bets_categorical_full(
     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(
+    assert len(market_probabilities) == 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)
+    n = len(market_probabilities)
     max_bet_value = max_bet.value
 
     if all(
@@ -283,22 +283,17 @@ def get_kelly_bets_categorical_full(
             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
+                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 = calculate_buy_outcome_token(
-                        CollateralToken(abs(bets[i]) / (n - 1)),
-                        j,
-                        outcome_pool_sizes,
-                        fees,
+                    buy_result = get_buy_token_amount(
+                        CollateralToken(abs(bets[i]) / (n - 1)), j
                     )
-                    payout += buy_result.outcome_tokens_received.value
+                    payout += buy_result.value
             payouts.append(payout)
         return payouts
 

prediction_market_agent_tooling/tools/datetime_utc.py

@@ -34,8 +34,20 @@ class DatetimeUTC(datetime):
     def __get_pydantic_core_schema__(
         cls, source_type: t.Any, handler: GetCoreSchemaHandler
     ) -> CoreSchema:
-        dt_schema = handler(datetime)
-        return core_schema.no_info_after_validator_function(cls._validate, dt_schema)
+        # Use union schema to handle int, str, and datetime inputs directly
+        return core_schema.union_schema(
+            [
+                core_schema.no_info_after_validator_function(
+                    cls._validate, core_schema.int_schema()
+                ),
+                core_schema.no_info_after_validator_function(
+                    cls._validate, core_schema.str_schema()
+                ),
+                core_schema.no_info_after_validator_function(
+                    cls._validate, handler(datetime)
+                ),
+            ]
+        )
 
     @staticmethod
     def from_datetime(dt: datetime) -> "DatetimeUTC":

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -5,7 +5,9 @@ from langfuse import Langfuse
 from langfuse.client import TraceWithDetails
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.deploy.agent import MarketType
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     PlacedTrade,
@@ -16,12 +18,13 @@ from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
+from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 class ProcessMarketTrace(BaseModel):
     timestamp: int
-    market: OmenAgentMarket
+    market: SeerAgentMarket | OmenAgentMarket
     answer: CategoricalProbabilisticAnswer
     trades: list[PlacedTrade]
 
@@ -40,13 +43,18 @@ class ProcessMarketTrace(BaseModel):
     def from_langfuse_trace(
         trace: TraceWithDetails,
     ) -> t.Optional["ProcessMarketTrace"]:
-        market = trace_to_omen_agent_market(trace)
+        market = trace_to_agent_market(trace)
         answer = trace_to_answer(trace)
         trades = trace_to_trades(trace)
 
         if not market or not answer or not trades:
             return None
 
+        if not isinstance(market, (SeerAgentMarket, OmenAgentMarket)):
+            raise ValueError(
+                f"Market type {type(market)} is not supported for ProcessMarketTrace"
+            )
+
         return ProcessMarketTrace(
             market=market,
             answer=answer,
@@ -105,17 +113,21 @@ def get_traces_for_agent(
     return all_agent_traces
 
 
-def trace_to_omen_agent_market(trace: TraceWithDetails) -> OmenAgentMarket | None:
+def trace_to_agent_market(trace: TraceWithDetails) -> AgentMarket | None:
     if not trace.input:
         logger.warning(f"No input in the trace: {trace}")
         return None
     if not trace.input["args"]:
         logger.warning(f"No args in the trace: {trace}")
         return None
-    assert len(trace.input["args"]) == 2 and trace.input["args"][0] == "omen"
+    assert len(trace.input["args"]) == 2
+
+    market_type = MarketType(trace.input["args"][0])
+    market_class = market_type.market_class
+
     try:
         # If the market model is invalid (e.g. outdated), it will raise an exception
-        market = OmenAgentMarket.model_validate(trace.input["args"][1])
+        market = market_class.model_validate(trace.input["args"][1])
         return market
     except Exception as e:
         logger.warning(f"Market not parsed from langfuse because: {e}")

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -194,7 +194,7 @@ def mint_full_set(
     # of the child market.
     seer_subgraph_handler = SeerSubgraphHandler()
     market = seer_subgraph_handler.get_market_by_wrapped_token(
-        token=collateral_token_contract.address
+        tokens=[collateral_token_contract.address]
     )
     market_collateral_token = Web3.to_checksum_address(market.collateral_token)
 

{prediction_market_agent_tooling-0.68.1.dist-info → prediction_market_agent_tooling-0.69.0.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.68.1.dist-info → prediction_market_agent_tooling-0.69.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=MF600uUR_I0Mf7-Pz5InS6RWMkdrZI2sohP6Vfh0YRw,148
 prediction_market_agent_tooling/config.py,sha256=juGITh2OxpH_dVe-63W4vcrRYtzldSUTT7UIjcDvAT4,13006
 prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=VY23h324VKIVkevj1B1O-zL1eEp9AElmcfn6SwYDUSc,14246
-prediction_market_agent_tooling/deploy/agent.py,sha256=LQUfP25ViMBQTqy9l_u0WsML__PsPMqjt1m1dXvW5zM,30076
+prediction_market_agent_tooling/deploy/agent.py,sha256=xtufEkxHkR54TSAqRqiBRcISf05MwrV-WlG4PcOo7xM,30582
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=E_0P8MFBtm50OT9BCAy_ZSHW80skDPtSr-vgGZqNjDs,26584
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=C6Q2tfUllkC9fIaABhKyVjq5QTO6qnVd1Jd1GFePaCU,29553
 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,10 +38,10 @@ 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=4KZ0iaKZx5zEZBBiEo9CHk0OpX3bKjoYA0wmptR0Wyk,2455
-prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=DqWQTQUsS0KE97mEJNeDxRcqcEktPavqOpkXZ21Mn0M,5126
+prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=CojpgghRs0lFEf5wl-oWhGaQozG616YD0cXdlmFO-U0,5116
 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=x4BW--A9gYWwd0qnBtG6D4fktnD695Ej_GYdJ_b5lqM,21501
+prediction_market_agent_tooling/markets/agent_market.py,sha256=AZpL6_vicDexs6YhAqLDCdxuIuF_oYfQnoqgBzOBf0Q,21755
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
 prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=OJp402xDbPXfks-S3iRN2ygAjjJpdasKVt6iYvQlemA,3065
 prediction_market_agent_tooling/markets/categorize.py,sha256=orLZlPaHgeREU66m1amxfWikeV77idV4sZDPB8NgSD0,1300
@@ -52,7 +52,7 @@ prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=3z1gFbPME
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=hHloNKYQRyd4OWTCUh5kCk-Kx1m77rOIg8d8bGJ6jvk,5454
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=DCigEbpGWkXR-RZT_oJrvJhilmxKFAxcWMjUFi0nBBI,530
 prediction_market_agent_tooling/markets/market_fees.py,sha256=YeK3ynjYIguB0xf6sO5iyg9lOdW_HD4C6nbJfiGyRCU,1351
-prediction_market_agent_tooling/markets/markets.py,sha256=jEyYZVubrxnMvPHVO3ofxVXgzwmQ5sPlPx4QAVLy9qc,2777
+prediction_market_agent_tooling/markets/markets.py,sha256=GmloYxwLJC51v65-ooQ5DqMtKpSCZ955TZWkf0uxhLI,3256
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=WjPt0MKeJNtoY-8oLQTLC8vQYYQ-dBj8UZoPq-UBYsQ,3288
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=kM0U0k90YfLE82ra53JAoCR9uIc9wm4B8l32hLw5imU,5312
@@ -72,18 +72,19 @@ prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=-zAx64Mc
 prediction_market_agent_tooling/markets/polymarket/polymarket_contracts.py,sha256=x8yvAUPl55nbJALsQAAHJtstahhpH8WcEOj8or_QloQ,1165
 prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py,sha256=2b1hVAp3tCPkmp_FFAZwy6baW7CrPhpUSGk7TlrvgtU,1631
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=A_diygWKYyp4WHbxAlAVAuC0S0ZqbEKE80wxL6mxHKQ,1275
-prediction_market_agent_tooling/markets/seer/data_models.py,sha256=M6hCKCAHPqKGh8ST0TVvRcCbNfJ-e60jetVS49Zu87w,6687
+prediction_market_agent_tooling/markets/seer/data_models.py,sha256=Y8tIyOyTHfcIYu0b6YfMDxXcDnW87o3Fam4NEHBITmw,7833
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
 prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=LCfbnwOlcWn_pb5mNSqu0fYb-FKOgql19OnpItEc8wA,10007
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=gv3iDH9g9JSjeh2IHTmrH1qG2osINxKpHI4BN76nbb8,29319
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=UUH75JAMfI_uZE1pEbdI3rbf5c0K0KgUzBiaVRshjV0,31031
+prediction_market_agent_tooling/markets/seer/seer_api.py,sha256=4iiTWskxWm__oGgUUd1GhV_ItPSrAr0OfnYQ7lKndnQ,1143
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=JqfQNFSRWREPw6pQGpJoh-No5ZlKwmTiALJiAYEuvW8,5516
-prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=e-rI0JwJAGtrFmUoDZP5uFbMx3EPmUHAhk2RgQvx3u4,17269
-prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=VREm8bR-gPY06ODFJsaiSMinYgN64q5dC6DFckMY6oA,1831
+prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=aohhV-VA2fsmmRpZSSsxUHpXW78wWzXvF2l2vqPsupI,18791
+prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=u75DaEwQCl77eko2eNuUP8dJPBXIaBrERR8bLNeMdiM,3753
 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=C1rWbj88gPsBYVpKSAoJgZ1iVfOL2YJ5tXnvqIxmMKk,14716
+prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=o5ba633gKiDqV4t_C2d9FWwH-HkRAOZd8FcZTYvbj6g,14451
 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=MpS3FOMn0C7nbmbQRUT9QwSh3UzzsgGczP91iSMr9wo,261
 prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=rZIGhgijquwwPtp_qncSAPR1SDF2XxIVZL1ir0fgzWw,12127
@@ -95,7 +96,7 @@ prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=q39Kr0mSvnKjyQ4LSm
 prediction_market_agent_tooling/tools/cow/models.py,sha256=Z_XUAMj5AGHZE-A92oRG0DuPeXTSyWnZRIwKQ49LaXU,709
 prediction_market_agent_tooling/tools/cow/semaphore.py,sha256=IJGKRgvXnRSkEt_z1i5-eFIoVMcyhr7HK0JfIz1MXdQ,3738
 prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
-prediction_market_agent_tooling/tools/datetime_utc.py,sha256=8_WackjtjC8zHXrhQFTGQ6e6Fz_6llWoKR4CSFvIv9I,2766
+prediction_market_agent_tooling/tools/datetime_utc.py,sha256=_oO6mMc28C9aSmQfrG-S7UQy5uMHVEQqia8arnscVCk,3213
 prediction_market_agent_tooling/tools/db/db_manager.py,sha256=GtzHH1NLl8HwqC8Z7s6eTlIQXuV0blxfaV2PeQrBnfQ,3013
 prediction_market_agent_tooling/tools/google_utils.py,sha256=D-6FB2HRtmxaKZJ_Za-qj6VZCp5XU18rF4wLMMrqEUg,2557
 prediction_market_agent_tooling/tools/hexbytes_custom.py,sha256=0Y1n8MChjWJmE4w6kgIJPiqbrGULui0m3TQzUBgZDHs,2206
@@ -106,7 +107,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=D_AzGvEg-YXc0xhYGALGPnmtQqeNyNxkP0SWMCRQW3M,6644
+prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=8d33dcYx5ElyE0pL_VTJTcJIXvt3PPkDaadQgxGGyp0,7132
 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
@@ -122,7 +123,7 @@ prediction_market_agent_tooling/tools/singleton.py,sha256=CHpUJuu89Hwup2fH9CIChU
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=5ldQs1pZe6uJ5eDAuP4OLpzmcqYShlIV67kttNFvGS0,342
 prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=pPs0qZNfJ7G-1ajfz0iaWOBQyiC0TbcShfrW8T39jtg,3859
-prediction_market_agent_tooling/tools/tokens/auto_deposit.py,sha256=ccpDCYueObaaoBS66d3P-xprJg7FFZREdx-6oRbuKm8,9183
+prediction_market_agent_tooling/tools/tokens/auto_deposit.py,sha256=E4jq6HvwOQCt6hb6yEFps7G78Ri5Z0JOfh3UqrwLPEM,9186
 prediction_market_agent_tooling/tools/tokens/auto_withdraw.py,sha256=HYLSI_MincuyRGSrSJTuf0cHMcdnyQPrXOUW3o2quBk,2811
 prediction_market_agent_tooling/tools/tokens/main_token.py,sha256=1rbwpdCusPgQIVFuo3m00nBZ_b2lCAoFVm67i-YDcEw,812
 prediction_market_agent_tooling/tools/tokens/slippage.py,sha256=ByBssRY6fBjLdxPx5bpudYfs-Z4gUa8CyOGuLDd5tQk,639
@@ -131,8 +132,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=DPO-4HBTy1-TZHKL_9CnH
 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=ajHZIBM_PNNNUp0ZxJ-AvpSzyVATm7LnZtb2hi6NcOw,12614
-prediction_market_agent_tooling-0.68.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.68.1.dist-info/METADATA,sha256=xViLluiOrvDpEF2wBMDodVyGSTS9auN_vTBosi8reos,8805
-prediction_market_agent_tooling-0.68.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.68.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.68.1.dist-info/RECORD,,
+prediction_market_agent_tooling-0.69.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.69.0.dist-info/METADATA,sha256=UtvkCNpHOorBV50gdyXVdgBJq3EiN15wH8SdyzeAt08,8805
+prediction_market_agent_tooling-0.69.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.69.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.69.0.dist-info/RECORD,,