Enable monitoring of Omen market

prediction_market_agent_tooling/benchmark/utils.py

@@ -269,35 +269,6 @@ def get_manifold_markets_paged(
     return markets
 
 
-def get_manifold_markets_dated(
-    oldest_date: datetime,
-    filter_: t.Literal[
-        "open", "closed", "resolved", "closing-this-month", "closing-next-month"
-    ] = "open",
-    excluded_questions: set[str] | None = None,
-) -> t.List[Market]:
-    markets: list[Market] = []
-
-    offset = 0
-    while True:
-        new_markets = get_manifold_markets(
-            limit=MANIFOLD_API_LIMIT,
-            offset=offset,
-            filter_=filter_,
-            sort="newest",  # Enforce sorting by newest, because there aren't date filters on the API.
-        )
-        if not new_markets:
-            break
-        for market in new_markets:
-            if market.created_time < oldest_date:
-                return markets
-            if not excluded_questions or market.question not in excluded_questions:
-                markets.append(market)
-            offset += 1
-
-    return markets
-
-
 def get_polymarket_markets(
     limit: int = 100,
     active: bool | None = True,

prediction_market_agent_tooling/deploy/agent.py

@@ -18,15 +18,14 @@
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket, SortBy
 from prediction_market_agent_tooling.markets.data_models import BetAmount
-from prediction_market_agent_tooling.markets.markets import (
-    MarketType,
-    get_binary_markets,
-)
+from prediction_market_agent_tooling.markets.markets import MARKET_TYPE_MAP, MarketType
 from prediction_market_agent_tooling.monitor.monitor_app import DEPLOYED_AGENT_TYPE_MAP
 from prediction_market_agent_tooling.tools.utils import DatetimeWithTimezone, utcnow
 
+MAX_AVAILABLE_MARKETS = 20
+
 
 class DeployableAgent:
     def __init__(self) -> None:
@@ -154,7 +153,14 @@ def calculate_bet_amount(self, answer: bool, market: AgentMarket) -> BetAmount:
         return market.get_tiny_bet_amount()
 
     def run(self, market_type: MarketType, _place_bet: bool = True) -> None:
-        available_markets = get_binary_markets(market_type)
+        cls = MARKET_TYPE_MAP.get(market_type)
+        if not cls:
+            raise ValueError(f"Unknown market type: {market_type}")
+
+        # Fetch the soonest closing markets to choose from
+        available_markets = cls.get_binary_markets(
+            limit=MAX_AVAILABLE_MARKETS, sort_by=SortBy.CLOSING_SOONEST
+        )
         markets = self.pick_markets(available_markets)
         for market in markets:
             result = self.answer_binary_market(market)

prediction_market_agent_tooling/markets/agent_market.py

@@ -1,10 +1,26 @@
 import typing as t
+from datetime import datetime
 from decimal import Decimal
+from enum import Enum
 
 from pydantic import BaseModel
 
 from prediction_market_agent_tooling.gtypes import Probability
-from prediction_market_agent_tooling.markets.data_models import BetAmount, Currency
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Currency,
+    Resolution,
+)
+
+
+class SortBy(str, Enum):
+    CLOSING_SOONEST = "closing-soonest"
+    NEWEST = "newest"
+
+
+class FilterBy(str, Enum):
+    OPEN = "open"
+    RESOLVED = "resolved"
 
 
 class AgentMarket(BaseModel):
@@ -18,6 +34,8 @@ class AgentMarket(BaseModel):
     id: str
     question: str
     outcomes: list[str]
+    resolution: t.Optional[Resolution] = None
+    created_time: datetime
     p_yes: Probability
 
     @property
@@ -34,9 +52,20 @@ def place_bet(self, outcome: bool, amount: BetAmount) -> None:
         raise NotImplementedError("Subclasses must implement this method")
 
     @staticmethod
-    def get_binary_markets(limit: int) -> list["AgentMarket"]:
+    def get_binary_markets(
+        limit: int,
+        sort_by: SortBy,
+        filter_by: FilterBy = FilterBy.OPEN,
+        created_after: t.Optional[datetime] = None,
+    ) -> list["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")
 
+    def is_resolved(self) -> bool:
+        return self.resolution is not None
+
+    def has_successful_resolution(self) -> bool:
+        return self.resolution in [Resolution.YES, Resolution.NO]
+
     def get_outcome_str(self, outcome_index: int) -> str:
         try:
             return self.outcomes[outcome_index]

prediction_market_agent_tooling/markets/data_models.py

@@ -14,6 +14,7 @@ class Resolution(str, Enum):
     YES = "YES"
     NO = "NO"
     CANCEL = "CANCEL"
+    MKT = "MKT"
 
 
 class BetAmount(BaseModel):

prediction_market_agent_tooling/markets/manifold/api.py

@@ -8,7 +8,6 @@
 from prediction_market_agent_tooling.markets.data_models import (
     BetAmount,
     Currency,
-    Resolution,
     ResolvedBet,
 )
 from prediction_market_agent_tooling.markets.manifold.data_models import (
@@ -26,30 +25,54 @@
 Note: There is an existing wrapper here: https://github.com/vluzko/manifoldpy. Consider using that instead.
 """
 
+MARKETS_LIMIT = 1000  # Manifold will only return up to 1000 markets
+
 
 def get_manifold_binary_markets(
     limit: int,
     term: str = "",
     topic_slug: t.Optional[str] = None,
-    sort: str = "liquidity",
+    sort: t.Literal["liquidity", "score", "newest", "close-date"] = "liquidity",
+    filter_: t.Literal[
+        "open", "closed", "resolved", "closing-this-month", "closing-next-month"
+    ] = "open",
+    created_after: t.Optional[datetime] = None,
 ) -> list[ManifoldMarket]:
+    all_markets: list[ManifoldMarket] = []
+
     url = "https://api.manifold.markets/v0/search-markets"
     params: dict[str, t.Union[str, int, float]] = {
         "term": term,
         "sort": sort,
-        "limit": limit,
-        "filter": "open",
+        "filter": filter_,
+        "limit": min(limit, MARKETS_LIMIT),
         "contractType": "BINARY",
     }
     if topic_slug:
         params["topicSlug"] = topic_slug
-    response = requests.get(url, params=params)
 
-    response.raise_for_status()
-    data = response.json()
+    offset = 0
+    while True:
+        params["offset"] = offset
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        markets = [ManifoldMarket.model_validate(x) for x in data]
+
+        if not markets:
+            break
+
+        for market in markets:
+            if created_after and market.createdTime < created_after:
+                continue
+            all_markets.append(market)
+
+        if len(all_markets) >= limit:
+            break
+
+        offset += len(markets)
 
-    markets = [ManifoldMarket.model_validate(x) for x in data]
-    return markets
+    return all_markets[:limit]
 
 
 def pick_binary_market() -> ManifoldMarket:
@@ -137,7 +160,7 @@ def manifold_to_generic_resolved_bet(bet: ManifoldBet) -> ResolvedBet:
     if not market.resolutionTime:
         raise ValueError(f"Market {market.id} has no resolution time.")
 
-    market_outcome = market.get_resolution_enum() == Resolution.YES
+    market_outcome = market.get_resolved_boolean_outcome()
     return ResolvedBet(
         amount=BetAmount(amount=bet.amount, currency=Currency.Mana),
         outcome=bet.get_resolved_boolean_outcome(),

prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -30,22 +30,22 @@ class ManifoldMarket(BaseModel):
     creatorId: str
     closeTime: datetime
     createdTime: datetime
-    creatorAvatarUrl: str
+    creatorAvatarUrl: t.Optional[str] = None
     creatorName: str
     creatorUsername: str
     isResolved: bool
-    resolution: t.Optional[str] = None
+    resolution: t.Optional[Resolution] = None
     resolutionTime: t.Optional[datetime] = None
     lastBetTime: t.Optional[datetime] = None
     lastCommentTime: t.Optional[datetime] = None
     lastUpdatedTime: datetime
     mechanism: str
     outcomeType: str
-    p: float
+    p: t.Optional[float] = None
     pool: ManifoldPool
     probability: Probability
     slug: str
-    totalLiquidity: Mana
+    totalLiquidity: t.Optional[Mana] = None
     uniqueBettorCount: int
     url: str
     volume: Mana
@@ -55,14 +55,19 @@ class ManifoldMarket(BaseModel):
     def outcomes(self) -> list[str]:
         return list(self.pool.model_fields.keys())
 
-    def get_resolution_enum(self) -> Resolution:
-        return Resolution(self.resolution)
+    def get_resolved_boolean_outcome(self) -> bool:
+        if self.resolution == Resolution.YES:
+            return True
+        elif self.resolution == Resolution.NO:
+            return False
+        else:
+            should_not_happen(f"Unexpected bet outcome string, '{self.resolution}'.")
 
     def is_resolved_non_cancelled(self) -> bool:
         return (
             self.isResolved
             and self.resolutionTime is not None
-            and self.get_resolution_enum() != Resolution.CANCEL
+            and self.resolution not in [Resolution.CANCEL, Resolution.MKT]
         )
 
     def __repr__(self) -> str:
@@ -139,16 +144,15 @@ class ManifoldBet(BaseModel):
     orderAmount: t.Optional[Mana] = None
     fills: t.Optional[list[ManifoldBetFills]] = None
     createdTime: datetime
-    outcome: str
+    outcome: Resolution
 
     def get_resolved_boolean_outcome(self) -> bool:
-        outcome = Resolution(self.outcome)
-        if outcome == Resolution.YES:
+        if self.outcome == Resolution.YES:
             return True
-        elif outcome == Resolution.NO:
+        elif self.outcome == Resolution.NO:
             return False
         else:
-            should_not_happen(f"Unexpected bet outcome string, '{outcome.value}'.")
+            should_not_happen(f"Unexpected bet outcome string, '{self.outcome.value}'.")
 
     def get_profit(self, market_outcome: bool) -> ProfitAmount:
         profit = (

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -1,9 +1,14 @@
 import typing as t
+from datetime import datetime
 from decimal import Decimal
 from math import ceil
 
 from prediction_market_agent_tooling.gtypes import Mana, Probability, mana_type
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    FilterBy,
+    SortBy,
+)
 from prediction_market_agent_tooling.markets.betting_strategies import (
     minimum_bet_to_win,
 )
@@ -44,12 +49,40 @@ def from_data_model(model: ManifoldMarket) -> "ManifoldAgentMarket":
             id=model.id,
             question=model.question,
             outcomes=model.outcomes,
+            resolution=model.resolution,
+            created_time=model.createdTime,
             p_yes=Probability(model.probability),
         )
 
     @staticmethod
-    def get_binary_markets(limit: int) -> list[AgentMarket]:
+    def get_binary_markets(
+        limit: int,
+        sort_by: SortBy,
+        filter_by: FilterBy = FilterBy.OPEN,
+        created_after: t.Optional[datetime] = None,
+    ) -> list[AgentMarket]:
+        sort: t.Literal["newest", "close-date"]
+        if sort_by == SortBy.CLOSING_SOONEST:
+            sort = "close-date"
+        elif sort_by == SortBy.NEWEST:
+            sort = "newest"
+        else:
+            raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        filter_: t.Literal["open", "resolved"]
+        if filter_by == FilterBy.OPEN:
+            filter_ = "open"
+        elif filter_by == FilterBy.RESOLVED:
+            filter_ = "resolved"
+        else:
+            raise ValueError(f"Unknown filter_by: {filter_by}")
+
         return [
             ManifoldAgentMarket.from_data_model(m)
-            for m in get_manifold_binary_markets(limit=limit, sort="close-date")
+            for m in get_manifold_binary_markets(
+                limit=limit,
+                sort=sort,
+                created_after=created_after,
+                filter_=filter_,
+            )
         ]

prediction_market_agent_tooling/markets/markets.py

@@ -16,11 +16,3 @@ class MarketType(str, Enum):
     MarketType.MANIFOLD: ManifoldAgentMarket,
     MarketType.OMEN: OmenAgentMarket,
 }
-
-
-def get_binary_markets(market_type: MarketType, limit: int = 20) -> list[AgentMarket]:
-    cls = MARKET_TYPE_MAP.get(market_type)
-    if cls:
-        return cls.get_binary_markets(limit=limit)
-    else:
-        raise ValueError(f"Unknown market type: {market_type}")