prediction-market-agent-tooling 0.66.5__py3-none-any.whl → 0.67.1__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/seer.py

@@ -24,6 +24,8 @@ from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
+    MarketFees,
+    MarketType,
     ProcessedMarket,
     ProcessedTradedMarket,
     SortBy,
@@ -66,8 +68,9 @@ from prediction_market_agent_tooling.tools.contract import (
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     NoLiquidityAvailableOnCowException,
-    get_buy_token_amount_else_raise,
+    OrderStatusError,
     get_orders_by_owner,
+    get_trades_by_order_uid,
     get_trades_by_owner,
     swap_tokens_waiting,
     wait_for_order_completion,
@@ -76,6 +79,9 @@ 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.tokens.slippage import (
+    get_slippage_tolerance_per_token,
+)
 from prediction_market_agent_tooling.tools.tokens.usd import (
     get_token_in_usd,
     get_usd_in_token,
@@ -95,6 +101,7 @@ class SeerAgentMarket(AgentMarket):
         None  # Seer markets don't have a description, so just default to None.
     )
     outcomes_supply: int
+    minimum_market_liquidity_required: CollateralToken = CollateralToken(1)
 
     def get_collateral_token_contract(
         self, web3: Web3 | None = None
@@ -131,45 +138,34 @@ class SeerAgentMarket(AgentMarket):
             web3=web3,
         )
 
+    def get_price_manager(self) -> PriceManager:
+        return PriceManager.build(HexBytes(HexStr(self.id)))
+
     def get_token_in_usd(self, x: CollateralToken) -> USD:
-        try:
-            return get_token_in_usd(
-                x, self.collateral_token_contract_address_checksummed
-            )
-        except NoLiquidityAvailableOnCowException as e:
-            logger.warning(
-                f"Could not get quote for {self.collateral_token_contract_address_checksummed} from Cow, exception {e=}. Falling back to pools. "
+        p = self.get_price_manager()
+        sdai_amount = p.get_amount_of_collateral_in_token(
+            # Hard-coded SDAI, because Seer is atm hard-coded it as well, and it's needed in case of fallback to pools. CoW would work with other tokens as well.
+            SDAI_CONTRACT_ADDRESS,
+            x,
+        )
+        if sdai_amount is None:
+            raise RuntimeError(
+                "Both CoW and pool-fallback way of getting price failed."
             )
-            usd_token_price = self.get_collateral_price_from_pools()
-            if usd_token_price is None:
-                raise RuntimeError(
-                    "Both CoW and pool-fallback way of getting price failed."
-                ) from e
-            return USD(x.value * usd_token_price.value)
-
-    def get_collateral_price_from_pools(self) -> USD | None:
-        p = PriceManager.build(HexBytes(HexStr(self.id)))
-        token_price = p.get_token_price_from_pools(token=SDAI_CONTRACT_ADDRESS)
-        if token_price:
-            return get_token_in_usd(token_price, SDAI_CONTRACT_ADDRESS)
-
-        return None
+        return get_token_in_usd(sdai_amount, SDAI_CONTRACT_ADDRESS)
 
     def get_usd_in_token(self, x: USD) -> CollateralToken:
-        try:
-            return get_usd_in_token(
-                x, self.collateral_token_contract_address_checksummed
-            )
-        except NoLiquidityAvailableOnCowException as e:
-            logger.warning(
-                f"Could not get quote for {self.collateral_token_contract_address_checksummed} from Cow, exception {e=}. Falling back to pools. "
+        p = self.get_price_manager()
+        token_amount = p.get_amount_of_token_in_collateral(
+            # Hard-coded SDAI, because Seer is atm hard-coded it as well, and it's needed in case of fallback to pools. CoW would work with other tokens as well.
+            SDAI_CONTRACT_ADDRESS,
+            get_usd_in_token(x, SDAI_CONTRACT_ADDRESS),
+        )
+        if token_amount is None:
+            raise RuntimeError(
+                "Both CoW and pool-fallback way of getting price failed."
             )
-            usd_token_price = self.get_collateral_price_from_pools()
-            if not usd_token_price:
-                raise RuntimeError(
-                    "Both CoW and pool-fallback way of getting price failed."
-                ) from e
-            return CollateralToken(x.value / usd_token_price.value)
+        return token_amount
 
     def get_buy_token_amount(
         self, bet_amount: USD | CollateralToken, outcome_str: OutcomeStr
@@ -185,16 +181,15 @@ class SeerAgentMarket(AgentMarket):
 
         bet_amount_in_tokens = self.get_in_token(bet_amount)
 
-        p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
-        price = p.get_price_for_token(
+        p = self.get_price_manager()
+        amount_outcome_tokens = p.get_amount_of_collateral_in_token(
             token=outcome_token, collateral_exchange_amount=bet_amount_in_tokens
         )
-        if not price:
+        if not amount_outcome_tokens:
             logger.info(f"Could not get price for token {outcome_token}")
             return None
 
-        amount_outcome_tokens = bet_amount_in_tokens / price
-        return OutcomeToken(amount_outcome_tokens)
+        return OutcomeToken(amount_outcome_tokens.value)
 
     def get_sell_value_of_outcome_token(
         self, outcome: OutcomeStr, amount: OutcomeToken
@@ -203,26 +198,18 @@ class SeerAgentMarket(AgentMarket):
             return CollateralToken.zero()
 
         wrapped_outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        try:
-            # We calculate how much collateral we would get back if we sold `amount` of outcome token.
-            value_outcome_token_in_collateral = get_buy_token_amount_else_raise(
-                sell_amount=amount.as_outcome_wei.as_wei,
-                sell_token=wrapped_outcome_token,
-                buy_token=self.collateral_token_contract_address_checksummed,
-            )
-            return value_outcome_token_in_collateral.as_token
-        except NoLiquidityAvailableOnCowException as e:
-            logger.warning(
-                f"No liquidity available on Cow for {wrapped_outcome_token} -> {self.collateral_token_contract_address_checksummed}."
+
+        p = self.get_price_manager()
+        value_outcome_token_in_collateral = p.get_amount_of_token_in_collateral(
+            wrapped_outcome_token, amount.as_token
+        )
+
+        if value_outcome_token_in_collateral is None:
+            raise RuntimeError(
+                f"Could not get price for token from pools for {wrapped_outcome_token}"
             )
-            p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
-            price = p.get_token_price_from_pools(token=wrapped_outcome_token)
-            if not price:
-                logger.info(
-                    f"Could not get price for token from pools for {wrapped_outcome_token}"
-                )
-                raise e
-            return CollateralToken(price.value * amount.value)
+
+        return value_outcome_token_in_collateral
 
     @staticmethod
     def get_trade_balance(api_keys: APIKeys) -> USD:
@@ -231,9 +218,7 @@ class SeerAgentMarket(AgentMarket):
     def get_tiny_bet_amount(self) -> CollateralToken:
         return self.get_in_token(SEER_TINY_BET_AMOUNT)
 
-    def get_position_else_raise(
-        self, user_id: str, web3: Web3 | None = None
-    ) -> ExistingPosition:
+    def get_position(self, user_id: str, web3: Web3 | None = None) -> ExistingPosition:
         """
         Fetches position from the user in a given market.
         We ignore the INVALID balances since we are only interested in binary outcomes.
@@ -264,15 +249,6 @@ class SeerAgentMarket(AgentMarket):
             amounts_ot=amounts_ot,
         )
 
-    def get_position(
-        self, user_id: str, web3: Web3 | None = None
-    ) -> ExistingPosition | None:
-        try:
-            return self.get_position_else_raise(user_id=user_id, web3=web3)
-        except Exception as e:
-            logger.warning(f"Could not get position for user {user_id}, exception {e}")
-            return None
-
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
         return OmenAgentMarket.get_user_id(api_keys)
@@ -409,16 +385,16 @@ class SeerAgentMarket(AgentMarket):
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        fetch_categorical_markets: bool = False,
-        fetch_scalar_markets: bool = False,
+        market_type: MarketType = MarketType.ALL,
+        include_conditional_markets: bool = False,
     ) -> t.Sequence["SeerAgentMarket"]:
         seer_subgraph = SeerSubgraphHandler()
+
         markets = seer_subgraph.get_markets(
             limit=limit,
             sort_by=sort_by,
             filter_by=filter_by,
-            include_categorical_markets=fetch_categorical_markets,
-            include_only_scalar_markets=fetch_scalar_markets,
+            market_type=market_type,
             include_conditional_markets=False,
         )
 
@@ -461,7 +437,8 @@ class SeerAgentMarket(AgentMarket):
                 f"Could not fetch pool for token {outcome_token}, no liquidity available for outcome."
             )
             return CollateralToken(0)
-        p = PriceManager.build(HexBytes(HexStr(self.id)))
+
+        p = self.get_price_manager()
         total = CollateralToken(0)
 
         for token_address in [pool.token0.id, pool.token1.id]:
@@ -474,19 +451,13 @@ class SeerAgentMarket(AgentMarket):
                 for_address=Web3.to_checksum_address(HexAddress(HexStr(pool.id.hex()))),
                 web3=web3,
             )
-
-            # get price
-            token_price_in_sdai = (
-                p.get_token_price_from_pools(token=token_address_checksummed)
-                if token_address_checksummed
-                != self.collateral_token_contract_address_checksummed
-                else CollateralToken(1.0)
+            collateral_balance = p.get_amount_of_token_in_collateral(
+                token_address_checksummed, token_balance
             )
 
             # We ignore the liquidity in outcome tokens if price unknown.
-            if token_price_in_sdai:
-                sdai_balance = token_balance * token_price_in_sdai
-                total += sdai_balance
+            if collateral_balance:
+                total += collateral_balance
 
         return total
 
@@ -501,7 +472,7 @@ class SeerAgentMarket(AgentMarket):
 
     def has_liquidity_for_outcome(self, outcome: OutcomeStr) -> bool:
         liquidity = self.get_liquidity_for_outcome(outcome)
-        return liquidity > CollateralToken(0)
+        return liquidity > self.minimum_market_liquidity_required
 
     def has_liquidity(self) -> bool:
         # We define a market as having liquidity if it has liquidity for all outcomes except for the invalid (index -1)
@@ -534,7 +505,7 @@ class SeerAgentMarket(AgentMarket):
         Returns:
             Transaction hash of the successful swap
         """
-
+        slippage_tolerance = get_slippage_tolerance_per_token(sell_token, buy_token)
         try:
             _, order = swap_tokens_waiting(
                 amount_wei=amount_wei,
@@ -544,17 +515,26 @@ class SeerAgentMarket(AgentMarket):
                 web3=web3,
                 wait_order_complete=False,
                 timeout=timedelta(minutes=2),
+                slippage_tolerance=slippage_tolerance,
             )
             order_metadata = asyncio.run(wait_for_order_completion(order=order))
-            logger.debug(
+            logger.info(
                 f"Swapped {sell_token} for {buy_token}. Order details {order_metadata}"
             )
-            return order_metadata.uid.root
+            trades = get_trades_by_order_uid(HexBytes(order_metadata.uid.root))
+            if len(trades) != 1:
+                raise ValueError(
+                    f"Expected exactly 1 trade from {order_metadata=}, but got {len(trades)=}."
+                )
+            cow_tx_hash = trades[0].txHash
+            logger.info(f"TxHash for {order_metadata.uid.root=} is {cow_tx_hash=}.")
+            return cow_tx_hash.hex()
 
         except (
             UnexpectedResponseError,
             TimeoutError,
             NoLiquidityAvailableOnCowException,
+            OrderStatusError,
         ) as e:
             # We don't retry if not enough balance.
             if "InsufficientBalance" in str(e):

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -1,5 +1,6 @@
 import sys
 import typing as t
+from enum import Enum
 from typing import Any
 
 from subgrounds import FieldPath
@@ -13,7 +14,11 @@ from prediction_market_agent_tooling.deploy.constants import (
 )
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
+from prediction_market_agent_tooling.markets.agent_market import (
+    FilterBy,
+    MarketType,
+    SortBy,
+)
 from prediction_market_agent_tooling.markets.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
@@ -24,6 +29,14 @@ from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
 
+class TemplateId(int, Enum):
+    """Template IDs used in Reality.eth questions."""
+
+    SCALAR = 1
+    CATEGORICAL = 2
+    MULTICATEGORICAL = 3
+
+
 class SeerSubgraphHandler(BaseSubgraphHandler):
     """
     Class responsible for handling interactions with Seer subgraphs.
@@ -70,6 +83,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.collateralToken,
             markets_field.upperBound,
             markets_field.lowerBound,
+            markets_field.templateId,
         ]
         return fields
 
@@ -100,8 +114,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         filter_by: FilterBy,
         outcome_supply_gt_if_open: Wei,
         include_conditional_markets: bool = False,
-        include_categorical_markets: bool = True,
-        include_only_scalar_markets: bool = False,
+        market_type: MarketType = MarketType.ALL,
     ) -> dict[Any, Any]:
         now = to_int_timestamp(utcnow())
 
@@ -123,43 +136,47 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         if not include_conditional_markets:
             and_stms["parentMarket"] = ADDRESS_ZERO.lower()
 
-        yes_stms, no_stms = {}, {}
-        exclude_scalar_yes, exclude_scalar_no = {}, {}
+        outcome_filters: list[dict[str, t.Any]] = []
 
-        # Return scalar markets.
-        if include_only_scalar_markets:
-            # We are interested in scalar markets only - this excludes categorical markets
-            yes_stms = SeerSubgraphHandler._create_case_variations_condition(
+        if market_type == MarketType.SCALAR:
+            # Template ID "1" + UP/DOWN outcomes for scalar markets
+            and_stms["templateId"] = TemplateId.SCALAR.value
+            up_filter = SeerSubgraphHandler._create_case_variations_condition(
                 UP_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_contains", "or"
             )
-            no_stms = SeerSubgraphHandler._create_case_variations_condition(
+            down_filter = SeerSubgraphHandler._create_case_variations_condition(
                 DOWN_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_contains", "or"
             )
-        elif include_conditional_markets and not include_categorical_markets:
-            # We are interested in binary markets only
-            yes_stms = SeerSubgraphHandler._create_case_variations_condition(
+            outcome_filters.extend([up_filter, down_filter])
+
+        elif market_type == MarketType.BINARY:
+            # Template ID "2" + YES/NO outcomes for binary markets
+            and_stms["templateId"] = TemplateId.CATEGORICAL.value
+            yes_filter = SeerSubgraphHandler._create_case_variations_condition(
                 YES_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_contains", "or"
             )
-            no_stms = SeerSubgraphHandler._create_case_variations_condition(
+            no_filter = SeerSubgraphHandler._create_case_variations_condition(
                 NO_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_contains", "or"
             )
+            outcome_filters.extend([yes_filter, no_filter])
 
-        if (
-            not include_only_scalar_markets
-            or include_categorical_markets
-            or include_conditional_markets
-        ):
-            # We should not provide any scalar markets because they are exclusive for categorical markets
-            exclude_scalar_yes = SeerSubgraphHandler._create_case_variations_condition(
-                UP_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_not_contains", "and"
-            )
-            exclude_scalar_no = SeerSubgraphHandler._create_case_variations_condition(
-                DOWN_OUTCOME_LOWERCASE_IDENTIFIER, "outcomes_not_contains", "and"
+        elif market_type == MarketType.CATEGORICAL:
+            # Template ID 2 (categorical) OR Template ID 3 (multi-categorical,
+            # we treat them as categorical for now for simplicity)
+            # https://reality.eth.limo/app/docs/html/contracts.html#templates
+            outcome_filters.append(
+                {
+                    "or": [
+                        {"templateId": TemplateId.CATEGORICAL.value},
+                        {"templateId": TemplateId.MULTICATEGORICAL.value},
+                    ]
+                }
             )
 
-        where_stms: dict[str, t.Any] = {
-            "and": [and_stms, yes_stms, no_stms, exclude_scalar_yes, exclude_scalar_no]
-        }
+        # If none specified, don't add any template/outcome filters (returns all types)
+
+        all_filters = [and_stms] + outcome_filters if and_stms else outcome_filters
+        where_stms: dict[str, t.Any] = {"and": all_filters}
         return where_stms
 
     def _build_sort_params(
@@ -194,20 +211,16 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         sort_by: SortBy = SortBy.NONE,
         limit: int | None = None,
         outcome_supply_gt_if_open: Wei = Wei(0),
-        include_conditional_markets: bool = True,
-        include_categorical_markets: bool = True,
-        include_only_scalar_markets: bool = False,
+        market_type: MarketType = MarketType.ALL,
+        include_conditional_markets: bool = False,
     ) -> list[SeerMarket]:
         sort_direction, sort_by_field = self._build_sort_params(sort_by)
 
-        """Returns markets that contain 2 categories plus an invalid outcome."""
-        # Binary markets on Seer contain 3 outcomes: OutcomeA, outcomeB and an Invalid option.
         where_stms = self._build_where_statements(
             filter_by=filter_by,
             outcome_supply_gt_if_open=outcome_supply_gt_if_open,
             include_conditional_markets=include_conditional_markets,
-            include_categorical_markets=include_categorical_markets,
-            include_only_scalar_markets=include_only_scalar_markets,
+            market_type=market_type,
         )
 
         # These values can not be set to `None`, but they can be omitted.

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -19,6 +19,7 @@ from prediction_market_agent_tooling.markets.seer.seer_contracts import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
+from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 
 
 class SwapPoolHandler:
@@ -79,7 +80,7 @@ class SwapPoolHandler:
         amount_out_minimum = self._calculate_amount_out_minimum(
             amount_wei=amount_wei,
             token_in=token_in,
-            price_outcome_token=price_outcome_token,
+            price_outcome_token=price_outcome_token.priceOfCollateralInAskingToken,
         )
 
         p = ExactInputSingleParams(
@@ -90,6 +91,15 @@ class SwapPoolHandler:
             amount_out_minimum=amount_out_minimum,
         )
 
+        # make sure user has enough tokens to sell
+        balance_collateral_token = ContractERC20OnGnosisChain(
+            address=token_in
+        ).balanceOf(self.api_keys.bet_from_address, web3=web3)
+        if balance_collateral_token < amount_wei:
+            raise ValueError(
+                f"Balance {balance_collateral_token} of {token_in} insufficient for trade, required {amount_wei}"
+            )
+
         tx_receipt = SwaprRouterContract().exact_input_single(
             api_keys=self.api_keys, params=p, web3=web3
         )

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -33,12 +33,7 @@ from cowdao_cowpy.order_book.generated.model import (
 from eth_account import Account
 from eth_account.signers.local import LocalAccount
 from eth_keys.datatypes import PrivateKey as eth_keys_PrivateKey
-from tenacity import (
-    retry_if_not_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-    wait_fixed,
-)
+from tenacity import stop_after_attempt, wait_exponential, wait_fixed
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
@@ -54,7 +49,7 @@ from prediction_market_agent_tooling.markets.omen.cow_contracts import (
     CowGPv2SettlementContract,
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
-from prediction_market_agent_tooling.tools.cow.models import MinimalisticToken, Order
+from prediction_market_agent_tooling.tools.cow.models import MinimalisticTrade, Order
 from prediction_market_agent_tooling.tools.cow.semaphore import postgres_rate_limited
 from prediction_market_agent_tooling.tools.utils import utcnow
 
@@ -108,7 +103,6 @@ def get_sell_token_amount(
 @tenacity.retry(
     stop=stop_after_attempt(4),
     wait=wait_exponential(min=4, max=10),
-    retry=retry_if_not_exception_type(NoLiquidityAvailableOnCowException),
 )
 def get_quote(
     amount_wei: Wei,
@@ -198,7 +192,7 @@ def handle_allowance(
     reraise=True,
     stop=stop_after_attempt(3),
     wait=wait_fixed(1),
-    retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
+    retry=tenacity.retry_if_not_exception_type((TimeoutError)),
     after=lambda x: logger.debug(f"swap_tokens_waiting failed, {x.attempt_number=}."),
 )
 def swap_tokens_waiting(
@@ -211,6 +205,7 @@ def swap_tokens_waiting(
     web3: Web3 | None = None,
     wait_order_complete: bool = True,
     timeout: timedelta = timedelta(seconds=120),
+    slippage_tolerance: float = 0.01,
 ) -> tuple[OrderMetaData | None, CompletedOrder]:
     # CoW library uses async, so we need to wrap the call in asyncio.run for us to use it.
     return asyncio.run(
@@ -224,6 +219,7 @@ def swap_tokens_waiting(
             timeout=timeout,
             web3=web3,
             wait_order_complete=wait_order_complete,
+            slippage_tolerance=slippage_tolerance,
         )
     )
 
@@ -353,14 +349,33 @@ async def sign_safe_cow_swap(
 )
 def get_trades_by_owner(
     owner: ChecksumAddress,
-) -> list[MinimalisticToken]:
+) -> list[MinimalisticTrade]:
     # Using this until cowpy gets fixed (https://github.com/cowdao-grants/cow-py/issues/35)
     response = httpx.get(
         f"https://api.cow.fi/xdai/api/v1/trades",
         params={"owner": owner},
     )
     response.raise_for_status()
-    return [MinimalisticToken.model_validate(i) for i in response.json()]
+    return [MinimalisticTrade.model_validate(i) for i in response.json()]
+
+
+@tenacity.retry(
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(1),
+    after=lambda x: logger.debug(
+        f"get_trades_by_order_uid failed, {x.attempt_number=}."
+    ),
+)
+def get_trades_by_order_uid(
+    order_uid: HexBytes,
+) -> list[MinimalisticTrade]:
+    # Using this until cowpy gets fixed (https://github.com/cowdao-grants/cow-py/issues/35)
+    response = httpx.get(
+        f"https://api.cow.fi/xdai/api/v1/trades",
+        params={"orderUid": order_uid.hex()},
+    )
+    response.raise_for_status()
+    return [MinimalisticTrade.model_validate(i) for i in response.json()]
 
 
 @tenacity.retry(

prediction_market_agent_tooling/tools/cow/models.py

@@ -1,14 +1,16 @@
 from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
-from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.utils import utcnow
 
 
-class MinimalisticToken(BaseModel):
+class MinimalisticTrade(BaseModel):
     sellToken: ChecksumAddress
     buyToken: ChecksumAddress
+    orderUid: HexBytes
+    txHash: HexBytes
 
 
 class Order(BaseModel):

prediction_market_agent_tooling/tools/httpx_cached_client.py

@@ -1,14 +1,21 @@
 import hishel
+import httpx
 
+from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 
-class HttpxCachedClient:
-    def __init__(self) -> None:
+ONE_DAY_IN_SECONDS = 60 * 60 * 24
+
+
+class HttpxCachedClient(metaclass=SingletonMeta):
+    def __init__(self, ttl: int = ONE_DAY_IN_SECONDS) -> None:
         storage = hishel.FileStorage(
-            ttl=24 * 60 * 60,
-            check_ttl_every=1 * 60 * 60,
+            ttl=ttl,
+            check_ttl_every=60,
         )
         controller = hishel.Controller(force_cache=True)
-        self.client = hishel.CacheClient(storage=storage, controller=controller)
+        self.client: httpx.Client = hishel.CacheClient(
+            storage=storage, controller=controller
+        )
 
-    def get_client(self) -> hishel.CacheClient:
+    def get_client(self) -> httpx.Client:
         return self.client

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -14,6 +14,9 @@ from prediction_market_agent_tooling.tools.cow.cow_order import (
     swap_tokens_waiting,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
+from prediction_market_agent_tooling.tools.tokens.slippage import (
+    get_slippage_tolerance_per_token,
+)
 from prediction_market_agent_tooling.tools.tokens.usd import get_usd_in_token
 from prediction_market_agent_tooling.tools.utils import should_not_happen
 
@@ -156,10 +159,14 @@ def auto_deposit_erc20(
             raise ValueError(
                 "Not enough of the source token to sell to get the desired amount of the collateral token."
             )
+    slippage_tolerance = get_slippage_tolerance_per_token(
+        KEEPING_ERC20_TOKEN.address, collateral_token_contract.address
+    )
     swap_tokens_waiting(
         amount_wei=amount_to_sell_wei,
         sell_token=KEEPING_ERC20_TOKEN.address,
         buy_token=collateral_token_contract.address,
         api_keys=api_keys,
         web3=web3,
+        slippage_tolerance=slippage_tolerance,
     )

prediction_market_agent_tooling/tools/tokens/auto_withdraw.py

@@ -9,6 +9,9 @@ from prediction_market_agent_tooling.tools.contract import (
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
+from prediction_market_agent_tooling.tools.tokens.slippage import (
+    get_slippage_tolerance_per_token,
+)
 from prediction_market_agent_tooling.tools.utils import should_not_happen
 
 
@@ -49,12 +52,17 @@ def auto_withdraw_collateral_token(
             f"Swapping {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         # Otherwise, DEX will handle the rest of token swaps.
+        slippage_tolerance = get_slippage_tolerance_per_token(
+            collateral_token_contract.address,
+            KEEPING_ERC20_TOKEN.address,
+        )
         swap_tokens_waiting(
             amount_wei=amount_wei,
             sell_token=collateral_token_contract.address,
             buy_token=KEEPING_ERC20_TOKEN.address,
             api_keys=api_keys,
             web3=web3,
+            slippage_tolerance=slippage_tolerance,
         )
     else:
         should_not_happen("Unsupported ERC20 contract type.")