prediction-market-agent-tooling 0.68.0.dev999__py3-none-any.whl → 0.69.0__py3-none-any.whl

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -30,8 +30,9 @@ class PolymarketSubgraphHandler(BaseSubgraphHandler):
     def get_conditions(
         self, condition_ids: list[HexBytes]
     ) -> list[ConditionSubgraphModel]:
-        where_stms = {"id_in": [i.hex() for i in condition_ids]}
+        where_stms = {"id_in": [i.to_0x_hex() for i in condition_ids]}
         conditions = self.conditions_subgraph.Query.conditions(
+            first=len(condition_ids),
             where=where_stms,
         )
 

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,5 +1,6 @@
 import typing as t
 from datetime import timedelta
+from enum import Enum
 from typing import Annotated
 from urllib.parse import urljoin
 
@@ -139,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)
@@ -160,7 +156,7 @@ class SeerMarket(BaseModel):
     @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):
@@ -188,3 +184,42 @@ class ExactInputSingleParams(BaseModel):
     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/price_manager.py

@@ -2,11 +2,15 @@ from cachetools import TTLCache, cached
 from pydantic import BaseModel
 from web3 import Web3
 
+from prediction_market_agent_tooling.deploy.constants import (
+    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
+)
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
     HexAddress,
     OutcomeStr,
+    OutcomeToken,
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
@@ -46,7 +50,7 @@ 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()} "
             )
 
     def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
@@ -182,3 +186,67 @@ class PriceManager:
             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 INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower():
+                    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

prediction_market_agent_tooling/markets/seer/seer.py

@@ -28,7 +28,6 @@ from prediction_market_agent_tooling.markets.agent_market import (
     FilterBy,
     ParentMarket,
     ProcessedMarket,
-    ProcessedTradedMarket,
     QuestionType,
     SortBy,
 )
@@ -36,9 +35,13 @@ from prediction_market_agent_tooling.markets.blockchain_utils import store_trade
 from prediction_market_agent_tooling.markets.data_models import (
     ExistingPosition,
     Resolution,
+    ResolvedBet,
 )
 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 import (
+    OmenAgentMarket,
+    send_keeping_token_to_eoa_xdai,
+)
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     SDAI_CONTRACT_ADDRESS,
 )
@@ -54,6 +57,7 @@ from prediction_market_agent_tooling.markets.seer.exceptions import (
     PriceCalculationError,
 )
 from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_api import get_seer_transactions
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     GnosisRouter,
     SeerMarketFactory,
@@ -79,7 +83,6 @@ from prediction_market_agent_tooling.tools.cow.cow_order import (
     OrderStatusError,
     get_orders_by_owner,
     get_trades_by_order_uid,
-    get_trades_by_owner,
     swap_tokens_waiting,
     wait_for_order_completion,
 )
@@ -136,7 +139,7 @@ class SeerAgentMarket(AgentMarket):
 
     def store_trades(
         self,
-        traded_market: ProcessedTradedMarket | None,
+        traded_market: ProcessedMarket | None,
         keys: APIKeys,
         agent_name: str,
         web3: Web3 | None = None,
@@ -262,10 +265,6 @@ class SeerAgentMarket(AgentMarket):
             amounts_ot=amounts_ot,
         )
 
-    @staticmethod
-    def get_user_id(api_keys: APIKeys) -> str:
-        return OmenAgentMarket.get_user_id(api_keys)
-
     @staticmethod
     def _filter_markets_contained_in_trades(
         api_keys: APIKeys,
@@ -274,10 +273,12 @@ class SeerAgentMarket(AgentMarket):
         """
         We filter the markets using previous trades by the user so that we don't have to process all Seer markets.
         """
-        trades_by_user = get_trades_by_owner(api_keys.bet_from_address)
+        trades_by_user = get_seer_transactions(
+            api_keys.bet_from_address, RPCConfig().CHAIN_ID
+        )
 
-        traded_tokens = {t.buyToken for t in trades_by_user}.union(
-            [t.sellToken for t in trades_by_user]
+        traded_tokens = {t.token_in_checksum for t in trades_by_user}.union(
+            [t.token_out_checksum for t in trades_by_user]
         )
         filtered_markets: list[SeerMarket] = []
         for market in markets:
@@ -315,19 +316,43 @@ class SeerAgentMarket(AgentMarket):
             for market in filtered_markets
             if market.is_redeemable(owner=api_keys.bet_from_address, web3=web3)
         ]
+        logger.info(f"Got {len(markets_to_redeem)} markets to redeem on Seer.")
 
         gnosis_router = GnosisRouter()
         for market in markets_to_redeem:
             try:
+                # GnosisRouter needs approval to use our outcome tokens
+                for i, token in enumerate(market.wrapped_tokens):
+                    ContractERC20OnGnosisChain(
+                        address=Web3.to_checksum_address(token)
+                    ).approve(
+                        api_keys,
+                        for_address=gnosis_router.address,
+                        amount_wei=market_balances[market.id][i].as_wei,
+                        web3=web3,
+                    )
+
+                # We can only ask for redeem of outcome tokens on correct outcomes
+                # TODO: Implement more complex use-cases: https://github.com/gnosis/prediction-market-agent-tooling/issues/850
+                amounts_to_redeem = [
+                    (amount if numerator > 0 else OutcomeWei(0))
+                    for amount, numerator in zip(
+                        market_balances[market.id], market.payout_numerators
+                    )
+                ]
+
+                # Redeem!
                 params = RedeemParams(
                     market=Web3.to_checksum_address(market.id),
                     outcome_indices=list(range(len(market.payout_numerators))),
-                    amounts=market_balances[market.id],
+                    amounts=amounts_to_redeem,
                 )
                 gnosis_router.redeem_to_base(api_keys, params=params, web3=web3)
-                logger.info(f"Redeemed market {market.id.hex()}")
-            except Exception as e:
-                logger.error(f"Failed to redeem market {market.id.hex()}, {e}")
+                logger.info(f"Redeemed market {market.url}.")
+            except Exception:
+                logger.exception(
+                    f"Failed to redeem market {market.url}, {market.outcomes}, with amounts {market_balances[market.id]} and payout numerators {market.payout_numerators}, and wrapped tokens {market.wrapped_tokens}."
+                )
 
         # GnosisRouter withdraws sDai into wxDAI/xDai on its own, so no auto-withdraw needed by us.
 
@@ -345,6 +370,17 @@ class SeerAgentMarket(AgentMarket):
 
         return False
 
+    def ensure_min_native_balance(
+        self,
+        min_required_balance: xDai,
+        multiplier: float = 3.0,
+    ) -> None:
+        send_keeping_token_to_eoa_xdai(
+            api_keys=APIKeys(),
+            min_required_balance=min_required_balance,
+            multiplier=multiplier,
+        )
+
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)
@@ -367,7 +403,7 @@ class SeerAgentMarket(AgentMarket):
             raise ValueError("Seer categorical markets must have 1 question.")
 
         question = model.questions[0]
-        outcome = model.outcomes[int(question.question.best_answer.hex(), 16)]
+        outcome = model.outcomes[int(question.question.best_answer.to_0x_hex(), 16)]
         return Resolution(outcome=outcome, invalid=False)
 
     @staticmethod
@@ -411,13 +447,17 @@ class SeerAgentMarket(AgentMarket):
         must_have_prices: bool,
     ) -> t.Optional["SeerAgentMarket"]:
         price_manager = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
-
-        probability_map = {}
+        wrapped_tokens = [Web3.to_checksum_address(i) for i in model.wrapped_tokens]
         try:
-            probability_map = price_manager.build_probability_map()
+            (
+                probability_map,
+                outcome_token_pool,
+            ) = price_manager.build_initial_probs_from_pool(
+                model=model, wrapped_tokens=wrapped_tokens
+            )
         except PriceCalculationError as e:
             logger.info(
-                f"Error when calculating probabilities for market {model.id.hex()} - {e}"
+                f"Error when calculating probabilities for market {model.id.to_0x_hex()} - {e}"
             )
             if must_have_prices:
                 # Price calculation failed, so don't return the market
@@ -428,7 +468,7 @@ class SeerAgentMarket(AgentMarket):
         parent = SeerAgentMarket.get_parent(model=model, seer_subgraph=seer_subgraph)
 
         market = SeerAgentMarket(
-            id=model.id.hex(),
+            id=model.id.to_0x_hex(),
             question=model.title,
             creator=model.creator,
             created_time=model.created_time,
@@ -437,9 +477,9 @@ class SeerAgentMarket(AgentMarket):
             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],
+            wrapped_tokens=wrapped_tokens,
             fees=MarketFees.get_zero_fees(),
-            outcome_token_pool=None,
+            outcome_token_pool=outcome_token_pool,
             outcomes_supply=model.outcomes_supply,
             resolution=resolution,
             volume=None,
@@ -451,6 +491,15 @@ class SeerAgentMarket(AgentMarket):
 
         return market
 
+    @staticmethod
+    def get_resolved_bets_made_since(
+        better_address: ChecksumAddress,
+        start_time: DatetimeUTC,
+        end_time: DatetimeUTC | None,
+    ) -> list[ResolvedBet]:
+        # TODO: https://github.com/gnosis/prediction-market-agent-tooling/issues/841
+        raise NotImplementedError()
+
     @staticmethod
     def get_markets(
         limit: int,
@@ -521,7 +570,9 @@ class SeerAgentMarket(AgentMarket):
             )
 
             token_balance = token_contract.balance_of_in_tokens(
-                for_address=Web3.to_checksum_address(HexAddress(HexStr(pool.id.hex()))),
+                for_address=Web3.to_checksum_address(
+                    HexAddress(HexStr(pool.id.to_0x_hex()))
+                ),
                 web3=web3,
             )
             collateral_balance = p.get_amount_of_token_in_collateral(
@@ -602,7 +653,7 @@ class SeerAgentMarket(AgentMarket):
                 )
             cow_tx_hash = trades[0].txHash
             logger.info(f"TxHash is {cow_tx_hash=} for {order_metadata.uid.root=}.")
-            return cow_tx_hash.hex()
+            return cow_tx_hash.to_0x_hex()
 
         except (
             UnexpectedResponseError,
@@ -635,7 +686,7 @@ class SeerAgentMarket(AgentMarket):
             )
             swap_pool_tx_hash = tx_receipt["transactionHash"]
             logger.info(f"TxHash is {swap_pool_tx_hash=}.")
-            return swap_pool_tx_hash.hex()
+            return swap_pool_tx_hash.to_0x_hex()
 
     def place_bet(
         self,

prediction_market_agent_tooling/markets/seer/seer_api.py

@@ -0,0 +1,28 @@
+import httpx
+
+from prediction_market_agent_tooling.gtypes import ChainID, ChecksumAddress
+from prediction_market_agent_tooling.markets.seer.data_models import SeerTransaction
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+
+
+def get_seer_transactions(
+    account: ChecksumAddress,
+    chain_id: ChainID,
+    start_time: DatetimeUTC | None = None,
+    end_time: DatetimeUTC | None = None,
+    timeout: int = 60,  # The endpoint is pretty slow to respond atm.
+) -> list[SeerTransaction]:
+    url = "https://app.seer.pm/.netlify/functions/get-transactions"
+    params: dict[str, str | int] = {
+        "account": account,
+        "chainId": chain_id,
+        "startTime": to_int_timestamp(start_time) if start_time else 0,
+        "endTime": to_int_timestamp(end_time if end_time else utcnow()),
+    }
+    response = httpx.get(url, params=params, timeout=timeout)
+    response.raise_for_status()
+    response_json = response.json()
+
+    transactions = [SeerTransaction.model_validate(tx) for tx in response_json]
+    return transactions

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -29,10 +29,17 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
     SeerMarketQuestions,
     SeerMarketWithQuestions,
 )
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    SeerPool,
+    SwaprSwap,
+)
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
-from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+from prediction_market_agent_tooling.tools.utils import (
+    DatetimeUTC,
+    to_int_timestamp,
+    utcnow,
+)
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
 
@@ -155,7 +162,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
                 raise ValueError(f"Unknown filter {filter_by}")
 
         if parent_market_id:
-            and_stms["parentMarket"] = parent_market_id.hex().lower()
+            and_stms["parentMarket"] = parent_market_id.to_0x_hex().lower()
 
         outcome_filters: list[dict[str, t.Any]] = []
 
@@ -294,7 +301,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         self, market_ids: list[HexBytes]
     ) -> list[SeerMarketQuestions]:
         where = unwrap_generic_value(
-            {"market_in": [market_id.hex().lower() for market_id in market_ids]}
+            {"market_in": [market_id.to_0x_hex().lower() for market_id in market_ids]}
         )
         markets_field = self.seer_subgraph.Query.marketQuestions(where=where)
         fields = self._get_fields_for_questions(markets_field)
@@ -302,7 +309,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         return questions
 
     def get_market_by_id(self, market_id: HexBytes) -> SeerMarketWithQuestions:
-        markets_field = self.seer_subgraph.Query.market(id=market_id.hex().lower())
+        markets_field = self.seer_subgraph.Query.market(
+            id=market_id.to_0x_hex().lower()
+        )
         fields = self._get_fields_for_markets(markets_field)
         markets = self.do_query(fields=fields, pydantic_model=SeerMarket)
         if len(markets) != 1:
@@ -326,8 +335,8 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         ]
         return fields
 
-    def get_market_by_wrapped_token(self, token: ChecksumAddress) -> SeerMarket:
-        where_stms = {"wrappedTokens_contains": [token]}
+    def get_market_by_wrapped_token(self, tokens: list[ChecksumAddress]) -> SeerMarket:
+        where_stms = {"wrappedTokens_contains": tokens}
         markets_field = self.seer_subgraph.Query.markets(
             where=unwrap_generic_value(where_stms)
         )
@@ -339,20 +348,27 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             )
         return markets[0]
 
-    def _get_fields_for_pools(self, pools_field: FieldPath) -> list[FieldPath]:
-        fields = [
-            pools_field.id,
-            pools_field.liquidity,
-            pools_field.sqrtPrice,
-            pools_field.token0Price,
-            pools_field.token1Price,
-            pools_field.token0.id,
-            pools_field.token0.name,
-            pools_field.token0.symbol,
-            pools_field.token1.id,
-            pools_field.token1.name,
-            pools_field.token1.symbol,
+    def _get_fields_for_seer_token(self, fields: FieldPath) -> list[FieldPath]:
+        return [
+            fields.id,
+            fields.name,
+            fields.symbol,
         ]
+
+    def _get_fields_for_pools(self, pools_field: FieldPath) -> list[FieldPath]:
+        fields = (
+            [
+                pools_field.id,
+                pools_field.liquidity,
+                pools_field.sqrtPrice,
+                pools_field.token0Price,
+                pools_field.token1Price,
+                pools_field.totalValueLockedToken0,
+                pools_field.totalValueLockedToken1,
+            ]
+            + self._get_fields_for_seer_token(pools_field.token0)
+            + self._get_fields_for_seer_token(pools_field.token1)
+        )
         return fields
 
     def get_pool_by_token(
@@ -392,6 +408,41 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             return pools[0]
         return None
 
+    def _get_fields_for_swaps(self, swaps_field: FieldPath) -> list[FieldPath]:
+        fields = (
+            [
+                swaps_field.id,
+                swaps_field.pool.id,
+                swaps_field.sender,
+                swaps_field.recipient,
+                swaps_field.price,
+                swaps_field.amount0,
+                swaps_field.amount1,
+                swaps_field.timestamp,
+            ]
+            + self._get_fields_for_seer_token(swaps_field.token0)
+            + self._get_fields_for_seer_token(swaps_field.token1)
+        )
+        return fields
+
+    def get_swaps(
+        self,
+        recipient: ChecksumAddress,
+        timestamp_gt: DatetimeUTC | None = None,
+        timestamp_lt: DatetimeUTC | None = None,
+    ) -> list[SwaprSwap]:
+        where_argument: dict[str, Any] = {"recipient": recipient.lower()}
+        if timestamp_gt is not None:
+            where_argument["timestamp_gt"] = to_int_timestamp(timestamp_gt)
+        if timestamp_lt is not None:
+            where_argument["timestamp_lt"] = to_int_timestamp(timestamp_lt)
+
+        swaps_field = self.swapr_algebra_subgraph.Query.swaps(where=where_argument)
+        fields = self._get_fields_for_swaps(swaps_field)
+        swaps = self.do_query(fields=fields, pydantic_model=SwaprSwap)
+
+        return swaps
+
 
 class SeerQuestionsCache(metaclass=SingletonMeta):
     """A singleton cache for storing and retrieving Seer market questions.

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -1,12 +1,17 @@
 from pydantic import BaseModel, ConfigDict, Field
+from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
 from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
     CollateralToken,
     HexAddress,
     HexBytes,
     OutcomeStr,
+    OutcomeToken,
+    Wei,
 )
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
 class SeerToken(BaseModel):
@@ -14,6 +19,10 @@ class SeerToken(BaseModel):
     name: str
     symbol: str
 
+    @property
+    def address(self) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.id.hex())
+
 
 class SeerPool(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
@@ -24,6 +33,64 @@ class SeerPool(BaseModel):
     token0Price: CollateralToken
     token1Price: CollateralToken
     sqrtPrice: int
+    totalValueLockedToken0: float
+    totalValueLockedToken1: float
+
+
+class SwaprSwap(BaseModel):
+    id: str  # It's like "0x73afd8f096096552d72a0b40ea66d2076be136c6a531e2f6b190d151a750271e#32" (note the #32) # web3-private-key-ok
+    recipient: HexAddress
+    sender: HexAddress
+    price: Wei
+    amount0: CollateralToken
+    amount1: CollateralToken
+    token0: SeerToken
+    token1: SeerToken
+    timestamp: int
+
+    @property
+    def timestamp_utc(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.timestamp)
+
+    @property
+    def added_to_pool(self) -> CollateralToken:
+        return self.amount0 if self.amount0 > 0 else self.amount1
+
+    @property
+    def withdrawn_from_pool(self) -> OutcomeToken:
+        return (
+            OutcomeToken(abs(self.amount0).value)
+            if self.amount0 < 0
+            else OutcomeToken(abs(self.amount1).value)
+        )
+
+
+class SeerSwap(BaseModel):
+    id: str  # It's like "0x73afd8f096096552d72a0b40ea66d2076be136c6a531e2f6b190d151a750271e#32" (note the #32) # web3-private-key-ok
+    recipient: HexAddress
+    sender: HexAddress
+    price: Wei
+    amount0: CollateralToken
+    amount1: CollateralToken
+    token0: SeerToken
+    token1: SeerToken
+    timestamp: int
+
+    @property
+    def timestamp_utc(self) -> DatetimeUTC:
+        return DatetimeUTC.to_datetime_utc(self.timestamp)
+
+    @property
+    def buying_collateral_amount(self) -> CollateralToken:
+        return self.amount0 if self.amount0 > 0 else self.amount1
+
+    @property
+    def received_shares_amount(self) -> OutcomeToken:
+        return (
+            OutcomeToken(abs(self.amount0).value)
+            if self.amount0 < 0
+            else OutcomeToken(abs(self.amount1).value)
+        )
 
 
 class NewMarketEvent(BaseModel):