prediction-market-agent-tooling 0.58.3.dev385__py3-none-any.whl → 0.58.5__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -64,7 +64,7 @@ from prediction_market_agent_tooling.tools.is_predictable import is_predictable_
 from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, observe
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
 
-MAX_AVAILABLE_MARKETS = 20
+MAX_AVAILABLE_MARKETS = 1000
 
 
 def initialize_langfuse(enable_langfuse: bool) -> None:
@@ -361,17 +361,23 @@ class DeployablePredictionAgent(DeployableAgent):
         if self.have_bet_on_market_since(
             market, since=self.same_market_trade_interval.get(market=market)
         ):
+            logger.info(
+                f"Market already bet on within {self.same_market_trade_interval}."
+            )
             return False
 
         # Manifold allows to bet only on markets with probability between 1 and 99.
         if market_type == MarketType.MANIFOLD and not (1 < market.current_p_yes < 99):
+            logger.info("Manifold's market probability not in the range 1-99.")
             return False
 
         # Do as a last check, as it uses paid OpenAI API.
         if not is_predictable_binary(market.question):
+            logger.info("Market question is not predictable.")
             return False
 
         if not self.allow_invalid_questions and is_invalid(market.question):
+            logger.info("Market question is invalid.")
             return False
 
         return True
@@ -430,6 +436,7 @@ class DeployablePredictionAgent(DeployableAgent):
             logger.info(f"Market '{market.question}' doesn't meet the criteria.")
             answer = None
         else:
+            logger.info(f"Answering market '{market.question}'.")
             answer = self.answer_binary_market(market)
 
         processed_market = (
@@ -480,7 +487,10 @@ class DeployablePredictionAgent(DeployableAgent):
         )
         processed = 0
 
-        for market in available_markets:
+        for market_idx, market in enumerate(available_markets):
+            logger.info(
+                f"Going to process market {market_idx+1} / {len(available_markets)}."
+            )
             self.before_process_market(market_type, market)
             processed_market = self.process_market(market_type, market)
             self.after_process_market(market_type, market, processed_market)
@@ -491,7 +501,9 @@ class DeployablePredictionAgent(DeployableAgent):
             if processed == self.bet_on_n_markets_per_run:
                 break
 
-        logger.info("All markets processed.")
+        logger.info(
+            f"All markets processed. Successfully processed {processed}/{len(available_markets)}."
+        )
 
     def after_process_markets(self, market_type: MarketType) -> None:
         """
@@ -522,6 +534,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         MarketType.OMEN,
         MarketType.MANIFOLD,
         MarketType.POLYMARKET,
+        MarketType.SEER,
     ]
 
     def __init__(

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -13,7 +13,6 @@ from prediction_market_agent_tooling.markets.data_models import (
     Trade,
     TradeType,
 )
-from prediction_market_agent_tooling.markets.omen.data_models import get_boolean_outcome
 from prediction_market_agent_tooling.markets.omen.omen import (
     get_buy_outcome_token_amount,
 )
@@ -94,11 +93,8 @@ class BettingStrategy(ABC):
         sell price is higher.
         """
         trades = []
-        for outcome in [
-            market.get_outcome_str_from_bool(True),
-            market.get_outcome_str_from_bool(False),
-        ]:
-            outcome_bool = get_boolean_outcome(outcome)
+        for outcome_bool in [True, False]:
+            outcome = market.get_outcome_str_from_bool(outcome_bool)
             prev_amount: TokenAmount = (
                 existing_position.amounts[outcome]
                 if existing_position and outcome in existing_position.amounts

prediction_market_agent_tooling/markets/agent_market.py

@@ -284,8 +284,7 @@ class AgentMarket(BaseModel):
     def has_unsuccessful_resolution(self) -> bool:
         return self.resolution in [Resolution.CANCEL, Resolution.MKT]
 
-    @staticmethod
-    def get_outcome_str_from_bool(outcome: bool) -> OutcomeStr:
+    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
         raise NotImplementedError("Subclasses must implement this method")
 
     def get_outcome_str(self, outcome_index: int) -> str:

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -0,0 +1,82 @@
+from web3 import Web3
+from web3.constants import HASH_ZERO
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    xDai,
+    xdai_type,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.omen.data_models import (
+    ContractPrediction,
+    IPFSAgentResult,
+)
+from prediction_market_agent_tooling.markets.omen.omen_contracts import (
+    OmenAgentResultMappingContract,
+)
+from prediction_market_agent_tooling.tools.balances import get_balances
+from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
+from prediction_market_agent_tooling.tools.utils import BPS_CONSTANT
+from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
+
+
+def get_total_balance(
+    address: ChecksumAddress,
+    web3: Web3 | None = None,
+    sum_xdai: bool = True,
+    sum_wxdai: bool = True,
+) -> xDai:
+    """
+    Checks if the total balance of xDai and wxDai in the wallet is above the minimum required balance.
+    """
+    current_balances = get_balances(address, web3)
+    # xDai and wxDai have equal value and can be exchanged for almost no cost, so we can sum them up.
+    total_balance = 0.0
+    if sum_xdai:
+        total_balance += current_balances.xdai
+    if sum_wxdai:
+        total_balance += current_balances.wxdai
+    return xdai_type(total_balance)
+
+
+def store_trades(
+    market_id: str,
+    traded_market: ProcessedTradedMarket | None,
+    keys: APIKeys,
+    agent_name: str,
+) -> None:
+    if traded_market is None:
+        logger.warning(f"No prediction for market {market_id}, not storing anything.")
+        return
+
+    reasoning = traded_market.answer.reasoning if traded_market.answer.reasoning else ""
+
+    ipfs_hash_decoded = HexBytes(HASH_ZERO)
+    if keys.enable_ipfs_upload:
+        logger.info("Storing prediction on IPFS.")
+        ipfs_hash = IPFSHandler(keys).store_agent_result(
+            IPFSAgentResult(reasoning=reasoning, agent_name=agent_name)
+        )
+        ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
+
+    tx_hashes = [
+        HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
+    ]
+    prediction = ContractPrediction(
+        publisher=keys.bet_from_address,
+        ipfs_hash=ipfs_hash_decoded,
+        tx_hashes=tx_hashes,
+        estimated_probability_bps=int(traded_market.answer.p_yes * BPS_CONSTANT),
+    )
+    tx_receipt = OmenAgentResultMappingContract().add_prediction(
+        api_keys=keys,
+        market_address=Web3.to_checksum_address(market_id),
+        prediction=prediction,
+    )
+    logger.info(
+        f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."
+    )

prediction_market_agent_tooling/markets/data_models.py

@@ -9,6 +9,7 @@ from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 class Currency(str, Enum):
     xDai = "xDai"
+    sDai = "sDai"
     Mana = "Mana"
     USDC = "USDC"
 

prediction_market_agent_tooling/markets/markets.py

@@ -28,6 +28,7 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 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,
@@ -41,6 +42,7 @@ class MarketType(str, Enum):
     MANIFOLD = "manifold"
     POLYMARKET = "polymarket"
     METACULUS = "metaculus"
+    SEER = "seer"
 
     @property
     def market_class(self) -> type[AgentMarket]:
@@ -56,7 +58,7 @@ class MarketType(str, Enum):
 
     @property
     def is_blockchain_market(self) -> bool:
-        return self in [MarketType.OMEN, MarketType.POLYMARKET]
+        return self in [MarketType.OMEN, MarketType.POLYMARKET, MarketType.SEER]
 
 
 MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
@@ -64,6 +66,7 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.OMEN: OmenAgentMarket,
     MarketType.POLYMARKET: PolymarketAgentMarket,
     MarketType.METACULUS: MetaculusAgentMarket,
+    MarketType.SEER: SeerAgentMarket,
 }
 
 JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {

prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -20,7 +20,7 @@ class AggregationItem(BaseModel):
     centers: list[float] | None
     interval_upper_bounds: list[float] | None
     means: list[float] | None
-    histogram: list[float] | None
+    histogram: list[list[float]] | None
 
 
 class Aggregation(BaseModel):

prediction_market_agent_tooling/markets/omen/omen.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 
 import tenacity
 from web3 import Web3
-from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -28,6 +27,10 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ProcessedTradedMarket,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.blockchain_utils import (
+    get_total_balance,
+    store_trades,
+)
 from prediction_market_agent_tooling.markets.data_models import (
     Bet,
     BetAmount,
@@ -42,9 +45,7 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     PRESAGIO_BASE_URL,
     Condition,
     ConditionPreparationEvent,
-    ContractPrediction,
     CreatedMarket,
-    IPFSAgentResult,
     OmenBet,
     OmenMarket,
     OmenUserPosition,
@@ -55,7 +56,6 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE_PERC,
     REALITY_DEFAULT_FINALIZATION_TIMEOUT,
     Arbitrator,
-    OmenAgentResultMappingContract,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
     OmenFixedProductMarketMakerFactoryContract,
@@ -74,7 +74,6 @@ from prediction_market_agent_tooling.tools.contract import (
 )
 from prediction_market_agent_tooling.tools.custom_exceptions import OutOfFundsError
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
-from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
 )
@@ -82,7 +81,6 @@ from prediction_market_agent_tooling.tools.tokens.auto_withdraw import (
     auto_withdraw_collateral_token,
 )
 from prediction_market_agent_tooling.tools.utils import (
-    BPS_CONSTANT,
     DatetimeUTC,
     calculate_sell_amount_in_collateral,
     check_not_none,
@@ -90,7 +88,6 @@ from prediction_market_agent_tooling.tools.utils import (
 from prediction_market_agent_tooling.tools.web3_utils import (
     add_fraction,
     get_receipt_block_timestamp,
-    ipfscidv0_to_byte32,
     remove_fraction,
     wei_to_xdai,
     xdai_to_wei,
@@ -206,7 +203,7 @@ class OmenAgentMarket(AgentMarket):
         self,
         outcome: bool,
         amount: BetAmount,
-        omen_auto_deposit: bool = True,
+        auto_deposit: bool = True,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
     ) -> str:
@@ -222,7 +219,7 @@ class OmenAgentMarket(AgentMarket):
             amount=amount_xdai,
             market=self,
             binary_outcome=outcome,
-            auto_deposit=omen_auto_deposit,
+            auto_deposit=auto_deposit,
             web3=web3,
         )
 
@@ -434,38 +431,11 @@ class OmenAgentMarket(AgentMarket):
         keys: APIKeys,
         agent_name: str,
     ) -> None:
-        if traded_market is None:
-            logger.warning(f"No prediction for market {self.id}, not storing anything.")
-            return
-
-        reasoning = (
-            traded_market.answer.reasoning if traded_market.answer.reasoning else ""
-        )
-
-        ipfs_hash_decoded = HexBytes(HASH_ZERO)
-        if keys.enable_ipfs_upload:
-            logger.info("Storing prediction on IPFS.")
-            ipfs_hash = IPFSHandler(keys).store_agent_result(
-                IPFSAgentResult(reasoning=reasoning, agent_name=agent_name)
-            )
-            ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
-
-        tx_hashes = [
-            HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
-        ]
-        prediction = ContractPrediction(
-            publisher=keys.bet_from_address,
-            ipfs_hash=ipfs_hash_decoded,
-            tx_hashes=tx_hashes,
-            estimated_probability_bps=int(traded_market.answer.p_yes * BPS_CONSTANT),
-        )
-        tx_receipt = OmenAgentResultMappingContract().add_prediction(
-            api_keys=keys,
-            market_address=Web3.to_checksum_address(self.id),
-            prediction=prediction,
-        )
-        logger.info(
-            f"Added prediction to market {self.id}. - receipt {tx_receipt['transactionHash'].hex()}."
+        return store_trades(
+            market_id=self.id,
+            traded_market=traded_market,
+            keys=keys,
+            agent_name=agent_name,
         )
 
     @staticmethod
@@ -516,8 +486,7 @@ class OmenAgentMarket(AgentMarket):
             cls.get_outcome_str(cls.index_set_to_outcome_index(index_set))
         )
 
-    @staticmethod
-    def get_outcome_str_from_bool(outcome: bool) -> OutcomeStr:
+    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
         return (
             OutcomeStr(OMEN_TRUE_OUTCOME) if outcome else OutcomeStr(OMEN_FALSE_OUTCOME)
         )
@@ -1302,25 +1271,6 @@ def get_binary_market_p_yes_history(market: OmenAgentMarket) -> list[Probability
     return history
 
 
-def get_total_balance(
-    address: ChecksumAddress,
-    web3: Web3 | None = None,
-    sum_xdai: bool = True,
-    sum_wxdai: bool = True,
-) -> xDai:
-    """
-    Checks if the total balance of xDai and wxDai in the wallet is above the minimum required balance.
-    """
-    current_balances = get_balances(address, web3)
-    # xDai and wxDai have equal value and can be exchanged for almost no cost, so we can sum them up.
-    total_balance = 0.0
-    if sum_xdai:
-        total_balance += current_balances.xdai
-    if sum_wxdai:
-        total_balance += current_balances.wxdai
-    return xdai_type(total_balance)
-
-
 def withdraw_wxdai_to_xdai_to_keep_balance(
     api_keys: APIKeys,
     min_required_balance: xDai,

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,10 +1,26 @@
+import re
 import typing as t
+from enum import Enum
+from urllib.parse import urljoin
 
-from eth_typing import HexAddress
 from pydantic import BaseModel, ConfigDict, Field
+from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
-from prediction_market_agent_tooling.gtypes import HexBytes, Wei
+from prediction_market_agent_tooling.config import RPCConfig
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexAddress,
+    HexBytes,
+    Probability,
+    Wei,
+    xdai_type,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.data_models import Resolution
+from prediction_market_agent_tooling.tools.cow.cow_manager import CowManager
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
 
 
 class CreateCategoricalMarketsParams(BaseModel):
@@ -30,21 +46,184 @@ class CreateCategoricalMarketsParams(BaseModel):
     token_names: list[str] = Field(..., alias="tokenNames")
 
 
+class SeerOutcomeEnum(str, Enum):
+    YES = "yes"
+    NO = "no"
+    INVALID = "invalid"
+
+    @classmethod
+    def from_bool(cls, value: bool) -> "SeerOutcomeEnum":
+        return cls.YES if value else cls.NO
+
+    @classmethod
+    def from_string(cls, value: str) -> "SeerOutcomeEnum":
+        """Convert a string (case-insensitive) to an Outcome enum."""
+        normalized = value.strip().lower()
+        patterns = {
+            r"^yes$": cls.YES,
+            r"^no$": cls.NO,
+            r"^(invalid|invalid result)$": cls.INVALID,
+        }
+
+        # Search through patterns and return the first match
+        for pattern, outcome in patterns.items():
+            if re.search(pattern, normalized):
+                return outcome
+
+        raise ValueError(f"Could not map {value=} to an outcome.")
+
+    def to_bool(self) -> bool:
+        """Convert a SeerOutcomeEnum to a boolean value."""
+        if self == self.YES:
+            return True
+        elif self == self.NO:
+            return False
+        elif self == self.INVALID:
+            raise ValueError("Cannot convert INVALID outcome to boolean.")
+        else:
+            raise ValueError(f"Unknown outcome: {self}")
+
+
 class SeerParentMarket(BaseModel):
     id: HexBytes
 
 
+SEER_BASE_URL = "https://app.seer.pm"
+
+
 class SeerMarket(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
     id: HexBytes
+    creator: HexAddress
     title: str = Field(alias="marketName")
     outcomes: list[str]
-    wrapped_tokens: list[HexBytes] = Field(alias="wrappedTokens")
+    wrapped_tokens: list[HexAddress] = Field(alias="wrappedTokens")
     parent_outcome: int = Field(alias="parentOutcome")
     parent_market: t.Optional[SeerParentMarket] = Field(
         alias="parentMarket", default=None
     )
+    collateral_token: HexAddress = Field(alias="collateralToken")
+    condition_id: HexBytes = Field(alias="conditionId")
+    opening_ts: int = Field(alias="openingTs")
+    block_timestamp: int = Field(alias="blockTimestamp")
+    has_answers: bool | None = Field(alias="hasAnswers")
+    payout_reported: bool = Field(alias="payoutReported")
+    payout_numerators: list[int] = Field(alias="payoutNumerators")
+
+    @property
+    def has_valid_answer(self) -> bool:
+        # We assume that, for the market to be resolved as invalid, it must have both:
+        # 1. An invalid outcome AND
+        # 2. Invalid payoutNumerator is 1.
+
+        try:
+            self.outcome_as_enums[SeerOutcomeEnum.INVALID]
+        except KeyError:
+            raise ValueError(
+                f"Market {self.id.hex()} has no invalid outcome. {self.outcomes}"
+            )
+
+        return self.payout_reported and self.payout_numerators[-1] != 1
+
+    @property
+    def outcome_as_enums(self) -> dict[SeerOutcomeEnum, int]:
+        return {
+            SeerOutcomeEnum.from_string(outcome): idx
+            for idx, outcome in enumerate(self.outcomes)
+        }
+
+    @property
+    def is_resolved(self) -> bool:
+        return self.payout_reported
+
+    @property
+    def is_resolved_with_valid_answer(self) -> bool:
+        return self.is_resolved and self.has_valid_answer
+
+    def get_resolution_enum(self) -> t.Optional[Resolution]:
+        if not self.is_resolved_with_valid_answer:
+            return None
+
+        max_idx = self.payout_numerators.index(1)
+
+        outcome: str = self.outcomes[max_idx]
+        outcome_enum = SeerOutcomeEnum.from_string(outcome)
+        if outcome_enum.to_bool():
+            return Resolution.YES
+        return Resolution.NO
+
+    @property
+    def is_binary(self) -> bool:
+        # 3 because Seer has also third, `Invalid` outcome.
+        return len(self.outcomes) == 3
+
+    def boolean_outcome_from_answer(self, answer: HexBytes) -> bool:
+        if not self.is_binary:
+            raise ValueError(
+                f"Market with title {self.title} is not binary, it has {len(self.outcomes)} outcomes."
+            )
+
+        outcome: str = self.outcomes[answer.as_int()]
+        outcome_enum = SeerOutcomeEnum.from_string(outcome)
+        return outcome_enum.to_bool()
+
+    def get_resolution_enum_from_answer(self, answer: HexBytes) -> Resolution:
+        if self.boolean_outcome_from_answer(answer):
+            return Resolution.YES
+        else:
+            return Resolution.NO
+
+    @property
+    def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.collateral_token)
+
+    @property
+    def close_time(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.opening_ts)
+
+    @property
+    def created_time(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.block_timestamp)
+
+    @property
+    def current_p_yes(self) -> Probability:
+        price_data = {}
+        for idx in range(len(self.outcomes)):
+            wrapped_token = self.wrapped_tokens[idx]
+            price = self._get_price_for_token(
+                token=Web3.to_checksum_address(wrapped_token)
+            )
+            price_data[idx] = price
+
+        if sum(price_data.values()) == 0:
+            logger.warning(
+                f"Could not get p_yes for market {self.id.hex()}, all price quotes are 0."
+            )
+            return Probability(0)
+
+        yes_idx = self.outcome_as_enums[SeerOutcomeEnum.YES]
+        price_yes = price_data[yes_idx] / sum(price_data.values())
+        return Probability(price_yes)
+
+    def _get_price_for_token(self, token: ChecksumAddress) -> float:
+        collateral_exchange_amount = xdai_to_wei(xdai_type(1))
+        try:
+            quote = CowManager().get_quote(
+                collateral_token=self.collateral_token_contract_address_checksummed,
+                buy_token=token,
+                sell_amount=collateral_exchange_amount,
+            )
+        except Exception as e:
+            logger.warning(f"Could not get quote for {token=}, returning price 0. {e=}")
+            return 0
+
+        return collateral_exchange_amount / float(quote.quote.buyAmount.root)
+
+    @property
+    def url(self) -> str:
+        chain_id = RPCConfig().chain_id
+        return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
 
 
 class SeerToken(BaseModel):

prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,22 +1,290 @@
+import typing as t
+
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import xDai
-from prediction_market_agent_tooling.markets.seer.data_models import NewMarketEvent
+from prediction_market_agent_tooling.gtypes import (
+    HexAddress,
+    HexBytes,
+    OutcomeStr,
+    Wei,
+    wei_type,
+    xDai,
+    xdai_type,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    FilterBy,
+    ProcessedMarket,
+    ProcessedTradedMarket,
+    SortBy,
+)
+from prediction_market_agent_tooling.markets.blockchain_utils import (
+    get_total_balance,
+    store_trades,
+)
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Currency,
+    Position,
+    TokenAmount,
+)
+from prediction_market_agent_tooling.markets.market_fees import MarketFees
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_contracts import sDaiContract
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    NewMarketEvent,
+    SeerMarket,
+    SeerOutcomeEnum,
+)
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     SeerMarketFactory,
 )
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
+    ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
+from prediction_market_agent_tooling.tools.cow.cow_manager import (
+    CowManager,
+    NoLiquidityAvailableOnCowException,
+)
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
 )
-from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai, xdai_to_wei
+
+# We place a larger bet amount by default than Omen so that cow presents valid quotes.
+SEER_TINY_BET_AMOUNT = xdai_type(0.1)
+
+
+class SeerAgentMarket(AgentMarket):
+    currency = Currency.sDai
+    wrapped_tokens: list[ChecksumAddress]
+    creator: HexAddress
+    collateral_token_contract_address_checksummed: ChecksumAddress
+    condition_id: HexBytes
+    seer_outcomes: dict[SeerOutcomeEnum, int]
+    description: str | None = (
+        None  # Seer markets don't have a description, so just default to None.
+    )
+
+    def store_prediction(
+        self,
+        processed_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+    ) -> None:
+        """On Seer, we have to store predictions along with trades, see `store_trades`."""
+
+    def store_trades(
+        self,
+        traded_market: ProcessedTradedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
+    ) -> None:
+        return store_trades(
+            market_id=self.id,
+            traded_market=traded_market,
+            keys=keys,
+            agent_name=agent_name,
+        )
+
+    def _convert_bet_amount_into_wei(self, bet_amount: BetAmount) -> Wei:
+        if bet_amount.currency == self.currency:
+            return xdai_to_wei(xdai_type(bet_amount.amount))
+        raise ValueError(
+            f"Currencies don't match. Currency bet amount {bet_amount.currency} currency market: {self.currency}"
+        )
+
+    def get_buy_token_amount(
+        self, bet_amount: BetAmount, direction: bool
+    ) -> TokenAmount:
+        """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
+
+        outcome_token = self.get_wrapped_token_for_outcome(direction)
+
+        bet_amount_in_wei = self._convert_bet_amount_into_wei(bet_amount=bet_amount)
+
+        quote = CowManager().get_quote(
+            buy_token=outcome_token,
+            sell_amount=bet_amount_in_wei,
+            collateral_token=self.collateral_token_contract_address_checksummed,
+        )
+        sell_amount = wei_to_xdai(wei_type(quote.quote.buyAmount.root))
+        return TokenAmount(amount=sell_amount, currency=bet_amount.currency)
+
+    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
+        outcome_translated = SeerOutcomeEnum.from_bool(outcome)
+        idx = self.seer_outcomes[outcome_translated]
+        return OutcomeStr(self.outcomes[idx])
+
+    @staticmethod
+    def get_trade_balance(api_keys: APIKeys) -> float:
+        return OmenAgentMarket.get_trade_balance(api_keys=api_keys)
+
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
+        return BetAmount(amount=SEER_TINY_BET_AMOUNT, currency=cls.currency)
+
+    def get_position(self, user_id: str, web3: Web3 | None = None) -> Position | None:
+        """
+        Fetches position from the user in a given market.
+        We ignore the INVALID balances since we are only interested in binary outcomes.
+        """
+
+        amounts = {}
+
+        for outcome in [True, False]:
+            wrapped_token = self.get_wrapped_token_for_outcome(outcome)
+
+            outcome_token_balance = ContractERC20OnGnosisChain(
+                address=wrapped_token
+            ).balanceOf(for_address=Web3.to_checksum_address(user_id), web3=web3)
+            outcome_str = self.get_outcome_str_from_bool(outcome=outcome)
+            amounts[outcome_str] = TokenAmount(
+                amount=wei_to_xdai(outcome_token_balance), currency=self.currency
+            )
+
+        return Position(market_id=self.id, amounts=amounts)
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return OmenAgentMarket.get_user_id(api_keys)
+
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys) -> None:
+        # ToDo - implement me (https://github.com/gnosis/prediction-market-agent-tooling/issues/499)
+        pass
+
+    @staticmethod
+    def verify_operational_balance(api_keys: APIKeys) -> bool:
+        return get_total_balance(
+            api_keys.public_key,
+            # Use `public_key`, not `bet_from_address` because transaction costs are paid from the EOA wallet.
+            sum_wxdai=False,
+        ) > xdai_type(0.001)
+
+    @staticmethod
+    def from_data_model(model: SeerMarket) -> "SeerAgentMarket":
+        return SeerAgentMarket(
+            id=model.id.hex(),
+            question=model.title,
+            creator=model.creator,
+            created_time=model.created_time,
+            outcomes=model.outcomes,
+            collateral_token_contract_address_checksummed=model.collateral_token_contract_address_checksummed,
+            condition_id=model.condition_id,
+            url=model.url,
+            close_time=model.close_time,
+            wrapped_tokens=[Web3.to_checksum_address(i) for i in model.wrapped_tokens],
+            fees=MarketFees.get_zero_fees(),
+            outcome_token_pool=None,
+            resolution=model.get_resolution_enum(),
+            volume=None,
+            current_p_yes=model.current_p_yes,
+            seer_outcomes=model.outcome_as_enums,
+        )
+
+    @staticmethod
+    def get_binary_markets(
+        limit: int,
+        sort_by: SortBy,
+        filter_by: FilterBy = FilterBy.OPEN,
+        created_after: t.Optional[DatetimeUTC] = None,
+        excluded_questions: set[str] | None = None,
+    ) -> t.Sequence["SeerAgentMarket"]:
+        return [
+            SeerAgentMarket.from_data_model(m)
+            for m in SeerSubgraphHandler().get_binary_markets(
+                limit=limit,
+                sort_by=sort_by,
+                filter_by=filter_by,
+            )
+        ]
+
+    def has_liquidity_for_outcome(self, outcome: bool) -> bool:
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
+        try:
+            CowManager().get_quote(
+                collateral_token=self.collateral_token_contract_address_checksummed,
+                buy_token=outcome_token,
+                sell_amount=xdai_to_wei(
+                    xdai_type(1)
+                ),  # we take 1 xDai as a baseline value for common trades the agents take.
+            )
+            return True
+        except NoLiquidityAvailableOnCowException:
+            logger.info(
+                f"Could not get a quote for {outcome_token=} {outcome=}, returning no liquidity"
+            )
+            return False
+
+    def has_liquidity(self) -> bool:
+        # We conservatively define a market as having liquidity if it has liquidity for the `True` outcome token AND the `False` outcome token.
+        return self.has_liquidity_for_outcome(True) and self.has_liquidity_for_outcome(
+            False
+        )
+
+    def get_wrapped_token_for_outcome(self, outcome: bool) -> ChecksumAddress:
+        outcome_from_enum = SeerOutcomeEnum.from_bool(outcome)
+        outcome_idx = self.seer_outcomes[outcome_from_enum]
+        outcome_token = self.wrapped_tokens[outcome_idx]
+        return outcome_token
+
+    def place_bet(
+        self,
+        outcome: bool,
+        amount: BetAmount,
+        auto_deposit: bool = True,
+        web3: Web3 | None = None,
+        api_keys: APIKeys | None = None,
+    ) -> str:
+        api_keys = api_keys if api_keys is not None else APIKeys()
+        if not self.can_be_traded():
+            raise ValueError(
+                f"Market {self.id} is not open for trading. Cannot place bet."
+            )
+
+        if amount.currency != self.currency:
+            raise ValueError(f"Seer bets are made in xDai. Got {amount.currency}.")
+
+        collateral_contract = sDaiContract()
+        if auto_deposit:
+            # We convert the deposit amount (in sDai) to assets in order to convert.
+            asset_amount = collateral_contract.convertToAssets(
+                xdai_to_wei(xdai_type(amount.amount))
+            )
+            auto_deposit_collateral_token(
+                collateral_contract, asset_amount, api_keys, web3
+            )
+
+        # We require that amount is given in sDAI.
+        collateral_balance = get_balances(address=api_keys.bet_from_address, web3=web3)
+        if collateral_balance.sdai < amount.amount:
+            raise ValueError(
+                f"Balance {collateral_balance.sdai} not enough for bet size {amount.amount}"
+            )
+
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
+        #  Sell sDAI using token address
+        order_metadata = CowManager().swap(
+            amount=xdai_type(amount.amount),
+            sell_token=collateral_contract.address,
+            buy_token=Web3.to_checksum_address(outcome_token),
+            api_keys=api_keys,
+            web3=web3,
+        )
+
+        return order_metadata.uid.root
 
 
 def seer_create_market_tx(

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -1,8 +1,11 @@
+import sys
+import typing as t
 from typing import Any
 
 from subgrounds import FieldPath
 from web3.constants import ADDRESS_ZERO
 
+from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
 from prediction_market_agent_tooling.markets.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
@@ -11,8 +14,7 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
     SeerPool,
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
-
-INVALID_OUTCOME = "Invalid result"
+from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
 
 
 class SeerSubgraphHandler(BaseSubgraphHandler):
@@ -45,21 +47,26 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.id,
             markets_field.factory,
             markets_field.creator,
+            markets_field.conditionId,
             markets_field.marketName,
             markets_field.parentOutcome,
             markets_field.outcomes,
+            markets_field.payoutReported,
+            markets_field.payoutNumerators,
+            markets_field.hasAnswers,
+            markets_field.blockTimestamp,
             markets_field.parentMarket.id,
+            markets_field.openingTs,
             markets_field.finalizeTs,
             markets_field.wrappedTokens,
+            markets_field.collateralToken,
         ]
         return fields
 
     @staticmethod
     def filter_bicategorical_markets(markets: list[SeerMarket]) -> list[SeerMarket]:
         # We do an extra check for the invalid outcome for safety.
-        return [
-            m for m in markets if len(m.outcomes) == 3 and INVALID_OUTCOME in m.outcomes
-        ]
+        return [m for m in markets if len(m.outcomes) == 3]
 
     @staticmethod
     def filter_binary_markets(markets: list[SeerMarket]) -> list[SeerMarket]:
@@ -70,35 +77,110 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         ]
 
     @staticmethod
-    def build_filter_for_conditional_markets(
-        include_conditional_markets: bool = True,
+    def _build_where_statements(
+        filter_by: FilterBy,
+        include_conditional_markets: bool = False,
     ) -> dict[Any, Any]:
-        return (
-            {}
-            if include_conditional_markets
-            else {"parentMarket": ADDRESS_ZERO.lower()}
-        )
+        now = to_int_timestamp(utcnow())
+
+        and_stms: dict[str, t.Any] = {}
+
+        match filter_by:
+            case FilterBy.OPEN:
+                and_stms["openingTs_gt"] = now
+                and_stms["hasAnswers"] = False
+            case FilterBy.RESOLVED:
+                # We consider RESOLVED == CLOSED (on Seer UI)
+                and_stms["payoutReported"] = True
+            case FilterBy.NONE:
+                pass
+            case _:
+                raise ValueError(f"Unknown filter {filter_by}")
+
+        if not include_conditional_markets:
+            and_stms["parentMarket"] = ADDRESS_ZERO.lower()
+
+        # We are only interested in binary markets of type YES/NO/Invalid.
+        or_stms = {}
+        or_stms["or"] = [
+            {"outcomes_contains": ["YES"]},
+            {"outcomes_contains": ["Yes"]},
+            {"outcomes_contains": ["yes"]},
+        ]
+
+        where_stms: dict[str, t.Any] = {"and": [and_stms, or_stms]}
+        return where_stms
+
+    def _build_sort_params(
+        self, sort_by: SortBy
+    ) -> tuple[str | None, FieldPath | None]:
+        sort_direction: str | None
+        sort_by_field: FieldPath | None
+
+        match sort_by:
+            case SortBy.NEWEST:
+                sort_direction = "desc"
+                sort_by_field = self.seer_subgraph.Market.block_timestamp
+            case SortBy.CLOSING_SOONEST:
+                sort_direction = "asc"
+                sort_by_field = self.seer_subgraph.Market.opening_ts
+            # ToDo - Implement liquidity conditions by looking up Swapr subgraph.
+            case SortBy.NONE | SortBy.HIGHEST_LIQUIDITY | SortBy.LOWEST_LIQUIDITY:
+                sort_direction = None
+                sort_by_field = None
+            case _:
+                raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        return sort_direction, sort_by_field
 
     def get_bicategorical_markets(
-        self, include_conditional_markets: bool = True
+        self,
+        filter_by: FilterBy,
+        limit: int | None = None,
+        sort_by_field: FieldPath | None = None,
+        sort_direction: str | None = None,
+        include_conditional_markets: bool = True,
     ) -> list[SeerMarket]:
         """Returns markets that contain 2 categories plus an invalid outcome."""
         # Binary markets on Seer contain 3 outcomes: OutcomeA, outcomeB and an Invalid option.
-        query_filter = self.build_filter_for_conditional_markets(
-            include_conditional_markets
+        where_stms = self._build_where_statements(
+            filter_by=filter_by, include_conditional_markets=include_conditional_markets
+        )
+
+        # These values can not be set to `None`, but they can be omitted.
+        optional_params = {}
+        if sort_by_field is not None:
+            optional_params["orderBy"] = sort_by_field
+        if sort_direction is not None:
+            optional_params["orderDirection"] = sort_direction
+
+        markets_field = self.seer_subgraph.Query.markets(
+            first=(
+                limit if limit else sys.maxsize
+            ),  # if not limit, we fetch all possible markets,
+            where=where_stms,
+            **optional_params,
         )
-        query_filter["outcomes_contains"] = [INVALID_OUTCOME]
-        markets_field = self.seer_subgraph.Query.markets(where=query_filter)
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
         two_category_markets = self.filter_bicategorical_markets(markets)
         return two_category_markets
 
     def get_binary_markets(
-        self, include_conditional_markets: bool = True
+        self,
+        filter_by: FilterBy,
+        sort_by: SortBy = SortBy.NONE,
+        limit: int | None = None,
+        include_conditional_markets: bool = True,
     ) -> list[SeerMarket]:
+        sort_direction, sort_by_field = self._build_sort_params(sort_by)
+
         two_category_markets = self.get_bicategorical_markets(
-            include_conditional_markets=include_conditional_markets
+            limit=limit,
+            include_conditional_markets=include_conditional_markets,
+            sort_direction=sort_direction,
+            sort_by_field=sort_by_field,
+            filter_by=filter_by,
         )
         # Now we additionally filter markets based on YES/NO being the only outcomes.
         binary_markets = self.filter_binary_markets(two_category_markets)
@@ -133,8 +215,8 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         for wrapped_token in market.wrapped_tokens:
             wheres.extend(
                 [
-                    {"token0": wrapped_token.hex().lower()},
-                    {"token1": wrapped_token.hex().lower()},
+                    {"token0": wrapped_token.lower()},
+                    {"token1": wrapped_token.lower()},
                 ]
             )
         pools_field = self.swapr_algebra_subgraph.Query.pools(where={"or": wheres})

prediction_market_agent_tooling/tools/cow/cow_manager.py

@@ -0,0 +1,113 @@
+import asyncio
+
+from cowdao_cowpy.common.api.errors import UnexpectedResponseError
+from cowdao_cowpy.common.config import SupportedChainId
+from cowdao_cowpy.cow.swap import get_order_quote
+from cowdao_cowpy.order_book.api import OrderBookApi
+from cowdao_cowpy.order_book.config import Envs, OrderBookAPIConfigFactory
+from cowdao_cowpy.order_book.generated.model import (
+    Address,
+    OrderMetaData,
+    OrderQuoteRequest,
+    OrderQuoteResponse,
+    OrderQuoteSide1,
+    OrderQuoteSideKindSell,
+)
+from cowdao_cowpy.order_book.generated.model import TokenAmount as TokenAmountCow
+from tenacity import retry, retry_if_not_exception_type, stop_after_attempt, wait_fixed
+from web3 import Web3
+from web3.constants import ADDRESS_ZERO
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, xDai
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
+
+COW_ENV: Envs = "prod"
+
+
+class NoLiquidityAvailableOnCowException(Exception):
+    """Custom exception for handling case where no liquidity available."""
+
+
+class CowManager:
+    def __init__(self) -> None:
+        self.order_book_api = OrderBookApi(
+            OrderBookAPIConfigFactory.get_config(COW_ENV, SupportedChainId.GNOSIS_CHAIN)
+        )
+        self.precision = 18  # number of token decimals from ERC1155 wrapped tokens.
+
+    @retry(
+        stop=stop_after_attempt(2),
+        wait=wait_fixed(2),
+        retry=retry_if_not_exception_type(NoLiquidityAvailableOnCowException),
+    )
+    def get_quote(
+        self,
+        collateral_token: ChecksumAddress,
+        buy_token: ChecksumAddress,
+        sell_amount: Wei,
+    ) -> OrderQuoteResponse:
+        """
+        Quote the price for a sell order.
+
+        Parameters:
+        - collateral_token: The token being sold.
+        - buy_token: The token being bought.
+        - sell_amount: The amount of collateral to sell in atoms.
+
+        Returns:
+        - An OrderQuoteResponse containing the quote information.
+
+        Raises:
+        - NoLiquidityAvailableOnCowException if no liquidity is available on CoW.
+        """
+
+        order_quote_request = OrderQuoteRequest(
+            buyToken=Address(buy_token),
+            sellToken=Address(collateral_token),
+            from_=Address(ADDRESS_ZERO),
+        )
+
+        order_side = OrderQuoteSide1(
+            kind=OrderQuoteSideKindSell.sell,
+            sellAmountBeforeFee=TokenAmountCow(str(sell_amount)),
+        )
+        try:
+            return asyncio.run(
+                get_order_quote(
+                    order_quote_request=order_quote_request,
+                    order_side=order_side,
+                    order_book_api=self.order_book_api,
+                )
+            )
+
+        except UnexpectedResponseError as e1:
+            if "NoLiquidity" in e1.message:
+                raise NoLiquidityAvailableOnCowException(e1.message)
+            logger.warning(f"Found unexpected Cow response error: {e1}")
+            raise
+        except Exception as e:
+            logger.warning(f"Found unhandled Cow response error: {e}")
+            raise
+
+    @staticmethod
+    def swap(
+        amount: xDai,
+        sell_token: ChecksumAddress,
+        buy_token: ChecksumAddress,
+        api_keys: APIKeys,
+        web3: Web3 | None = None,
+    ) -> OrderMetaData:
+        order_metadata = swap_tokens_waiting(
+            amount_wei=xdai_to_wei(amount),
+            sell_token=sell_token,
+            buy_token=buy_token,
+            api_keys=api_keys,
+            web3=web3,
+        )
+        logger.debug(
+            f"Purchased {buy_token} in exchange for {sell_token}. Order details {order_metadata}"
+        )
+        return order_metadata

{prediction_market_agent_tooling-0.58.3.dev385.dist-info → prediction_market_agent_tooling-0.58.5.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.58.3.dev385.dist-info → prediction_market_agent_tooling-0.58.5.dist-info}/RECORD

@@ -23,9 +23,9 @@ prediction_market_agent_tooling/benchmark/agents.py,sha256=B1-uWdyeN4GGKMWGK_-Cc
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=MqTiaaJ3cYiOLUVR7OyImLWxcEya3Rl5JyFYW-K0lwM,17097
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
 prediction_market_agent_tooling/config.py,sha256=owJ3goDbH1aeX8PzeJCeGK5pitYJqqk7yFOkaTbDarY,9209
-prediction_market_agent_tooling/deploy/agent.py,sha256=3VzmTIekbICWrpoo0VjIbR7s_AKjhYaAaUP5RITDGek,23554
+prediction_market_agent_tooling/deploy/agent.py,sha256=fFUxATQjSTRz70oDxBrgCk93NzF1i506cklJ8WtS_S0,24199
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=kMrIE3wMv_IB6nJd_1DmDXDkEZhsXFOgyTd7JZ0gqHI,13068
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=Y6Pb8OfSb6galRbfdNBvvNTgO-4dR2ybJ4o5GKJcMoM,12894
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=OsPboCFGiZKsvGyntGZHwdqPlLTthITkNF5rJFvGgU8,2582
@@ -36,23 +36,24 @@ prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=GOtsNm7URhzZM5fPY64r8m8Gz-sSsUhG1qmDoC7wGL8,2231
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=N0_jGDyXQeVXXlYg4oA_pOfqIjscHsLQbr0pBwFGoRo,5178
 prediction_market_agent_tooling/loggers.py,sha256=MvCkQSJL2_0yErNatqr81sJlc4aOgPzDp9VNrIhKUcc,4140
-prediction_market_agent_tooling/markets/agent_market.py,sha256=W2ME57-CSAhrt8qm8-b5r7yLq-Sk7R_BZMaApvjhrUE,12901
+prediction_market_agent_tooling/markets/agent_market.py,sha256=IoJ7EVj2kHtL4ht8Dq02ghj8OC0mEj5jKOI0jpcU1n0,12889
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
+prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=gZtQwF5UrOd_yOkNPLRbpMzUd55-Nsluy0858YYdPn8,2873
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
-prediction_market_agent_tooling/markets/data_models.py,sha256=oMoHxxiNekGgXX1FFExS_MNuHjte2pV1OEynVDIKVc8,4368
+prediction_market_agent_tooling/markets/data_models.py,sha256=uUuCMoo-Q4ws-03e6iOJJbQtZmQ1JZLapXOeb97t95o,4386
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=Fd0HYnstvvHO6AZkp1xiRlvCwQUc8kLR8DAj6PAZu0s,7297
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=eiGS4rEkxseZNpEb2BICKnjF0qqgkQTMuUPbSe7_04I,6059
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=qemQIwuFg4yf6egGWFp9lWpz1lXr02QiBeZ2akcT6II,5026
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=_gGlWid0sPF127Omx5qQ1fq17frLInv0wdyXJBMGVzM,670
 prediction_market_agent_tooling/markets/market_fees.py,sha256=Q64T9uaJx0Vllt0BkrPmpMEz53ra-hMVY8Czi7CEP7s,1227
-prediction_market_agent_tooling/markets/markets.py,sha256=5x_bX_Mr-696RGXL97qZWnkqq6uV3q2stI-v2-dcaHs,3894
+prediction_market_agent_tooling/markets/markets.py,sha256=OMADWd1C5wD7sVdcY_GVdxAFDndkU9kn6Ble4GXCw0c,4045
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
-prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=Suxa7xELdYuFNKqvGvFh8qyfVtAg79E-vaQ6dqNZOtA,3261
+prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=FaBCTPPezXbBwZ9p791CiVgQ4vB696xnMbz9XVXmiVI,3267
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=86TIx6cavEWc8Cv4KpZxSvwiSw9oFybXE3YB49pg-CA,4377
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=uT8ILKrg2g4jGodPxtolPErk25buNzMYndb01ZL2dYE,28421
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=xNHYn5diKjKlkeKoYNr8DrE0gSMsU8poGhxBjw2PZow,51783
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=mtkLJR1w3QRfyW6aY_Ey-3ITL2BPHrisvPY0tmB4wGU,49864
 prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=D9oflYKafLQiHYtB5sScMHqmXyzM8JP8J0yATmc4SQQ,233
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=EXqBlVivbmW8aBQ65O09X2xkyesHAop49GUl1tUffWA,28648
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=E1BVDvQd1qYtCxmfC94kJtGkmQqpGPHL3zTkcs5wW6M,9697
@@ -62,10 +63,10 @@ prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=Fd5PI5y
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=VZhVccTApygSKMmy6Au2G02JCJOKJnR_oVeKlaesuSg,12548
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=NRoZK71PtH8kkangMqme7twcAXhRJSSabbmOir-UnAI,3418
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=DImFxeMg8lTfsEDZ8FavndW38TfUsCkawcVGnucsuGo,2029
-prediction_market_agent_tooling/markets/seer/data_models.py,sha256=DmxkAfusRbupqBDjohSFhsYyW7WjKZ1sQKpm8xeAMi4,2017
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=l87L82M-RHMBJjfdtNXWgGLc979n2Fub9Z702zE8I9c,3351
+prediction_market_agent_tooling/markets/seer/data_models.py,sha256=HGJv4XSvCxXLLC5VwxZTZ5E4w_bWGKv50fM_6ssloxI,8203
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=M3RN3ZlLduFJvhk_0KTZDkX94z_HKhFOIK7BwLSGauM,13145
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=E7CYAKZiK6cg3dyj1kJuIPKSYYUft98F64shF5S0g4s,2730
-prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=KraQe4GgbdMcYnvpEJqcSHXQqgyDiC7IjkIOHAfma9s,5528
+prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=aycOvJ1_f5m7xzd_Hlx98_-VeM869IY9mTzJ2zn_VEM,8577
 prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py,sha256=fjIgjDIx5MhH5mwf7S0cspLOOSU3elYLhGYoIiM26mU,2746
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=TS4ERwTfQnot8dhekNyVNhJYf5ysYsjF-9v5_kM3aVI,3334
 prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=LOnyWWBFdg10-cTWdb76nOsNjDloO8OfMT85GBzRCFI,1455
@@ -86,6 +87,7 @@ prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjq
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
 prediction_market_agent_tooling/tools/contract.py,sha256=JkkrXm75_XUZ33jVlXF7v-Ge9RLSfXQeY523H_kuThQ,26069
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
+prediction_market_agent_tooling/tools/cow/cow_manager.py,sha256=WK6Uk722VotjLHtxDPHxvwBrWVb3rvTegg_3w58ehwU,3869
 prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=ohriN_65BZ69f_BV6bNg_AwZjidip4yi4d2G6Ddy5Qg,4238
 prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
 prediction_market_agent_tooling/tools/data_models.py,sha256=jDQ7FU0QQhXlcgJh5VZZGwDTYP2OPAqKPHZFewCPAUY,732
@@ -118,8 +120,8 @@ prediction_market_agent_tooling/tools/tokens/main_token.py,sha256=5iHO7-iehSlXuu
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=jLG4nbEoIzzJiZ4RgMx4Q969Zdl0p0s63p8uET_0Fuw,6440
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=e7lqqQddVZaa905rhBb6L1fC3o39Yr-PDJsJjHFBeRE,12523
-prediction_market_agent_tooling-0.58.3.dev385.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.58.3.dev385.dist-info/METADATA,sha256=BUNlEFZXKyo10bb9d49r_eyTZgC8tRHExC6OukNMZFU,8636
-prediction_market_agent_tooling-0.58.3.dev385.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-prediction_market_agent_tooling-0.58.3.dev385.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.58.3.dev385.dist-info/RECORD,,
+prediction_market_agent_tooling-0.58.5.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.58.5.dist-info/METADATA,sha256=rPCTjBMlKpKZHpIpANRKiO-FIZRUqMA_P0DUcps9pcI,8629
+prediction_market_agent_tooling-0.58.5.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+prediction_market_agent_tooling-0.58.5.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.58.5.dist-info/RECORD,,