Enable monitoring of Omen market

prediction_market_agent_tooling/benchmark/utils.py

@@ -258,35 +258,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

@@ -10,12 +10,11 @@
     schedule_deployed_gcp_function,
 )
 from prediction_market_agent_tooling.deploy.gcp.utils import gcp_function_is_active
-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
+
+MAX_AVAILABLE_MARKETS = 20
 
 
 class DeployableAgent:
@@ -120,7 +119,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

@@ -26,30 +26,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:

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.gtypes import Mana, mana_type
+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,
-            p_yes=Probability(model.pool.YES),
+            resolution=model.get_resolution_enum() if model.isResolved else None,
+            created_time=model.createdTime,
+            p_yes=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}")

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -17,6 +17,7 @@
     BetAmount,
     Currency,
     ProfitAmount,
+    Resolution,
     ResolvedBet,
 )
 from prediction_market_agent_tooling.tools.utils import check_not_none
@@ -50,6 +51,20 @@ class OmenMarket(BaseModel):
     outcomeTokenAmounts: list[OmenOutcomeToken]
     outcomeTokenMarginalPrices: t.Optional[list[xDai]]
     fee: t.Optional[Wei]
+    resolutionTimestamp: t.Optional[int] = None
+    answerFinalizedTimestamp: t.Optional[int] = None
+    currentAnswer: t.Optional[str] = None
+    creationTimestamp: t.Optional[int] = None
+
+    @property
+    def is_open(self) -> bool:
+        return self.currentAnswer is None
+
+    @property
+    def is_resolved(self) -> bool:
+        return (
+            self.answerFinalizedTimestamp is not None and self.currentAnswer is not None
+        )
 
     @property
     def market_maker_contract_address(self) -> HexAddress:
@@ -75,30 +90,73 @@ def outcomeTokenProbabilities(self) -> t.Optional[list[Probability]]:
             else None
         )
 
-    @property
-    def p_yes(self) -> Probability:
-        return check_not_none(
-            self.outcomeTokenProbabilities,
-            "outcomeTokenProbabilities not available",
-        )[self.outcomes.index(OMEN_TRUE_OUTCOME)]
-
     @property
     def p_no(self) -> Probability:
         return Probability(1 - self.p_yes)
 
+    @property
+    def p_yes(self) -> Probability:
+        """
+        Calculate the probability of the outcomes from the relative token amounts.
+
+        Note, not all markets reliably have outcomeTokenMarginalPrices, hence the
+        need for this method.
+        """
+        if self.outcomeTokenAmounts is None:
+            raise ValueError(
+                f"Market with title {self.title} has no outcomeTokenAmounts."
+            )
+        if len(self.outcomeTokenAmounts) != 2:
+            raise ValueError(
+                f"Market with title {self.title} has {len(self.outcomeTokenAmounts)} outcomes."
+            )
+        true_index = self.outcomes.index(OMEN_TRUE_OUTCOME)
+
+        if sum(self.outcomeTokenAmounts) == 0:
+            return Probability(0.5)
+
+        return Probability(
+            1 - self.outcomeTokenAmounts[true_index] / sum(self.outcomeTokenAmounts)
+        )
+
     def __repr__(self) -> str:
         return f"Omen's market: {self.title}"
 
+    @property
+    def is_binary(self) -> bool:
+        return len(self.outcomes) == 2
+
+    @property
+    def boolean_outcome(self) -> bool:
+        if not self.is_binary:
+            raise ValueError(
+                f"Market with title {self.title} is not binary, it has {len(self.outcomes)} outcomes."
+            )
+        if not self.is_resolved:
+            raise ValueError(f"Bet with title {self.title} is not resolved.")
+
+        outcome: str = self.outcomes[int(check_not_none(self.currentAnswer), 16)]
+        return get_boolean_outcome(outcome)
+
+    def get_resolution_enum(self) -> t.Optional[Resolution]:
+        if not self.is_resolved:
+            return None
+        if self.boolean_outcome:
+            return Resolution.YES
+        else:
+            return Resolution.NO
+
 
 class OmenBetCreator(BaseModel):
     id: HexAddress
 
 
-class OmenBetFPMM(BaseModel):
+class OmenBetFPMM(BaseModel):  # TODO replace with OmenMarket
     id: HexAddress
     outcomes: list[str]
     title: str
     answerFinalizedTimestamp: t.Optional[int] = None
+    resolutionTimestamp: t.Optional[int] = None
     currentAnswer: t.Optional[str] = None
     isPendingArbitration: bool
     arbitrationOccurred: bool
@@ -179,6 +237,8 @@ def to_generic_resolved_bet(self) -> ResolvedBet:
             created_time=datetime.fromtimestamp(self.creationTimestamp),
             market_question=self.title,
             market_outcome=self.fpmm.boolean_outcome,
-            resolved_time=datetime.fromtimestamp(self.fpmm.answerFinalizedTimestamp),  # type: ignore # TODO Mypy doesn't understand that self.fpmm.is_resolved is True and therefore timestamp is known non-None
+            resolved_time=datetime.fromtimestamp(
+                check_not_none(self.fpmm.resolutionTimestamp)
+            ),
             profit=self.get_profit(),
         )