prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,7 +1,10 @@
 import typing as t
+from datetime import timedelta
+from enum import Enum
+from typing import Annotated
 from urllib.parse import urljoin
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, computed_field
 from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
@@ -13,12 +16,11 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeWei,
     Web3Wei,
-)
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
-    SeerParentMarket,
+    Wei,
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class CreateCategoricalMarketsParams(BaseModel):
@@ -47,6 +49,36 @@ class CreateCategoricalMarketsParams(BaseModel):
 SEER_BASE_URL = "https://app.seer.pm"
 
 
+def seer_normalize_wei(value: int | dict[str, t.Any] | None) -> int | None:
+    # See https://github.com/seer-pm/demo/blob/main/web/netlify/edge-functions/utils/common.ts#L22
+    if value is None:
+        return value
+    elif isinstance(value, dict):
+        if value.get("value") is None:
+            raise ValueError(f"Expected a dictionary with a value key, but got {value}")
+        value = int(value["value"])
+    is_in_wei = value > 1e10
+    return value if is_in_wei else value * 10**18
+
+
+SeerNormalizedWei = Annotated[Wei | None, BeforeValidator(seer_normalize_wei)]
+
+
+class MarketId(BaseModel):
+    id: HexBytes
+
+
+class SeerQuestion(BaseModel):
+    id: str
+    best_answer: HexBytes
+    finalize_ts: int
+
+
+class SeerMarketQuestions(BaseModel):
+    question: SeerQuestion
+    market: MarketId
+
+
 class SeerMarket(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
@@ -55,10 +87,11 @@ class SeerMarket(BaseModel):
     title: str = Field(alias="marketName")
     outcomes: t.Sequence[OutcomeStr]
     wrapped_tokens: list[HexAddress] = Field(alias="wrappedTokens")
-    parent_outcome: int = Field(alias="parentOutcome")
-    parent_market: t.Optional[SeerParentMarket] = Field(
-        alias="parentMarket", default=None
+    parent_outcome: int = Field(
+        alias="parentOutcome", description="It comes as 0 from non-conditioned markets."
     )
+    parent_market: t.Optional["SeerMarket"] = Field(alias="parentMarket", default=None)
+    template_id: int = Field(alias="templateId")
     collateral_token: HexAddress = Field(alias="collateralToken")
     condition_id: HexBytes = Field(alias="conditionId")
     opening_ts: int = Field(alias="openingTs")
@@ -67,6 +100,8 @@ class SeerMarket(BaseModel):
     payout_reported: bool = Field(alias="payoutReported")
     payout_numerators: list[int] = Field(alias="payoutNumerators")
     outcomes_supply: int = Field(alias="outcomesSupply")
+    upper_bound: SeerNormalizedWei = Field(alias="upperBound", default=None)
+    lower_bound: SeerNormalizedWei = Field(alias="lowerBound", default=None)
 
     @property
     def has_valid_answer(self) -> bool:
@@ -105,11 +140,6 @@ class SeerMarket(BaseModel):
             for token in self.wrapped_tokens
         ]
 
-    @property
-    def is_binary(self) -> bool:
-        # 3 because Seer has also third, `Invalid` outcome.
-        return len(self.outcomes) == 3
-
     @property
     def collateral_token_contract_address_checksummed(self) -> ChecksumAddress:
         return Web3.to_checksum_address(self.collateral_token)
@@ -122,14 +152,78 @@ class SeerMarket(BaseModel):
     def created_time(self) -> DatetimeUTC:
         return DatetimeUTC.to_datetime_utc(self.block_timestamp)
 
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def url(self) -> str:
         chain_id = RPCConfig().chain_id
-        return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
+        return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.to_0x_hex()}")
+
+
+class SeerMarketWithQuestions(SeerMarket):
+    questions: list[SeerMarketQuestions]
+
+
+class ExactInputSingleParams(BaseModel):
+    # from https://gnosisscan.io/address/0xffb643e73f280b97809a8b41f7232ab401a04ee1#code
+    model_config = ConfigDict(populate_by_name=True)
+    token_in: ChecksumAddress = Field(alias="tokenIn")
+    token_out: ChecksumAddress = Field(alias="tokenOut")
+    recipient: ChecksumAddress
+    deadline: int = Field(
+        default_factory=lambda: int((utcnow() + timedelta(minutes=10)).timestamp())
+    )
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out_minimum: Wei = Field(alias="amountOutMinimum")
+    limit_sqrt_price: Wei = Field(
+        alias="limitSqrtPrice", default_factory=lambda: Wei(0)
+    )  # 0 for convenience, we also don't expect major price shifts
 
 
-class RedeemParams(BaseModel):
+class QuoteExactInputSingleParams(BaseModel):
+    # from https://gnosisscan.io/address/0xcBaD9FDf0D2814659Eb26f600EFDeAF005Eda0F7#writeContract
     model_config = ConfigDict(populate_by_name=True)
-    market: ChecksumAddress
-    outcome_indices: list[int] = Field(alias="outcomeIndexes")
-    amounts: list[OutcomeWei]
+    token_in: ChecksumAddress = Field(alias="tokenIn")
+    token_out: ChecksumAddress = Field(alias="tokenOut")
+    amount_in: Wei = Field(alias="amountIn")
+    limit_sqrt_price: Wei = Field(
+        alias="limitSqrtPrice", default_factory=lambda: Wei(0)
+    )  # 0 for convenience, we also don't expect major price shifts
+
+
+class SeerTransactionType(str, Enum):
+    SWAP = "swap"
+    SPLIT = "split"
+
+
+class SeerTransaction(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    market_name: str = Field(alias="marketName")
+    market_id: HexBytes = Field(alias="marketId")
+    type: SeerTransactionType
+    block_number: int = Field(alias="blockNumber")
+    transaction_hash: HexBytes = Field(alias="transactionHash")
+    collateral: HexAddress
+    collateral_symbol: str = Field(alias="collateralSymbol")
+
+    token_in: HexAddress = Field(alias="tokenIn")
+    token_out: HexAddress = Field(alias="tokenOut")
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out: Wei = Field(alias="amountOut")
+    token_in_symbol: str = Field(alias="tokenInSymbol")
+    token_out_symbol: str = Field(alias="tokenOutSymbol")
+    timestamp: int | None = None
+
+    amount: Wei | None = None
+
+    @property
+    def timestamp_dt(self) -> DatetimeUTC | None:
+        return DatetimeUTC.to_datetime_utc(self.timestamp) if self.timestamp else None
+
+    @property
+    def token_in_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_in)
+
+    @property
+    def token_out_checksum(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.token_out)

prediction_market_agent_tooling/markets/seer/exceptions.py

@@ -0,0 +1,2 @@
+class PriceCalculationError(Exception):
+    """Raised when there's an error discovering prices for a market."""

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -1,46 +1,38 @@
-import typing as t
-
 from cachetools import TTLCache, cached
+from pydantic import BaseModel
 from web3 import Web3
 
+from prediction_market_agent_tooling.deploy.constants import is_invalid_outcome
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
     HexAddress,
     OutcomeStr,
+    OutcomeToken,
     Probability,
+    Wei,
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
+from prediction_market_agent_tooling.markets.seer.exceptions import (
+    PriceCalculationError,
+)
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    QuoteExactInputSingleParams,
+    SwaprQuoterContract,
+)
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 
 
-def _make_cache_key(
-    *args: t.Any,
-    token: ChecksumAddress,
-    collateral_exchange_amount: CollateralToken | None = None,
-) -> str:
-    """
-    Generate a unique cache key based on a token address and optional collateral token.
-    """
-
-    if collateral_exchange_amount is None:
-        return f"{token}-no_collateral"
-
-    return "-".join(
-        [
-            token,
-            collateral_exchange_amount.symbol,
-            str(collateral_exchange_amount.value),
-        ]
-    )
+class Prices(BaseModel):
+    priceOfCollateralInAskingToken: CollateralToken
+    priceOfAskingTokenInCollateral: CollateralToken
 
 
 class PriceManager:
@@ -61,20 +53,20 @@ class PriceManager:
         price_diff_pct = abs(old_price - normalized_price) / max(old_price, 0.01)
         if price_diff_pct > max_price_diff:
             logger.info(
-                f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
+                f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.to_0x_hex()} "
             )
 
-    @cached(TTLCache(maxsize=100, ttl=5 * 60), key=_make_cache_key)
-    def get_price_for_token(
+    def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
+        return self.get_amount_of_token_in_collateral(token, OutcomeToken(1))
+
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_collateral_in_token(
         self,
         token: ChecksumAddress,
-        collateral_exchange_amount: CollateralToken | None = None,
-    ) -> CollateralToken | None:
-        collateral_exchange_amount = (
-            collateral_exchange_amount
-            if collateral_exchange_amount is not None
-            else CollateralToken(1)
-        )
+        collateral_exchange_amount: CollateralToken,
+    ) -> OutcomeToken | None:
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return OutcomeToken(collateral_exchange_amount.value)
 
         try:
             buy_token_amount = get_buy_token_amount_else_raise(
@@ -82,23 +74,55 @@ class PriceManager:
                 sell_token=self.seer_market.collateral_token_contract_address_checksummed,
                 buy_token=token,
             )
-            price = collateral_exchange_amount.as_wei / buy_token_amount
-            return CollateralToken(price)
+            return OutcomeToken.from_token(buy_token_amount.as_token)
 
         except Exception as e:
             logger.warning(
                 f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
             )
-            return self.get_token_price_from_pools(token=token)
+            quote = self.get_swapr_input_quote(
+                input_token=self.seer_market.collateral_token_contract_address_checksummed,
+                output_token=token,
+                input_amount=collateral_exchange_amount.as_wei,
+            )
+            return OutcomeToken.from_token(quote.as_token)
 
-    @staticmethod
-    def pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
-        return pool.token0.id.hex().lower() == token.lower()
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_token_in_collateral(
+        self,
+        token: ChecksumAddress,
+        token_exchange_amount: OutcomeToken,
+    ) -> CollateralToken | None:
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return token_exchange_amount.as_token
+
+        try:
+            buy_collateral_amount = get_buy_token_amount_else_raise(
+                sell_amount=token_exchange_amount.as_outcome_wei.as_wei,
+                sell_token=token,
+                buy_token=self.seer_market.collateral_token_contract_address_checksummed,
+            )
+            return buy_collateral_amount.as_token
+
+        except Exception as e:
+            logger.warning(
+                f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
+            )
+            quote = self.get_swapr_input_quote(
+                input_token=token,
+                output_token=self.seer_market.collateral_token_contract_address_checksummed,
+                input_amount=token_exchange_amount.as_outcome_wei.as_wei,
+            )
+            return quote.as_token
 
     def get_token_price_from_pools(
         self,
         token: ChecksumAddress,
-    ) -> CollateralToken | None:
+    ) -> Prices | None:
+        """
+        Although this might come handy,
+        consider using `get_amount_of_collateral_in_token` or `get_amount_of_token_in_collateral` to have an exact quote.
+        """
         pool = SeerSubgraphHandler().get_pool_by_token(
             token_address=token,
             collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
@@ -108,15 +132,24 @@ class PriceManager:
             logger.warning(f"Could not find a pool for {token=}")
             return None
 
-        # The mapping below is odd but surprisingly the Algebra subgraph delivers the token1Price
-        # for the token0 and the token0Price for the token1 pool.
-        # For example, in a outcomeYES (token0)/sDAI pool (token1), token1Price is the price of outcomeYES in units of sDAI.
-        price = (
-            pool.token1Price
-            if self.pool_token0_matches_token(token=token, pool=pool)
-            else pool.token0Price
+        if (
+            Web3.to_checksum_address(pool.token0.id)
+            == self.seer_market.collateral_token_contract_address_checksummed
+        ):
+            price_coll_in_asking = (
+                pool.token1Price
+            )  # how many outcome tokens per 1 collateral
+            price_asking_in_coll = (
+                pool.token0Price
+            )  # how many collateral tokens per 1 outcome
+        else:
+            price_coll_in_asking = pool.token0Price
+            price_asking_in_coll = pool.token1Price
+
+        return Prices(
+            priceOfCollateralInAskingToken=price_coll_in_asking,
+            priceOfAskingTokenInCollateral=price_asking_in_coll,
         )
-        return price
 
     def build_probability_map(self) -> dict[OutcomeStr, Probability]:
         # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
@@ -128,7 +161,7 @@ class PriceManager:
             )
             # It's okay if invalid (last) outcome has price 0, but not the other outcomes.
             if price is None and idx != len(self.seer_market.wrapped_tokens) - 1:
-                raise ValueError(
+                raise PriceCalculationError(
                     f"Couldn't get price for {wrapped_token} for market {self.seer_market.url}."
                 )
             price_data[wrapped_token] = (
@@ -142,7 +175,7 @@ class PriceManager:
             sum(price_data.values(), start=CollateralToken.zero())
             == CollateralToken.zero()
         ):
-            raise ValueError(
+            raise PriceCalculationError(
                 f"All prices for market {self.seer_market.url} are zero. This shouldn't happen."
             )
 
@@ -157,6 +190,88 @@ class PriceManager:
             outcome = self.seer_market.outcomes[
                 self.seer_market.wrapped_tokens.index(outcome_token)
             ]
-            normalized_prices[OutcomeStr(outcome)] = new_price
+            normalized_prices[outcome] = new_price
 
         return normalized_prices
+
+    def build_initial_probs_from_pool(
+        self, model: SeerMarket, wrapped_tokens: list[ChecksumAddress]
+    ) -> tuple[dict[OutcomeStr, Probability], dict[OutcomeStr, OutcomeToken]]:
+        """
+        Builds a map of outcome to probability and outcome token pool.
+        """
+        probability_map = {}
+        outcome_token_pool = {}
+        wrapped_tokens_with_supply = [
+            (
+                token,
+                SeerSubgraphHandler().get_pool_by_token(
+                    token, model.collateral_token_contract_address_checksummed
+                ),
+            )
+            for token in wrapped_tokens
+        ]
+        wrapped_tokens_with_supply = [
+            (token, pool)
+            for token, pool in wrapped_tokens_with_supply
+            if pool is not None
+        ]
+
+        for token, pool in wrapped_tokens_with_supply:
+            if pool is None or pool.token1.id is None or pool.token0.id is None:
+                continue
+            if HexBytes(token) == HexBytes(pool.token1.id):
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken0)
+                    if pool.totalValueLockedToken0 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token0Price.value)
+            else:
+                outcome_token_pool[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = (
+                    OutcomeToken(pool.totalValueLockedToken1)
+                    if pool.totalValueLockedToken1 is not None
+                    else OutcomeToken(0)
+                )
+                probability_map[
+                    OutcomeStr(model.outcomes[wrapped_tokens.index(token)])
+                ] = Probability(pool.token1Price.value)
+
+        for outcome in model.outcomes:
+            if outcome not in outcome_token_pool:
+                outcome_token_pool[outcome] = OutcomeToken(0)
+                logger.warning(
+                    f"Outcome {outcome} not found in outcome_token_pool for market {self.seer_market.url}."
+                )
+            if outcome not in probability_map:
+                if not is_invalid_outcome(outcome):
+                    raise PriceCalculationError(
+                        f"Couldn't get probability for {outcome} for market {self.seer_market.url}."
+                    )
+                else:
+                    probability_map[outcome] = Probability(0)
+        return probability_map, outcome_token_pool
+
+    def get_swapr_input_quote(
+        self,
+        input_token: ChecksumAddress,
+        output_token: ChecksumAddress,
+        input_amount: Wei,
+        web3: Web3 | None = None,
+    ) -> Wei:  # Not marked as OutcomeWei, but this works for both buying and selling.
+        quoter = SwaprQuoterContract()
+        amount_out, _ = quoter.quote_exact_input_single(
+            QuoteExactInputSingleParams(
+                token_in=input_token,
+                token_out=output_token,
+                amount_in=input_amount,
+            ),
+            web3=web3,
+        )
+        return amount_out