prediction-market-agent-tooling 0.58.3__tar.gz → 0.58.4__tar.gz

{prediction_market_agent_tooling-0.58.3 → prediction_market_agent_tooling-0.58.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.58.3
+Version: 0.58.4
 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 → prediction_market_agent_tooling-0.58.4}/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:
@@ -430,6 +430,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 = (
@@ -522,6 +523,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         MarketType.OMEN,
         MarketType.MANIFOLD,
         MarketType.POLYMARKET,
+        MarketType.SEER,
     ]
 
     def __init__(

{prediction_market_agent_tooling-0.58.3 → prediction_market_agent_tooling-0.58.4}/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-0.58.3 → prediction_market_agent_tooling-0.58.4}/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-0.58.4/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-0.58.3 → prediction_market_agent_tooling-0.58.4}/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-0.58.3 → prediction_market_agent_tooling-0.58.4}/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-0.58.3 → prediction_market_agent_tooling-0.58.4}/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-0.58.4/prediction_market_agent_tooling/markets/seer/data_models.py

@@ -0,0 +1,249 @@
+import re
+import typing as t
+from enum import Enum
+from urllib.parse import urljoin
+
+from pydantic import BaseModel, ConfigDict, Field
+from web3 import Web3
+from web3.constants import ADDRESS_ZERO
+
+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):
+    model_config = ConfigDict(populate_by_name=True)
+
+    market_name: str = Field(..., alias="marketName")
+    outcomes: list[str]
+    # Only relevant for scalar markets
+    question_start: str = Field(alias="questionStart", default="")
+    question_end: str = Field(alias="questionEnd", default="")
+    outcome_type: str = Field(alias="outcomeType", default="")
+
+    # Not needed for non-conditional markets.
+    parent_outcome: int = Field(alias="parentOutcome", default=0)
+    parent_market: HexAddress = Field(alias="parentMarket", default=ADDRESS_ZERO)
+
+    category: str
+    lang: str
+    lower_bound: int = Field(alias="lowerBound", default=0)
+    upper_bound: int = Field(alias="upperBound", default=0)
+    min_bond: Wei = Field(..., alias="minBond")
+    opening_time: int = Field(..., alias="openingTime")
+    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[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):
+    id: HexBytes
+    name: str
+    symbol: str
+
+
+class SeerPool(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    id: HexBytes
+    liquidity: int
+    token0: SeerToken
+    token1: SeerToken
+
+
+class NewMarketEvent(BaseModel):
+    market: HexAddress
+    marketName: str
+    parentMarket: HexAddress
+    conditionId: HexBytes
+    questionId: HexBytes
+    questionsIds: list[HexBytes]