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

prediction_market_agent_tooling/deploy/agent.py

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

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -30,8 +30,13 @@ from prediction_market_agent_tooling.markets.omen.omen import (
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
     get_kelly_bet_full,
     get_kelly_bet_simplified,
+    get_kelly_bets_categorical_full,
+    get_kelly_bets_categorical_simplified,
+)
+from prediction_market_agent_tooling.tools.betting_strategies.utils import (
+    BinaryKellyBet,
+    CategoricalKellyBet,
 )
-from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
@@ -245,7 +250,7 @@ class BettingStrategy(ABC):
         return trades
 
 
-class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
+class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
     def __init__(self, max_position_amount: USD, take_profit: bool = True):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
@@ -308,8 +313,11 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         )
         return trades
 
+    def __repr__(self) -> str:
+        return f"CategoricalMaxAccuracyBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
 
-class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy):
+class MaxExpectedValueBettingStrategy(CategoricalMaxAccuracyBettingStrategy):
     @staticmethod
     def calculate_direction(
         market: AgentMarket, answer: CategoricalProbabilisticAnswer
@@ -350,49 +358,49 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
         return best_outcome
 
+    def __repr__(self) -> str:
+        return f"MaxExpectedValueBettingStrategy(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
 
-class KellyBettingStrategy(BettingStrategy):
+class BinaryKellyBettingStrategy(BettingStrategy):
     def __init__(
         self,
         max_position_amount: USD,
         max_price_impact: float | None = None,
         take_profit: bool = True,
+        force_simplified_calculation: bool = False,
     ):
         super().__init__(take_profit=take_profit)
         self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
+        self.force_simplified_calculation = force_simplified_calculation
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
         return self.max_position_amount
 
-    @staticmethod
     def get_kelly_bet(
+        self,
         market: AgentMarket,
-        max_bet_amount: USD,
         direction: OutcomeStr,
         other_direction: OutcomeStr,
         answer: CategoricalProbabilisticAnswer,
         override_p_yes: float | None = None,
-    ) -> SimpleBet:
+    ) -> BinaryKellyBet:
         estimated_p_yes = (
             answer.probability_for_market_outcome(direction)
             if not override_p_yes
             else override_p_yes
         )
 
-        if not market.is_binary:
-            # use Kelly simple, since Kelly full only supports 2 outcomes
-
+        if market.outcome_token_pool is None or self.force_simplified_calculation:
             kelly_bet = get_kelly_bet_simplified(
-                max_bet=market.get_usd_in_token(max_bet_amount),
+                max_bet=market.get_usd_in_token(self.max_position_amount),
                 market_p_yes=market.probability_for_market_outcome(direction),
                 estimated_p_yes=estimated_p_yes,
                 confidence=answer.confidence,
             )
         else:
-            # We consider only binary markets, since the Kelly strategy is not yet implemented
-            # for markets with more than 2 outcomes (https://github.com/gnosis/prediction-market-agent-tooling/issues/671).
             direction_to_bet_pool_size = market.get_outcome_token_pool_by_outcome(
                 direction
             )
@@ -403,7 +411,7 @@ class KellyBettingStrategy(BettingStrategy):
                 yes_outcome_pool_size=direction_to_bet_pool_size,
                 no_outcome_pool_size=other_direction_pool_size,
                 estimated_p_yes=estimated_p_yes,
-                max_bet=market.get_usd_in_token(max_bet_amount),
+                max_bet=market.get_usd_in_token(self.max_position_amount),
                 confidence=answer.confidence,
                 fees=market.fees,
             )
@@ -416,7 +424,7 @@ class KellyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         # We consider the p_yes as the direction with highest probability.
-        direction = MultiCategoricalMaxAccuracyBettingStrategy.calculate_direction(
+        direction = CategoricalMaxAccuracyBettingStrategy.calculate_direction(
             market, answer
         )
         # We get the first direction which is != direction.
@@ -426,7 +434,6 @@ class KellyBettingStrategy(BettingStrategy):
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_position_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -436,15 +443,21 @@ class KellyBettingStrategy(BettingStrategy):
         if self.max_price_impact:
             # Adjust amount
             max_price_impact_bet_amount = self.calculate_bet_amount_for_price_impact(
-                market, kelly_bet, direction=direction
+                market,
+                kelly_bet.size,
+                direction=direction,
+                max_price_impact=self.max_price_impact,
             )
 
             # We just don't want Kelly size to extrapolate price_impact - hence we take the min.
             kelly_bet_size = min(kelly_bet.size, max_price_impact_bet_amount)
 
         bet_outcome = direction if kelly_bet.direction else other_direction
+
         amounts = {
-            bet_outcome: market.get_token_in_usd(kelly_bet_size),
+            bet_outcome: BettingStrategy.cap_to_profitable_bet_amount(
+                market, market.get_token_in_usd(kelly_bet_size), bet_outcome
+            ),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
@@ -452,8 +465,8 @@ class KellyBettingStrategy(BettingStrategy):
         )
         return trades
 
+    @staticmethod
     def calculate_price_impact_for_bet_amount(
-        self,
         outcome_idx: int,
         bet_amount: CollateralToken,
         pool_balances: list[OutcomeWei],
@@ -471,29 +484,33 @@ class KellyBettingStrategy(BettingStrategy):
         price_impact = (actual_price - expected_price) / expected_price
         return price_impact
 
+    @staticmethod
     def calculate_bet_amount_for_price_impact(
-        self, market: AgentMarket, kelly_bet: SimpleBet, direction: OutcomeStr
+        market: AgentMarket,
+        kelly_bet_size: CollateralToken,
+        direction: OutcomeStr,
+        max_price_impact: float,
     ) -> CollateralToken:
         def calculate_price_impact_deviation_from_target_price_impact(
-            bet_amount_usd: float,  # Needs to be float because it's used in minimize_scalar internally.
+            bet_amount_collateral: float,  # Needs to be float because it's used in minimize_scalar internally.
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
-            price_impact = self.calculate_price_impact_for_bet_amount(
-                outcome_idx=outcome_idx,
-                bet_amount=market.get_usd_in_token(USD(bet_amount_usd)),
-                pool_balances=pool_balances,
-                fees=market.fees,
+            price_impact = (
+                BinaryKellyBettingStrategy.calculate_price_impact_for_bet_amount(
+                    outcome_idx=outcome_idx,
+                    bet_amount=CollateralToken(bet_amount_collateral),
+                    pool_balances=pool_balances,
+                    fees=market.fees,
+                )
             )
             # We return abs for the algorithm to converge to 0 instead of the min (and possibly negative) value.
-
-            max_price_impact = check_not_none(self.max_price_impact)
             return abs(price_impact - max_price_impact)
 
         if not market.outcome_token_pool:
             logger.warning(
                 "Market outcome_token_pool is None, cannot calculate bet amount"
             )
-            return kelly_bet.size
+            return kelly_bet_size
 
         pool_balances = [i.as_outcome_wei for i in market.outcome_token_pool.values()]
         # stay float for compatibility with `minimize_scalar`
@@ -504,13 +521,13 @@ class KellyBettingStrategy(BettingStrategy):
             calculate_price_impact_deviation_from_target_price_impact,
             bounds=(0, 1000 * total_pool_balance),
             method="bounded",
-            tol=1e-11,
+            tol=1e-13,
             options={"maxiter": 10000},
         )
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount}, max_price_impact={self.max_price_impact})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
@@ -526,40 +543,29 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
     def maximum_possible_bet_amount(self) -> USD:
         return self.max_position_amount
 
-    def adjust_bet_amount(
-        self, existing_position: ExistingPosition | None, market: AgentMarket
-    ) -> USD:
-        existing_position_total_amount = (
-            existing_position.total_amount_current if existing_position else USD(0)
-        )
-        return self.max_position_amount + existing_position_total_amount
-
     def calculate_trades(
         self,
         existing_position: ExistingPosition | None,
         answer: CategoricalProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount_usd = self.adjust_bet_amount(existing_position, market)
-
         outcome = get_most_probable_outcome(answer.probabilities)
 
-        direction = MultiCategoricalMaxAccuracyBettingStrategy.calculate_direction(
+        direction = CategoricalMaxAccuracyBettingStrategy.calculate_direction(
             market, answer
         )
         # We get the first direction which is != direction.
-        other_direction = (
-            MultiCategoricalMaxAccuracyBettingStrategy.get_other_direction(
-                outcomes=market.outcomes, direction=direction
-            )
+        other_direction = CategoricalMaxAccuracyBettingStrategy.get_other_direction(
+            outcomes=market.outcomes, direction=direction
         )
 
         # We ignore the direction nudge given by Kelly, hence we assume we have a perfect prediction.
         estimated_p_yes = 1.0
 
-        kelly_bet = KellyBettingStrategy.get_kelly_bet(
+        kelly_bet = BinaryKellyBettingStrategy(
+            max_position_amount=self.max_position_amount
+        ).get_kelly_bet(
             market=market,
-            max_bet_amount=adjusted_bet_amount_usd,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -581,4 +587,118 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount})"
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, take_profit={self.take_profit})"
+
+
+class CategoricalKellyBettingStrategy(BettingStrategy):
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None,
+        allow_multiple_bets: bool,
+        allow_shorting: bool,
+        multicategorical: bool,
+        take_profit: bool = True,
+        force_simplified_calculation: bool = False,
+    ):
+        super().__init__(take_profit=take_profit)
+        self.max_position_amount = max_position_amount
+        self.max_price_impact = max_price_impact
+        self.allow_multiple_bets = allow_multiple_bets
+        self.allow_shorting = allow_shorting
+        self.multicategorical = multicategorical
+        self.force_simplified_calculation = force_simplified_calculation
+
+    @property
+    def maximum_possible_bet_amount(self) -> USD:
+        return self.max_position_amount
+
+    def get_kelly_bets(
+        self,
+        market: AgentMarket,
+        max_bet_amount: USD,
+        answer: CategoricalProbabilisticAnswer,
+    ) -> list[CategoricalKellyBet]:
+        max_bet = market.get_usd_in_token(max_bet_amount)
+
+        if market.outcome_token_pool is None or self.force_simplified_calculation:
+            kelly_bets = get_kelly_bets_categorical_simplified(
+                market_probabilities=[market.probabilities[o] for o in market.outcomes],
+                estimated_probabilities=[
+                    answer.probability_for_market_outcome(o) for o in market.outcomes
+                ],
+                confidence=answer.confidence,
+                max_bet=max_bet,
+                fees=market.fees,
+                allow_multiple_bets=self.allow_multiple_bets,
+                allow_shorting=self.allow_shorting,
+            )
+
+        else:
+            kelly_bets = get_kelly_bets_categorical_full(
+                outcome_pool_sizes=[
+                    market.outcome_token_pool[o] for o in market.outcomes
+                ],
+                estimated_probabilities=[
+                    answer.probability_for_market_outcome(o) for o in market.outcomes
+                ],
+                confidence=answer.confidence,
+                max_bet=max_bet,
+                fees=market.fees,
+                allow_multiple_bets=self.allow_multiple_bets,
+                allow_shorting=self.allow_shorting,
+                multicategorical=self.multicategorical,
+            )
+
+        return kelly_bets
+
+    def calculate_trades(
+        self,
+        existing_position: ExistingPosition | None,
+        answer: CategoricalProbabilisticAnswer,
+        market: AgentMarket,
+    ) -> list[Trade]:
+        kelly_bets = self.get_kelly_bets(
+            market=market,
+            max_bet_amount=self.max_position_amount,
+            answer=answer,
+        )
+
+        # TODO: Allow shorting in BettingStrategy._build_rebalance_trades_from_positions.
+        # In binary implementation, we simply flip the direction in case of negative bet, for categorical outcome, we need to implement shorting.
+        kelly_bets = [bet for bet in kelly_bets if bet.size > 0]
+        if not kelly_bets:
+            return []
+
+        # TODO: Allow betting on multiple outcomes.
+        # Categorical kelly could suggest to bet on multiple outcomes, but we only consider the first one for now (limitation of BettingStrategy `trades` creation).
+        # Also, this could maybe work for multi-categorical markets as well, but it wasn't benchmarked for it.
+        best_kelly_bet = max(kelly_bets, key=lambda x: abs(x.size))
+
+        if self.max_price_impact:
+            # Adjust amount
+            max_price_impact_bet_amount = (
+                BinaryKellyBettingStrategy.calculate_bet_amount_for_price_impact(
+                    market,
+                    best_kelly_bet.size,
+                    direction=market.get_outcome_str(best_kelly_bet.index),
+                    max_price_impact=self.max_price_impact,
+                )
+            )
+            # We just don't want Kelly size to extrapolate price_impact - hence we take the min.
+            best_kelly_bet.size = min(best_kelly_bet.size, max_price_impact_bet_amount)
+
+        amounts = {
+            market.outcomes[best_kelly_bet.index]: market.get_token_in_usd(
+                best_kelly_bet.size
+            ),
+        }
+        target_position = Position(market_id=market.id, amounts_current=amounts)
+        trades = self._build_rebalance_trades_from_positions(
+            existing_position, target_position, market=market
+        )
+
+        return trades
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(max_position_amount={self.max_position_amount}, max_price_impact={self.max_price_impact}, allow_multiple_bets={self.allow_multiple_bets}, allow_shorting={self.allow_shorting}, take_profit={self.take_profit}, force_simplified_calculation={self.force_simplified_calculation})"

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

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

prediction_market_agent_tooling/markets/agent_market.py

@@ -153,6 +153,23 @@ class AgentMarket(BaseModel):
         if "fees" not in data and "fee" in data:
             data["fees"] = MarketFees(absolute=0.0, bet_proportion=data["fee"])
             del data["fee"]
+        # Backward compatibility for older `AgentMarket` without `probabilities`.
+        if "probabilities" not in data and "current_p_yes" in data:
+            yes_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    YES_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            no_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    NO_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            data["probabilities"] = {
+                yes_outcome: data["current_p_yes"],
+                no_outcome: 1 - data["current_p_yes"],
+            }
+            del data["current_p_yes"]
         return data
 
     def market_outcome_for_probability_key(

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -37,6 +37,10 @@ def store_trades(
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
         return None
 
+    logger.info(
+        f"Storing trades for market {market_id}, with outcomes {outcomes}, {traded_market=}."
+    )
+
     probabilities = traded_market.answer.probabilities
     if not probabilities:
         logger.info("Skipping this since no probabilities available.")
@@ -56,9 +60,7 @@ def store_trades(
         ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
     # tx_hashes must be list of bytes32 (see Solidity contract).
-    tx_hashes = [
-        HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
-    ]
+    tx_hashes = [HexBytes(HexStr(i.id)) for i in traded_market.trades]
 
     # Dune dashboard expects the probs to be in the same order as on the market.
     probabilities_converted = [

prediction_market_agent_tooling/markets/data_models.py

@@ -1,7 +1,7 @@
 from enum import Enum
-from typing import Annotated, Sequence
+from typing import Annotated, Any, Sequence
 
-from pydantic import BaseModel, BeforeValidator, computed_field
+from pydantic import BaseModel, BeforeValidator, computed_field, model_validator
 
 from prediction_market_agent_tooling.deploy.constants import (
     DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
@@ -157,6 +157,15 @@ class CategoricalProbabilisticAnswer(BaseModel):
     confidence: float
     reasoning: str | None = None
 
+    @model_validator(mode="before")
+    @classmethod
+    def _model_validator(cls, data: Any) -> Any:
+        if "p_yes" in data:
+            return CategoricalProbabilisticAnswer.from_probabilistic_answer(
+                ProbabilisticAnswer.model_validate(data)
+            ).model_dump()
+        return data
+
     @property
     def probable_resolution(self) -> Resolution:
         most_likely_outcome = max(
@@ -290,9 +299,20 @@ class Trade(BaseModel):
     outcome: OutcomeStr
     amount: USD
 
+    @model_validator(mode="before")
+    @classmethod
+    def _model_validator(cls, data: Any) -> Any:
+        if isinstance(data["outcome"], bool):
+            data["outcome"] = (
+                YES_OUTCOME_LOWERCASE_IDENTIFIER
+                if data["outcome"]
+                else NO_OUTCOME_LOWERCASE_IDENTIFIER
+            )
+        return data
+
 
 class PlacedTrade(Trade):
-    id: str | None = None
+    id: str
 
     @staticmethod
     def from_trade(trade: Trade, id: str) -> "PlacedTrade":

prediction_market_agent_tooling/markets/omen/data_models.py

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

prediction_market_agent_tooling/markets/omen/omen.py

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

prediction_market_agent_tooling/markets/polymarket/api.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 from enum import Enum
 from urllib.parse import urljoin
 
@@ -49,7 +50,7 @@ def get_polymarkets_with_pagination(
     Binary markets have len(model.markets) == 1.
     Categorical markets have len(model.markets) > 1
     """
-    client: httpx.Client = HttpxCachedClient(ttl=60).get_client()
+    client: httpx.Client = HttpxCachedClient(ttl=timedelta(seconds=60)).get_client()
     all_markets: list[PolymarketGammaResponseDataItem] = []
     offset = 0
     remaining = limit
@@ -82,6 +83,9 @@ def get_polymarkets_with_pagination(
 
         markets_to_add = []
         for m in market_response.data:
+            # Some Polymarket markets are missing the markets field
+            if m.markets is None:
+                continue
             if excluded_questions and m.title in excluded_questions:
                 continue
 
@@ -94,14 +98,16 @@ def get_polymarkets_with_pagination(
                 ]:
                     continue
 
-            if created_after and created_after > m.startDate:
+            if not m.startDate or (created_after and created_after > m.startDate):
                 continue
 
             markets_to_add.append(m)
 
         if only_binary:
             markets_to_add = [
-                market for market in market_response.data if len(market.markets) == 1
+                market
+                for market in markets_to_add
+                if market.markets is not None and len(market.markets) == 1
             ]
 
         # Add the markets from this batch to our results