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

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -1,22 +1,35 @@
 import typing as t
 
-from prediction_market_agent_tooling.gtypes import USD, CollateralToken, OutcomeStr
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    CollateralToken,
+    HexBytes,
+    OutcomeStr,
+    Probability,
+)
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
+    MarketType,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.polymarket.api import (
-    get_polymarket_binary_markets,
+    PolymarketOrderByEnum,
+    get_polymarkets_with_pagination,
 )
 from prediction_market_agent_tooling.markets.polymarket.data_models import (
-    PolymarketMarketWithPrices,
+    PolymarketGammaResponseDataItem,
 )
 from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
     POLYMARKET_BASE_URL,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC
+from prediction_market_agent_tooling.markets.polymarket.polymarket_subgraph_handler import (
+    ConditionSubgraphModel,
+    PolymarketSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
 class PolymarketAgentMarket(AgentMarket):
@@ -33,19 +46,68 @@ class PolymarketAgentMarket(AgentMarket):
     fees: MarketFees = MarketFees.get_zero_fees()
 
     @staticmethod
-    def from_data_model(model: PolymarketMarketWithPrices) -> "PolymarketAgentMarket":
+    def build_resolution_from_condition(
+        condition_id: HexBytes,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+        outcomes: list[OutcomeStr],
+    ) -> Resolution | None:
+        condition_model = condition_model_dict.get(condition_id)
+        if (
+            not condition_model
+            or condition_model.resolutionTimestamp is None
+            or not condition_model.payoutNumerators
+            or not condition_model.payoutDenominator
+        ):
+            return None
+
+        # Currently we only support binary markets, hence we throw an error if we get something else.
+        payout_numerator_indices_gt_0 = [
+            idx
+            for idx, value in enumerate(condition_model.payoutNumerators)
+            if value > 0
+        ]
+        # For a binary market, there should be exactly one payout numerator greater than 0.
+        if len(payout_numerator_indices_gt_0) != 1:
+            raise ValueError(
+                f"Only binary markets are supported. Got payout numerators: {condition_model.payoutNumerators}"
+            )
+
+        # we return the only payout numerator greater than 0 as resolution
+        resolved_outcome = outcomes[payout_numerator_indices_gt_0[0]]
+        return Resolution.from_answer(resolved_outcome)
+
+    @staticmethod
+    def from_data_model(
+        model: PolymarketGammaResponseDataItem,
+        condition_model_dict: dict[HexBytes, ConditionSubgraphModel],
+    ) -> "PolymarketAgentMarket":
+        # If len(model.markets) > 0, this denotes a categorical market.
+
+        outcomes = model.markets[0].outcomes_list
+        outcome_prices = model.markets[0].outcome_prices
+        if not outcome_prices:
+            # We give random prices
+            outcome_prices = [0.5, 0.5]
+        probabilities = {o: Probability(op) for o, op in zip(outcomes, outcome_prices)}
+
+        resolution = PolymarketAgentMarket.build_resolution_from_condition(
+            condition_id=model.markets[0].conditionId,
+            condition_model_dict=condition_model_dict,
+            outcomes=outcomes,
+        )
+
         return PolymarketAgentMarket(
             id=model.id,
-            question=model.question,
+            question=model.title,
             description=model.description,
-            outcomes=[x.outcome for x in model.tokens],
-            resolution=model.resolution,
-            created_time=None,
-            close_time=model.end_date_iso,
+            outcomes=outcomes,
+            resolution=resolution,
+            created_time=model.startDate,
+            close_time=model.endDate,
             url=model.url,
-            volume=None,
+            volume=CollateralToken(model.volume) if model.volume else None,
             outcome_token_pool=None,
-            probabilities={},  # ToDo - Implement when fixing Polymarket
+            probabilities=probabilities,
         )
 
     def get_tiny_bet_amount(self) -> CollateralToken:
@@ -61,16 +123,11 @@ class PolymarketAgentMarket(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["PolymarketAgentMarket"]:
-        if sort_by != SortBy.NONE:
-            raise ValueError(f"Unsuported sort_by {sort_by} for Polymarket.")
-
-        if created_after is not None:
-            raise ValueError(f"Unsuported created_after for Polymarket.")
-
         closed: bool | None
+
         if filter_by == FilterBy.OPEN:
             closed = False
         elif filter_by == FilterBy.RESOLVED:
@@ -80,11 +137,37 @@ class PolymarketAgentMarket(AgentMarket):
         else:
             raise ValueError(f"Unknown filter_by: {filter_by}")
 
+        ascending: bool = False  # default value
+        match sort_by:
+            case SortBy.NEWEST:
+                order_by = PolymarketOrderByEnum.START_DATE
+            case SortBy.CLOSING_SOONEST:
+                ascending = True
+                order_by = PolymarketOrderByEnum.END_DATE
+            case SortBy.HIGHEST_LIQUIDITY:
+                order_by = PolymarketOrderByEnum.LIQUIDITY
+            case SortBy.NONE:
+                order_by = PolymarketOrderByEnum.VOLUME_24HR
+            case _:
+                raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        # closed markets also have property active=True, hence ignoring active.
+        markets = get_polymarkets_with_pagination(
+            limit=limit,
+            closed=closed,
+            order_by=order_by,
+            ascending=ascending,
+            created_after=created_after,
+            excluded_questions=excluded_questions,
+            only_binary=market_type is not MarketType.CATEGORICAL,
+        )
+
+        condition_models = PolymarketSubgraphHandler().get_conditions(
+            condition_ids=[market.markets[0].conditionId for market in markets]
+        )
+        condition_models_dict = {c.id: c for c in condition_models}
+
         return [
-            PolymarketAgentMarket.from_data_model(m)
-            for m in get_polymarket_binary_markets(
-                limit=limit,
-                closed=closed,
-                excluded_questions=excluded_questions,
-            )
+            PolymarketAgentMarket.from_data_model(m, condition_models_dict)
+            for m in markets
         ]

prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.py

@@ -0,0 +1,49 @@
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.gtypes import HexBytes
+from prediction_market_agent_tooling.markets.base_subgraph_handler import (
+    BaseSubgraphHandler,
+)
+
+
+class ConditionSubgraphModel(BaseModel):
+    id: HexBytes
+    payoutDenominator: int | None = None
+    payoutNumerators: list[int] | None = None
+    outcomeSlotCount: int
+    resolutionTimestamp: int | None = None
+
+
+class PolymarketSubgraphHandler(BaseSubgraphHandler):
+    POLYMARKET_CONDITIONS_SUBGRAPH = "https://gateway.thegraph.com/api/{graph_api_key}/subgraphs/id/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Load the subgraph
+        self.conditions_subgraph = self.sg.load_subgraph(
+            self.POLYMARKET_CONDITIONS_SUBGRAPH.format(
+                graph_api_key=self.keys.graph_api_key.get_secret_value()
+            )
+        )
+
+    def get_conditions(
+        self, condition_ids: list[HexBytes]
+    ) -> list[ConditionSubgraphModel]:
+        where_stms = {"id_in": [i.hex() for i in condition_ids]}
+        conditions = self.conditions_subgraph.Query.conditions(
+            where=where_stms,
+        )
+
+        condition_fields = [
+            conditions.id,
+            conditions.payoutNumerators,
+            conditions.payoutDenominator,
+            conditions.outcomeSlotCount,
+            conditions.resolutionTimestamp,
+        ]
+
+        conditions_models = self.do_query(
+            fields=condition_fields, pydantic_model=ConditionSubgraphModel
+        )
+        return conditions_models

prediction_market_agent_tooling/markets/polymarket/utils.py

@@ -1,28 +1,7 @@
-from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.markets.markets import MarketType
-from prediction_market_agent_tooling.markets.polymarket.data_models_web import (
-    PolymarketFullMarket,
-)
 from prediction_market_agent_tooling.tools.google_utils import search_google_gcp
 
 
-def find_resolution_on_polymarket(question: str) -> Resolution | None:
-    full_market = find_full_polymarket(question)
-    # TODO: Only main markets are supported right now, add logic for others if needed.
-    return (
-        full_market.main_market.resolution
-        if full_market and full_market.is_main_market
-        else None
-    )
-
-
-def find_full_polymarket(question: str) -> PolymarketFullMarket | None:
-    polymarket_url = find_url_to_polymarket(question)
-    return (
-        PolymarketFullMarket.fetch_from_url(polymarket_url) if polymarket_url else None
-    )
-
-
 def find_url_to_polymarket(question: str) -> str | None:
     # Manually create potential Polymarket's slug from the question.
     replace_chars = {

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,
@@ -76,6 +78,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 +100,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
@@ -231,9 +237,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 +268,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 +404,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,
         )
 
@@ -501,7 +496,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 +529,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,6 +539,7 @@ 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(

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:
@@ -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

@@ -211,6 +211,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 +225,7 @@ def swap_tokens_waiting(
             timeout=timeout,
             web3=web3,
             wait_order_complete=wait_order_complete,
+            slippage_tolerance=slippage_tolerance,
         )
     )
 

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.")

prediction_market_agent_tooling/tools/tokens/slippage.py

@@ -0,0 +1,21 @@
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    METRI_SUPER_GROUP_CONTRACT_ADDRESS,
+)
+
+DEFAULT_SLIPPAGE_TOLERANCE = 0.05
+
+SLIPPAGE_TOLERANCE_PER_TOKEN = {
+    METRI_SUPER_GROUP_CONTRACT_ADDRESS: 0.1,
+}
+
+
+def get_slippage_tolerance_per_token(
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    default_slippage: float = DEFAULT_SLIPPAGE_TOLERANCE,
+) -> float:
+    return max(
+        SLIPPAGE_TOLERANCE_PER_TOKEN.get(sell_token, default_slippage),
+        SLIPPAGE_TOLERANCE_PER_TOKEN.get(buy_token, default_slippage),
+    )