prediction-market-agent-tooling 0.65.7__tar.gz → 0.65.9__tar.gz

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/PKG-INFO

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

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/deploy/agent.py

@@ -33,10 +33,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     ProbabilisticAnswer,
     Trade,
 )
-from prediction_market_agent_tooling.markets.markets import (
-    MarketType,
-    have_bet_on_market_since,
-)
+from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.markets.omen.omen import (
     send_keeping_token_to_eoa_xdai,
 )
@@ -219,7 +216,6 @@ class DeployablePredictionAgent(DeployableAgent):
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
-        self.have_bet_on_market_since = observe()(self.have_bet_on_market_since)  # type: ignore[method-assign]
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
         self.answer_categorical_market = observe()(self.answer_categorical_market)  # type: ignore[method-assign]
@@ -265,16 +261,13 @@ class DeployablePredictionAgent(DeployableAgent):
                 f"{api_keys=} doesn't have enough operational balance."
             )
 
-    def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
-        return have_bet_on_market_since(keys=APIKeys(), market=market, since=since)
-
     def verify_market(self, market_type: MarketType, market: AgentMarket) -> bool:
         """
         Subclasses can implement their own logic instead of this one, or on top of this one.
         By default, it allows only markets where user didn't bet recently and it's a reasonable question.
         """
-        if self.have_bet_on_market_since(
-            market, since=self.same_market_trade_interval.get(market=market)
+        if market.have_bet_on_market_since(
+            keys=APIKeys(), since=self.same_market_trade_interval.get(market=market)
         ):
             logger.info(
                 f"Market already bet on within {self.same_market_trade_interval}."

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/agent_market.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 from enum import Enum
 from math import prod
 
@@ -115,6 +116,9 @@ class AgentMarket(BaseModel):
                 )
         return outcome_token_pool
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        raise NotImplementedError("Subclasses must implement this method")
+
     def get_outcome_token_pool_by_outcome(self, outcome: OutcomeStr) -> OutcomeToken:
         if self.outcome_token_pool is None or not self.outcome_token_pool:
             return OutcomeToken(0)

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -12,7 +12,9 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.markets.manifold.utils import validate_resolution
+from prediction_market_agent_tooling.markets.manifold.utils import (
+    validate_manifold_resolution,
+)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, should_not_happen
 
 MANIFOLD_BASE_URL = "https://manifold.markets"
@@ -110,7 +112,7 @@ class ManifoldMarket(BaseModel):
 
     @field_validator("resolution", mode="before")
     def validate_resolution(cls, v: t.Any) -> Resolution:
-        return validate_resolution(v)
+        return validate_manifold_resolution(v)
 
     def __repr__(self) -> str:
         return f"Manifold's market: {self.question}"
@@ -204,7 +206,7 @@ class ManifoldBet(BaseModel):
 
     @field_validator("outcome", mode="before")
     def validate_resolution(cls, v: t.Any) -> Resolution:
-        return validate_resolution(v)
+        return validate_manifold_resolution(v)
 
     def get_resolved_outcome(self) -> OutcomeStr:
         if self.outcome.outcome:

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -15,6 +16,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
 )
 from prediction_market_agent_tooling.markets.manifold.api import (
     get_authenticated_user,
+    get_manifold_bets,
     get_manifold_binary_markets,
     get_manifold_market,
     place_bet,
@@ -24,7 +26,7 @@ from prediction_market_agent_tooling.markets.manifold.data_models import (
     FullManifoldMarket,
     usd_to_mana,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
 
 
 class ManifoldAgentMarket(AgentMarket):
@@ -51,6 +53,20 @@ class ManifoldAgentMarket(AgentMarket):
     def get_tiny_bet_amount(self) -> CollateralToken:
         return CollateralToken(1)
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        start_time = utcnow() - since
+        recently_betted_questions = set(
+            get_manifold_market(b.contractId).question
+            for b in get_manifold_bets(
+                user_id=get_authenticated_user(
+                    keys.manifold_api_key.get_secret_value()
+                ).id,
+                start_time=start_time,
+                end_time=None,
+            )
+        )
+        return self.question in recently_betted_questions
+
     def place_bet(self, outcome: OutcomeStr, amount: USD) -> str:
         self.get_usd_in_token(amount)
         bet = place_bet(

prediction_market_agent_tooling-0.65.9/prediction_market_agent_tooling/markets/manifold/utils.py

@@ -0,0 +1,16 @@
+import typing as t
+
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+from prediction_market_agent_tooling.markets.data_models import Resolution
+
+MANIFOLD_CANCEL_OUTCOME = "CANCEL"
+
+
+def validate_manifold_resolution(v: t.Any) -> Resolution:
+    if isinstance(v, str):
+        return (
+            Resolution(outcome=OutcomeStr(v), invalid=False)
+            if v != MANIFOLD_CANCEL_OUTCOME
+            else Resolution(outcome=None, invalid=True)
+        )
+    raise ValueError(f"Expected a string, got {v} {type(v)}")

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/markets.py

@@ -1,8 +1,6 @@
 import typing as t
-from datetime import timedelta
 from enum import Enum
 
-from prediction_market_agent_tooling.config import APIKeys
 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 (
@@ -10,11 +8,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     FilterBy,
     SortBy,
 )
-from prediction_market_agent_tooling.markets.manifold.api import (
-    get_authenticated_user,
-    get_manifold_bets,
-    get_manifold_market,
-)
 from prediction_market_agent_tooling.markets.manifold.manifold import (
     ManifoldAgentMarket,
 )
@@ -22,18 +15,11 @@ from prediction_market_agent_tooling.markets.metaculus.metaculus import (
     MetaculusAgentMarket,
 )
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
-from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
-    OmenSubgraphHandler,
-)
 from prediction_market_agent_tooling.markets.polymarket.polymarket import (
     PolymarketAgentMarket,
 )
 from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
-from prediction_market_agent_tooling.tools.utils import (
-    DatetimeUTC,
-    should_not_happen,
-    utcnow,
-)
+from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 class MarketType(str, Enum):
@@ -92,35 +78,3 @@ def get_binary_markets(
         excluded_questions=excluded_questions,
     )
     return markets
-
-
-def have_bet_on_market_since(
-    keys: APIKeys, market: AgentMarket, since: timedelta
-) -> bool:
-    start_time = utcnow() - since
-    recently_betted_questions = (
-        set(
-            get_manifold_market(b.contractId).question
-            for b in get_manifold_bets(
-                user_id=get_authenticated_user(
-                    keys.manifold_api_key.get_secret_value()
-                ).id,
-                start_time=start_time,
-                end_time=None,
-            )
-        )
-        if isinstance(market, ManifoldAgentMarket)
-        else (
-            set(
-                b.title
-                for b in OmenSubgraphHandler().get_bets(
-                    better_address=keys.bet_from_address,
-                    start_time=start_time,
-                    market_id=market.market_maker_contract_address_checksummed,
-                )
-            )
-            if isinstance(market, OmenAgentMarket)
-            else should_not_happen(f"Unknown market: {market}")
-        )
-    )
-    return market.question in recently_betted_questions

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -84,6 +84,7 @@ from prediction_market_agent_tooling.tools.utils import (
     DatetimeUTC,
     calculate_sell_amount_in_collateral,
     check_not_none,
+    utcnow,
 )
 from prediction_market_agent_tooling.tools.web3_utils import get_receipt_block_timestamp
 
@@ -157,6 +158,14 @@ class OmenAgentMarket(AgentMarket):
     def get_usd_in_token(self, x: USD) -> CollateralToken:
         return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        start_time = utcnow() - since
+        prev_bets = self.get_bets_made_since(
+            better_address=keys.bet_from_address, start_time=start_time
+        )
+
+        return self.id in [b.market_id for b in prev_bets]
+
     def liquidate_existing_positions(
         self,
         bet_outcome: OutcomeStr,

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -31,7 +31,11 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 from prediction_market_agent_tooling.tools.tokens.main_token import (
     MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES,
 )
-from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
+from prediction_market_agent_tooling.tools.utils import (
+    check_not_none,
+    extract_error_from_retry_error,
+    utcnow,
+)
 from prediction_market_agent_tooling.tools.web3_utils import ZERO_BYTES
 
 
@@ -264,14 +268,24 @@ def omen_resolve_market_tx(
     Market can be resolved after the answer if finalized on Reality.
     """
     oracle_contract = OmenOracleContract()
-    oracle_contract.resolve(
-        api_keys=api_keys,
-        question_id=market.question.id,
-        template_id=market.question.templateId,
-        question_raw=market.question.question_raw,
-        n_outcomes=market.question.n_outcomes,
-        web3=web3,
-    )
+    try:
+        oracle_contract.resolve(
+            api_keys=api_keys,
+            question_id=market.question.id,
+            template_id=market.question.templateId,
+            question_raw=market.question.question_raw,
+            n_outcomes=market.question.n_outcomes,
+            web3=web3,
+        )
+    except BaseException as e:
+        e = extract_error_from_retry_error(e)
+        if "condition not prepared or found" in str(e):
+            # We can't do anything about these, so just skip them with warning.
+            logger.warning(
+                f"Market {market.url=} not resolved, because `condition not prepared or found`, skipping."
+            )
+        else:
+            raise
 
 
 def find_resolution_on_other_markets(market: OmenMarket) -> Resolution | None:

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 
 from eth_typing import ChecksumAddress
 from web3 import Web3
@@ -52,6 +53,7 @@ from prediction_market_agent_tooling.tools.contract import (
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
+    get_orders_by_owner,
     get_trades_by_owner,
     swap_tokens_waiting,
 )
@@ -63,6 +65,7 @@ from prediction_market_agent_tooling.tools.tokens.usd import (
     get_token_in_usd,
     get_usd_in_token,
 )
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 # We place a larger bet amount by default than Omen so that cow presents valid quotes.
 SEER_TINY_BET_AMOUNT = USD(0.1)
@@ -272,6 +275,20 @@ class SeerAgentMarket(AgentMarket):
 
         # GnosisRouter withdraws sDai into wxDAI/xDai on its own, so no auto-withdraw needed by us.
 
+    def have_bet_on_market_since(self, keys: APIKeys, since: timedelta) -> bool:
+        """Check if the user has placed a bet on this market since a specific time using Cow API."""
+        # Cow endpoint doesn't allow us to filter by time.
+        start_time = utcnow() - since
+        prev_orders = get_orders_by_owner(owner=keys.bet_from_address)
+        for order in prev_orders:
+            if order.creationDate >= start_time and {
+                Web3.to_checksum_address(order.sellToken),
+                Web3.to_checksum_address(order.buyToken),
+            }.intersection(set(self.wrapped_tokens)):
+                return True
+
+        return False
+
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -1,4 +1,5 @@
 import asyncio
+import typing as t
 from datetime import timedelta
 
 import httpx
@@ -23,7 +24,6 @@ from cowdao_cowpy.order_book.generated.model import (
     OrderStatus,
     TokenAmount,
 )
-from cowdao_cowpy.subgraph.client import BaseModel
 from tenacity import (
     retry_if_not_exception_type,
     stop_after_attempt,
@@ -39,14 +39,10 @@ from prediction_market_agent_tooling.markets.omen.cow_contracts import (
     CowGPv2SettlementContract,
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
+from prediction_market_agent_tooling.tools.cow.models import MinimalisticToken, Order
 from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
 
 
-class MinimalisticToken(BaseModel):
-    sellToken: ChecksumAddress
-    buyToken: ChecksumAddress
-
-
 class OrderStatusError(Exception):
     pass
 
@@ -292,3 +288,38 @@ def get_trades_by_owner(
     )
     response.raise_for_status()
     return [MinimalisticToken.model_validate(i) for i in response.json()]
+
+
+@tenacity.retry(
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(1),
+    after=lambda x: logger.debug(f"get_orders_by_owner failed, {x.attempt_number=}."),
+)
+def get_orders_by_owner(
+    owner: ChecksumAddress,
+) -> list[Order]:
+    """Retrieves all orders with pagination."""
+    items = paginate_endpoint(f"https://api.cow.fi/xdai/api/v1/account/{owner}/orders")
+    return [Order.model_validate(i) for i in items]
+
+
+@tenacity.retry(
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(1),
+    after=lambda x: logger.debug(f"paginate_endpoint failed, {x.attempt_number=}."),
+)
+def paginate_endpoint(url: str, limit: int = 1000) -> t.Any:
+    offset = 0
+    results = []
+
+    while True:
+        response = httpx.get(url, params={"offset": offset, "limit": limit})
+        response.raise_for_status()
+        items = response.json()
+        if not items:
+            break
+
+        results.extend(items)
+        offset += limit
+
+    return results

prediction_market_agent_tooling-0.65.9/prediction_market_agent_tooling/tools/cow/models.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+
+
+class MinimalisticToken(BaseModel):
+    sellToken: ChecksumAddress
+    buyToken: ChecksumAddress
+
+
+class Order(BaseModel):
+    uid: str
+    sellToken: str
+    buyToken: str
+    creationDate: DatetimeUTC

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/prediction_market_agent_tooling/tools/utils.py

@@ -9,6 +9,7 @@ import requests
 from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
+from tenacity import RetryError
 
 from prediction_market_agent_tooling.gtypes import (
     CollateralToken,
@@ -230,3 +231,12 @@ def calculate_sell_amount_in_collateral(
 
     amount_to_sell = newton(f, 0)
     return CollateralToken(float(amount_to_sell) * 0.999999)  # Avoid rounding errors
+
+
+def extract_error_from_retry_error(e: BaseException | RetryError) -> BaseException:
+    if (
+        isinstance(e, RetryError)
+        and (exp_from_retry := e.last_attempt.exception()) is not None
+    ):
+        e = exp_from_retry
+    return e

{prediction_market_agent_tooling-0.65.7 → prediction_market_agent_tooling-0.65.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.65.7"
+version = "0.65.9"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"

prediction_market_agent_tooling-0.65.7/prediction_market_agent_tooling/markets/manifold/utils.py

@@ -1,10 +0,0 @@
-import typing as t
-
-from prediction_market_agent_tooling.gtypes import OutcomeStr
-from prediction_market_agent_tooling.markets.data_models import Resolution
-
-
-def validate_resolution(v: t.Any) -> Resolution:
-    if isinstance(v, str):
-        return Resolution(outcome=OutcomeStr(v), invalid=False)
-    raise ValueError(f"Expected a string, got {v} {type(v)}")