prediction-market-agent-tooling 0.66.4__tar.gz → 0.66.6__tar.gz

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/PKG-INFO

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

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/deploy/agent.py

@@ -19,9 +19,11 @@ from prediction_market_agent_tooling.deploy.trade_interval import (
 )
 from prediction_market_agent_tooling.gtypes import USD, OutcomeToken, xDai
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket, FilterBy
+from prediction_market_agent_tooling.markets.agent_market import (
+    MarketType as AgentMarketType,
+)
 from prediction_market_agent_tooling.markets.agent_market import (
-    AgentMarket,
-    FilterBy,
     ProcessedMarket,
     ProcessedTradedMarket,
     SortBy,
@@ -335,6 +337,15 @@ class DeployablePredictionAgent(DeployableAgent):
             return True
         return False
 
+    @property
+    def agent_market_type(self) -> AgentMarketType:
+        if self.fetch_scalar_markets:
+            return AgentMarketType.SCALAR
+        elif self.fetch_categorical_markets:
+            return AgentMarketType.CATEGORICAL
+        else:
+            return AgentMarketType.BINARY
+
     def get_markets(
         self,
         market_type: MarketType,
@@ -343,14 +354,16 @@ class DeployablePredictionAgent(DeployableAgent):
         Override this method to customize what markets will fetch for processing.
         """
         cls = market_type.market_class
+
+        agent_market_type = self.agent_market_type
+
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_markets(
             limit=self.n_markets_to_fetch,
             sort_by=self.get_markets_sort_by,
             filter_by=self.get_markets_filter_by,
             created_after=self.trade_on_markets_created_after,
-            fetch_categorical_markets=self.fetch_categorical_markets,
-            fetch_scalar_markets=self.fetch_scalar_markets,
+            market_type=agent_market_type,
         )
         return available_markets
 
@@ -628,7 +641,12 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         api_keys = APIKeys()
         user_id = market.get_user_id(api_keys=api_keys)
 
-        existing_position = market.get_position(user_id=user_id)
+        try:
+            existing_position = market.get_position(user_id=user_id)
+        except Exception as e:
+            logger.warning(f"Could not get position for user {user_id}, exception {e}")
+            return None
+
         trades = self.build_trades(
             market=market,
             answer=processed_market.answer,

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/agent_market.py

@@ -64,6 +64,13 @@ class FilterBy(str, Enum):
     NONE = "none"
 
 
+class MarketType(str, Enum):
+    ALL = "all"
+    CATEGORICAL = "categorical"
+    SCALAR = "scalar"
+    BINARY = "binary"
+
+
 class AgentMarket(BaseModel):
     """
     Common market class that can be created from vendor specific markets.
@@ -369,8 +376,8 @@ class AgentMarket(BaseModel):
         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["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")
 

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -12,6 +12,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    MarketType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.manifold.api import (
@@ -110,8 +111,8 @@ class ManifoldAgentMarket(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["ManifoldAgentMarket"]:
         sort: t.Literal["newest", "close-date"] | None
         if sort_by == SortBy.CLOSING_SOONEST:

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/markets.py

@@ -3,11 +3,11 @@ from enum import Enum
 
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
 from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket, FilterBy
 from prediction_market_agent_tooling.markets.agent_market import (
-    AgentMarket,
-    FilterBy,
-    SortBy,
+    MarketType as AgentMarketType,
 )
+from prediction_market_agent_tooling.markets.agent_market import SortBy
 from prediction_market_agent_tooling.markets.manifold.manifold import (
     ManifoldAgentMarket,
 )
@@ -68,7 +68,7 @@ def get_binary_markets(
     sort_by: SortBy = SortBy.NONE,
     excluded_questions: set[str] | None = None,
     created_after: DatetimeUTC | None = None,
-    fetch_scalar_markets: bool = False,
+    agent_market_type: AgentMarketType = AgentMarketType.BINARY,
 ) -> t.Sequence[AgentMarket]:
     agent_market_class = MARKET_TYPE_TO_AGENT_MARKET[market_type]
     markets = agent_market_class.get_markets(
@@ -77,6 +77,6 @@ def get_binary_markets(
         filter_by=filter_by,
         created_after=created_after,
         excluded_questions=excluded_questions,
-        fetch_scalar_markets=fetch_scalar_markets,
+        market_type=agent_market_type,
     )
     return markets

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -9,6 +9,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    MarketType,
     ProcessedMarket,
     SortBy,
 )
@@ -66,14 +67,15 @@ class MetaculusAgentMarket(AgentMarket):
         )
 
     @staticmethod
-    def get_markets(
+    def get_markets(  # type: ignore[override]
         limit: int,
         sort_by: SortBy = SortBy.NONE,
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         tournament_id: int | None = None,
-        fetch_scalar_markets: bool = False,
+        market_type: MarketType = MarketType.ALL,
+        include_conditional_markets: bool = False,
     ) -> t.Sequence["MetaculusAgentMarket"]:
         order_by: str | None
         if sort_by == SortBy.NONE:

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -25,6 +25,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    MarketType,
     ProcessedMarket,
     ProcessedTradedMarket,
     SortBy,
@@ -379,9 +380,11 @@ class OmenAgentMarket(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["OmenAgentMarket"]:
+        fetch_categorical_markets = market_type == MarketType.CATEGORICAL
+
         return [
             OmenAgentMarket.from_data_model(m)
             for m in OmenSubgraphHandler().get_omen_markets_simple(

prediction_market_agent_tooling-0.66.6/prediction_market_agent_tooling/markets/polymarket/api.py

@@ -0,0 +1,123 @@
+import typing as t
+from enum import Enum
+from urllib.parse import urljoin
+
+import httpx
+import tenacity
+
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.polymarket.data_models import (
+    POLYMARKET_FALSE_OUTCOME,
+    POLYMARKET_TRUE_OUTCOME,
+    PolymarketGammaResponse,
+    PolymarketGammaResponseDataItem,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.httpx_cached_client import HttpxCachedClient
+from prediction_market_agent_tooling.tools.utils import response_to_model
+
+MARKETS_LIMIT = 100  # Polymarket will only return up to 100 markets
+POLYMARKET_GAMMA_API_BASE_URL = "https://gamma-api.polymarket.com/"
+
+
+class PolymarketOrderByEnum(str, Enum):
+    LIQUIDITY = "liquidity"
+    START_DATE = "startDate"
+    END_DATE = "endDate"
+    VOLUME_24HR = "volume24hr"
+
+
+@tenacity.retry(
+    stop=tenacity.stop_after_attempt(2),
+    wait=tenacity.wait_fixed(1),
+    after=lambda x: logger.debug(
+        f"get_polymarkets_with_pagination failed, {x.attempt_number=}."
+    ),
+)
+def get_polymarkets_with_pagination(
+    limit: int,
+    created_after: t.Optional[DatetimeUTC] = None,
+    active: bool | None = None,
+    closed: bool | None = None,
+    excluded_questions: set[str] | None = None,
+    only_binary: bool = True,
+    archived: bool = False,
+    ascending: bool = False,
+    order_by: PolymarketOrderByEnum = PolymarketOrderByEnum.VOLUME_24HR,
+) -> list[PolymarketGammaResponseDataItem]:
+    """
+    Binary markets have len(model.markets) == 1.
+    Categorical markets have len(model.markets) > 1
+    """
+    client: httpx.Client = HttpxCachedClient(ttl=60).get_client()
+    all_markets: list[PolymarketGammaResponseDataItem] = []
+    offset = 0
+    remaining = limit
+
+    while remaining > 0:
+        # Calculate how many items to request in this batch (up to MARKETS_LIMIT or remaining)
+        # By default we fetch many markets because not possible to filter by binary/categorical
+        batch_size = MARKETS_LIMIT
+
+        # Build query parameters, excluding None values
+        params = {
+            "limit": batch_size,
+            "active": str(active).lower() if active is not None else None,
+            "archived": str(archived).lower(),
+            "closed": str(closed).lower() if closed is not None else None,
+            "order": order_by.value,
+            "ascending": str(ascending).lower(),
+            "offset": offset,
+        }
+        params_not_none = {k: v for k, v in params.items() if v is not None}
+        url = urljoin(
+            POLYMARKET_GAMMA_API_BASE_URL,
+            f"events/pagination",
+        )
+
+        r = client.get(url, params=params_not_none)
+        r.raise_for_status()
+
+        market_response = response_to_model(r, PolymarketGammaResponse)
+
+        markets_to_add = []
+        for m in market_response.data:
+            if excluded_questions and m.title in excluded_questions:
+                continue
+
+            sorted_outcome_list = sorted(m.markets[0].outcomes_list)
+            if only_binary:
+                # We keep markets that are only Yes,No
+                if len(m.markets) > 1 or sorted_outcome_list != [
+                    POLYMARKET_FALSE_OUTCOME,
+                    POLYMARKET_TRUE_OUTCOME,
+                ]:
+                    continue
+
+            if 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
+            ]
+
+        # Add the markets from this batch to our results
+        all_markets.extend(markets_to_add)
+
+        # Update counters
+        offset += len(market_response.data)
+        remaining -= len(markets_to_add)
+
+        # Stop if we've reached our limit or there are no more results
+        if (
+            remaining <= 0
+            or not market_response.pagination.hasMore
+            or len(market_response.data) == 0
+        ):
+            break
+
+    # Return exactly the number of items requested (in case we got more due to batch size)
+    return all_markets[:limit]

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/polymarket/data_models.py

@@ -1,3 +1,5 @@
+import json
+
 from pydantic import BaseModel
 
 from prediction_market_agent_tooling.gtypes import USDC, OutcomeStr, Probability
@@ -5,9 +7,9 @@ from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
     POLYMARKET_FALSE_OUTCOME,
     POLYMARKET_TRUE_OUTCOME,
-    PolymarketFullMarket,
     construct_polymarket_url,
 )
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
@@ -26,6 +28,63 @@ class PolymarketToken(BaseModel):
     winner: bool
 
 
+class PolymarketGammaMarket(BaseModel):
+    conditionId: HexBytes
+    outcomes: str
+    outcomePrices: str | None = None
+    marketMakerAddress: str
+    createdAt: DatetimeUTC
+    updatedAt: DatetimeUTC | None = None
+    archived: bool
+    questionId: str | None = None
+    clobTokenIds: str | None = None  # int-encoded hex
+
+    @property
+    def outcomes_list(self) -> list[OutcomeStr]:
+        return [OutcomeStr(i) for i in json.loads(self.outcomes)]
+
+    @property
+    def outcome_prices(self) -> list[float] | None:
+        if not self.outcomePrices:
+            return None
+        return [float(i) for i in json.loads(self.outcomePrices)]
+
+
+class PolymarketGammaTag(BaseModel):
+    label: str
+    slug: str
+
+
+class PolymarketGammaResponseDataItem(BaseModel):
+    id: str
+    slug: str
+    volume: float | None = None
+    startDate: DatetimeUTC
+    endDate: DatetimeUTC | None = None
+    liquidity: float | None = None
+    liquidityClob: float | None = None
+    title: str
+    description: str
+    archived: bool
+    closed: bool
+    active: bool
+    markets: list[PolymarketGammaMarket]
+    tags: list[PolymarketGammaTag]
+
+    @property
+    def url(self) -> str:
+        return construct_polymarket_url(self.slug)
+
+
+class PolymarketGammaPagination(BaseModel):
+    hasMore: bool
+
+
+class PolymarketGammaResponse(BaseModel):
+    data: list[PolymarketGammaResponseDataItem]
+    pagination: PolymarketGammaPagination
+
+
 class PolymarketMarket(BaseModel):
     enable_order_book: bool
     active: bool
@@ -89,19 +148,6 @@ class PolymarketMarket(BaseModel):
                 f"Should not happen, invalid winner tokens: {winner_tokens}"
             )
 
-    def fetch_full_market(self) -> PolymarketFullMarket | None:
-        return PolymarketFullMarket.fetch_from_url(self.url)
-
-    def fetch_if_its_a_main_market(self) -> bool:
-        # On Polymarket, there are markets that are actually a group of multiple Yes/No markets, for example https://polymarket.com/event/presidential-election-winner-2024.
-        # But API returns them individually, and then we receive questions such as "Will any other Republican Politician win the 2024 US Presidential Election?",
-        # which are naturally unpredictable without futher details.
-        # This is a heuristic to filter them out.
-        # Warning: This is a very slow operation, as it requires fetching the website. Use it only when necessary.
-        full_market = self.fetch_full_market()
-        # `full_market` can be None, if this class come from a multiple Yes/No market, becase then, the constructed URL is invalid (and there is now way to construct an valid one from the data we have).
-        return full_market is not None and full_market.is_main_market
-
 
 class MarketsEndpointResponse(BaseModel):
     limit: int

{prediction_market_agent_tooling-0.66.4 → prediction_market_agent_tooling-0.66.6}/prediction_market_agent_tooling/markets/polymarket/data_models_web.py

@@ -5,14 +5,11 @@ Keep in mind that not all fields were used so far, so there might be some bugs.
 These models are based on what Polymarket's website returns in the response, and `prediction_market_agent_tooling/markets/polymarket/data_models.py` are based on what their API returns.
 """
 
-import json
 import typing as t
 
-import requests
 from pydantic import BaseModel, field_validator
 
 from prediction_market_agent_tooling.gtypes import USDC, HexAddress, OutcomeStr
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
@@ -293,57 +290,6 @@ class PolymarketFullMarket(BaseModel):
             )
         return self.markets[0]
 
-    @staticmethod
-    def fetch_from_url(url: str) -> "PolymarketFullMarket | None":
-        """
-        Get the full market data from the Polymarket website.
-
-        Returns None if this market's url returns "Oops...we didn't forecast this", see `check_if_its_a_main_market` method for more details.
-
-        Warning: This is a very slow operation, as it requires fetching the website. Use it only when necessary.
-        """
-        logger.info(f"Fetching full market from {url}")
-
-        # Fetch the website as a normal browser would.
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
-        }
-        content = requests.get(url, headers=headers).text
-
-        # Find the JSON with the data within the content.
-        start_tag = """<script id="__NEXT_DATA__" type="application/json" crossorigin="anonymous">"""
-        start_idx = content.find(start_tag) + len(start_tag)
-        end_idx = content.find("</script>", start_idx)
-        response_data = content[start_idx:end_idx]
-
-        # Parsing.
-        response_dict = json.loads(response_data)
-        response_model = PolymarketWebResponse.model_validate(response_dict)
-
-        full_market_queries = [
-            q
-            for q in response_model.props.pageProps.dehydratedState.queries
-            if isinstance(q.state.data, PolymarketFullMarket)
-        ]
-
-        # We expect either 0 markets (if it doesn't exist) or 1 market.
-        if len(full_market_queries) not in (0, 1):
-            raise ValueError(
-                f"Unexpected number of queries in the response, please check it out and modify the code accordingly: `{response_dict}`"
-            )
-
-        # It will be `PolymarketFullMarket` thanks to the filter above.
-        market = (
-            t.cast(PolymarketFullMarket, full_market_queries[0].state.data)
-            if full_market_queries
-            else None
-        )
-
-        if market is None:
-            logger.warning(f"No polymarket found for {url}")
-
-        return market
-
 
 class PriceSide(BaseModel):
     price: USDC

prediction_market_agent_tooling-0.66.6/prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -0,0 +1,173 @@
+import typing as t
+
+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 (
+    PolymarketOrderByEnum,
+    get_polymarkets_with_pagination,
+)
+from prediction_market_agent_tooling.markets.polymarket.data_models import (
+    PolymarketGammaResponseDataItem,
+)
+from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
+    POLYMARKET_BASE_URL,
+)
+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):
+    """
+    Polymarket's market class that can be used by agents to make predictions.
+    """
+
+    base_url: t.ClassVar[str] = POLYMARKET_BASE_URL
+
+    # Based on https://docs.polymarket.com/#fees, there are currently no fees, except for transactions fees.
+    # However they do have `maker_fee_base_rate` and `taker_fee_base_rate`, but impossible to test out our implementation without them actually taking the fees.
+    # But then in the new subgraph API, they have `fee: BigInt! (Percentage fee of trades taken by market maker. A 2% fee is represented as 2*10^16)`.
+    # TODO: Check out the fees while integrating the subgraph API or if we implement placing of bets on Polymarket.
+    fees: MarketFees = MarketFees.get_zero_fees()
+
+    @staticmethod
+    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.title,
+            description=model.description,
+            outcomes=outcomes,
+            resolution=resolution,
+            created_time=model.startDate,
+            close_time=model.endDate,
+            url=model.url,
+            volume=CollateralToken(model.volume) if model.volume else None,
+            outcome_token_pool=None,
+            probabilities=probabilities,
+        )
+
+    def get_tiny_bet_amount(self) -> CollateralToken:
+        raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
+
+    def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
+        raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
+
+    @staticmethod
+    def get_markets(
+        limit: int,
+        sort_by: SortBy = SortBy.NONE,
+        filter_by: FilterBy = FilterBy.OPEN,
+        created_after: t.Optional[DatetimeUTC] = None,
+        excluded_questions: set[str] | None = None,
+        market_type: MarketType = MarketType.ALL,
+        include_conditional_markets: bool = False,
+    ) -> t.Sequence["PolymarketAgentMarket"]:
+        closed: bool | None
+
+        if filter_by == FilterBy.OPEN:
+            closed = False
+        elif filter_by == FilterBy.RESOLVED:
+            closed = True
+        elif filter_by == FilterBy.NONE:
+            closed = None
+        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, condition_models_dict)
+            for m in markets
+        ]