prediction-market-agent-tooling 0.66.5__py3-none-any.whl → 0.67.1__py3-none-any.whl

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -1,22 +1,35 @@
 import typing as t
 
-from prediction_market_agent_tooling.gtypes import USD, CollateralToken, OutcomeStr
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    CollateralToken,
+    HexBytes,
+    OutcomeStr,
+    Probability,
+)
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    MarketType,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.polymarket.api import (
-    get_polymarket_binary_markets,
+    PolymarketOrderByEnum,
+    get_polymarkets_with_pagination,
 )
 from prediction_market_agent_tooling.markets.polymarket.data_models import (
-    PolymarketMarketWithPrices,
+    PolymarketGammaResponseDataItem,
 )
 from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
     POLYMARKET_BASE_URL,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_handler import (
+    ConditionSubgraphModel,
+    PolymarketSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
 class PolymarketAgentMarket(AgentMarket):
@@ -33,19 +46,68 @@ class PolymarketAgentMarket(AgentMarket):
     fees: MarketFees = MarketFees.get_zero_fees()
 
     @staticmethod
-    def from_data_model(model: PolymarketMarketWithPrices) -> "PolymarketAgentMarket":
+    def build_resolution_from_condition(
+        condition_id: HexBytes,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+        outcomes: list[OutcomeStr],
+    ) -> Resolution | None:
+        condition_model = condition_model_dict.get(condition_id)
+        if (
+            not condition_model
+            or condition_model.resolutionTimestamp is None
+            or not condition_model.payoutNumerators
+            or not condition_model.payoutDenominator
+        ):
+            return None
+
+        # Currently we only support binary markets, hence we throw an error if we get something else.
+        payout_numerator_indices_gt_0 = [
+            idx
+            for idx, value in enumerate(condition_model.payoutNumerators)
+            if value > 0
+        ]
+        # For a binary market, there should be exactly one payout numerator greater than 0.
+        if len(payout_numerator_indices_gt_0) != 1:
+            raise ValueError(
+                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators}"
+            )
+
+        # we return the only payout numerator greater than 0 as resolution
+        resolved_outcome = outcomes[payout_numerator_indices_gt_0[0]]
+        return Resolution.from_answer(resolved_outcome)
+
+    @staticmethod
+    def from_data_model(
+        model: PolymarketGammaResponseDataItem,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+    ) -> "PolymarketAgentMarket":
+        # If len(model.markets) > 0, this denotes a categorical market.
+
+        outcomes = model.markets[0].outcomes_list
+        outcome_prices = model.markets[0].outcome_prices
+        if not outcome_prices:
+            # We give random prices
+            outcome_prices = [0.5, 0.5]
+        probabilities = {o: Probability(op) for o, op in zip(outcomes, outcome_prices)}
+
+        resolution = PolymarketAgentMarket.build_resolution_from_condition(
+            condition_id=model.markets[0].conditionId,
+            condition_model_dict=condition_model_dict,
+            outcomes=outcomes,
+        )
+
         return PolymarketAgentMarket(
             id=model.id,
-            question=model.question,
+            question=model.title,
             description=model.description,
-            outcomes=[x.outcome for x in model.tokens],
-            resolution=model.resolution,
-            created_time=None,
-            close_time=model.end_date_iso,
+            outcomes=outcomes,
+            resolution=resolution,
+            created_time=model.startDate,
+            close_time=model.endDate,
             url=model.url,
-            volume=None,
+            volume=CollateralToken(model.volume) if model.volume else None,
             outcome_token_pool=None,
-            probabilities={},  # ToDo - Implement when fixing Polymarket
+            probabilities=probabilities,
         )
 
     def get_tiny_bet_amount(self) -> CollateralToken:
@@ -61,16 +123,11 @@ class PolymarketAgentMarket(AgentMarket):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        fetch_categorical_markets: bool = False,
-        fetch_scalar_markets: bool = False,
+        market_type: MarketType = MarketType.ALL,
+        include_conditional_markets: bool = False,
     ) -> t.Sequence["PolymarketAgentMarket"]:
-        if sort_by != SortBy.NONE:
-            raise ValueError(f"Unsuported sort_by {sort_by} for Polymarket.")
-
-        if created_after is not None:
-            raise ValueError(f"Unsuported created_after for Polymarket.")
-
         closed: bool | None
+
         if filter_by == FilterBy.OPEN:
             closed = False
         elif filter_by == FilterBy.RESOLVED:
@@ -80,11 +137,37 @@ class PolymarketAgentMarket(AgentMarket):
         else:
             raise ValueError(f"Unknown filter_by: {filter_by}")
 
+        ascending: bool = False  # default value
+        match sort_by:
+            case SortBy.NEWEST:
+                order_by = PolymarketOrderByEnum.START_DATE
+            case SortBy.CLOSING_SOONEST:
+                ascending = True
+                order_by = PolymarketOrderByEnum.END_DATE
+            case SortBy.HIGHEST_LIQUIDITY:
+                order_by = PolymarketOrderByEnum.LIQUIDITY
+            case SortBy.NONE:
+                order_by = PolymarketOrderByEnum.VOLUME_24HR
+            case _:
+                raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        # closed markets also have property active=True, hence ignoring active.
+        markets = get_polymarkets_with_pagination(
+            limit=limit,
+            closed=closed,
+            order_by=order_by,
+            ascending=ascending,
+            created_after=created_after,
+            excluded_questions=excluded_questions,
+            only_binary=market_type is not MarketType.CATEGORICAL,
+        )
+
+        condition_models = PolymarketSubgraphHandler().get_conditions(
+            condition_ids=[market.markets[0].conditionId for market in markets]
+        )
+        condition_models_dict = {c.id: c for c in condition_models}
+
         return [
-            PolymarketAgentMarket.from_data_model(m)
-            for m in get_polymarket_binary_markets(
-                limit=limit,
-                closed=closed,
-                excluded_questions=excluded_questions,
-            )
+            PolymarketAgentMarket.from_data_model(m, condition_models_dict)
+            for m in markets
         ]

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -0,0 +1,49 @@
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.gtypes import HexBytes
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
+
+
+class ConditionSubgraphModel(BaseModel):
+    id: HexBytes
+    payoutDenominator: int | None = None
+    payoutNumerators: list[int] | None = None
+    outcomeSlotCount: int
+    resolutionTimestamp: int | None = None
+
+
+class PolymarketSubgraphHandler(BaseSubgraphHandler):
+    POLYMARKET_CONDITIONS_SUBGRAPH = "https://gateway.thegraph.com/api/{graph_api_key}/subgraphs/id/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Load the subgraph
+        self.conditions_subgraph = self.sg.load_subgraph(
+            self.POLYMARKET_CONDITIONS_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+
+    def get_conditions(
+        self, condition_ids: list[HexBytes]
+    ) -> list[ConditionSubgraphModel]:
+        where_stms = {"id_in": [i.hex() for i in condition_ids]}
+        conditions = self.conditions_subgraph.Query.conditions(
+            where=where_stms,
+        )
+
+        condition_fields = [
+            conditions.id,
+            conditions.payoutNumerators,
+            conditions.payoutDenominator,
+            conditions.outcomeSlotCount,
+            conditions.resolutionTimestamp,
+        ]
+
+        conditions_models = self.do_query(
+            fields=condition_fields, pydantic_model=ConditionSubgraphModel
+        )
+        return conditions_models

prediction_market_agent_tooling/markets/polymarket/utils.py

@@ -1,28 +1,7 @@
-from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
-    PolymarketFullMarket,
-)
 from prediction_market_agent_tooling.tools.google_utils import search_google_gcp
 
 
-def find_resolution_on_polymarket(question: str) -> Resolution | None:
-    full_market = find_full_polymarket(question)
-    # TODO: Only main markets are supported right now, add logic for others if needed.
-    return (
-        full_market.main_market.resolution
-        if full_market and full_market.is_main_market
-        else None
-    )
-
-
-def find_full_polymarket(question: str) -> PolymarketFullMarket | None:
-    polymarket_url = find_url_to_polymarket(question)
-    return (
-        PolymarketFullMarket.fetch_from_url(polymarket_url) if polymarket_url else None
-    )
-
-
 def find_url_to_polymarket(question: str) -> str | None:
     # Manually create potential Polymarket's slug from the question.
     replace_chars = {

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -1,6 +1,5 @@
-import typing as t
-
 from cachetools import TTLCache, cached
+from pydantic import BaseModel
 from web3 import Web3
 
 from prediction_market_agent_tooling.gtypes import (
@@ -18,32 +17,15 @@ from prediction_market_agent_tooling.markets.seer.exceptions import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 
 
-def _make_cache_key(
-    *args: t.Any,
-    token: ChecksumAddress,
-    collateral_exchange_amount: CollateralToken | None = None,
-) -> str:
-    """
-    Generate a unique cache key based on a token address and optional collateral token.
-    """
-
-    if collateral_exchange_amount is None:
-        return f"{token}-no_collateral"
-
-    return "-".join(
-        [
-            token,
-            collateral_exchange_amount.symbol,
-            str(collateral_exchange_amount.value),
-        ]
-    )
+class Prices(BaseModel):
+    priceOfCollateralInAskingToken: CollateralToken
+    priceOfAskingTokenInCollateral: CollateralToken
 
 
 class PriceManager:
@@ -67,17 +49,17 @@ class PriceManager:
                 f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
             )
 
-    @cached(TTLCache(maxsize=100, ttl=5 * 60), key=_make_cache_key)
-    def get_price_for_token(
+    def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
+        return self.get_amount_of_token_in_collateral(token, CollateralToken(1))
+
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_collateral_in_token(
         self,
         token: ChecksumAddress,
-        collateral_exchange_amount: CollateralToken | None = None,
+        collateral_exchange_amount: CollateralToken,
     ) -> CollateralToken | None:
-        collateral_exchange_amount = (
-            collateral_exchange_amount
-            if collateral_exchange_amount is not None
-            else CollateralToken(1)
-        )
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return collateral_exchange_amount
 
         try:
             buy_token_amount = get_buy_token_amount_else_raise(
@@ -85,23 +67,51 @@ class PriceManager:
                 sell_token=self.seer_market.collateral_token_contract_address_checksummed,
                 buy_token=token,
             )
-            price = collateral_exchange_amount.as_wei / buy_token_amount
-            return CollateralToken(price)
+            return buy_token_amount.as_token
 
         except Exception as e:
             logger.warning(
                 f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
             )
-            return self.get_token_price_from_pools(token=token)
+            prices = self.get_token_price_from_pools(token=token)
+            return (
+                prices.priceOfCollateralInAskingToken * collateral_exchange_amount
+                if prices
+                else None
+            )
 
-    @staticmethod
-    def pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
-        return pool.token0.id.hex().lower() == token.lower()
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_token_in_collateral(
+        self,
+        token: ChecksumAddress,
+        token_exchange_amount: CollateralToken,
+    ) -> CollateralToken | None:
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return token_exchange_amount
+
+        try:
+            buy_collateral_amount = get_buy_token_amount_else_raise(
+                sell_amount=token_exchange_amount.as_wei,
+                sell_token=token,
+                buy_token=self.seer_market.collateral_token_contract_address_checksummed,
+            )
+            return buy_collateral_amount.as_token
+
+        except Exception as e:
+            logger.warning(
+                f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
+            )
+            prices = self.get_token_price_from_pools(token=token)
+            return (
+                prices.priceOfAskingTokenInCollateral * token_exchange_amount
+                if prices
+                else None
+            )
 
     def get_token_price_from_pools(
         self,
         token: ChecksumAddress,
-    ) -> CollateralToken | None:
+    ) -> Prices | None:
         pool = SeerSubgraphHandler().get_pool_by_token(
             token_address=token,
             collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
@@ -111,15 +121,24 @@ class PriceManager:
             logger.warning(f"Could not find a pool for {token=}")
             return None
 
-        # The mapping below is odd but surprisingly the Algebra subgraph delivers the token1Price
-        # for the token0 and the token0Price for the token1 pool.
-        # For example, in a outcomeYES (token0)/sDAI pool (token1), token1Price is the price of outcomeYES in units of sDAI.
-        price = (
-            pool.token1Price
-            if self.pool_token0_matches_token(token=token, pool=pool)
-            else pool.token0Price
+        if (
+            Web3.to_checksum_address(pool.token0.id)
+            == self.seer_market.collateral_token_contract_address_checksummed
+        ):
+            price_coll_in_asking = (
+                pool.token1Price
+            )  # how many outcome tokens per 1 collateral
+            price_asking_in_coll = (
+                pool.token0Price
+            )  # how many collateral tokens per 1 outcome
+        else:
+            price_coll_in_asking = pool.token0Price
+            price_asking_in_coll = pool.token1Price
+
+        return Prices(
+            priceOfCollateralInAskingToken=price_coll_in_asking,
+            priceOfAskingTokenInCollateral=price_asking_in_coll,
         )
-        return price
 
     def build_probability_map(self) -> dict[OutcomeStr, Probability]:
         # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
@@ -160,6 +179,6 @@ class PriceManager:
             outcome = self.seer_market.outcomes[
                 self.seer_market.wrapped_tokens.index(outcome_token)
             ]
-            normalized_prices[OutcomeStr(outcome)] = new_price
+            normalized_prices[outcome] = new_price
 
         return normalized_prices