prediction-market-agent-tooling 0.62.0.dev493__py3-none-any.whl → 0.63.0.dev498__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -65,7 +65,11 @@ from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, ob
 from prediction_market_agent_tooling.tools.tokens.main_token import (
     MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES,
 )
-from prediction_market_agent_tooling.tools.utils import DatetimeUTC, utcnow
+from prediction_market_agent_tooling.tools.utils import (
+    DatetimeUTC,
+    check_not_none,
+    utcnow,
+)
 
 MAX_AVAILABLE_MARKETS = 1000
 
@@ -615,9 +619,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
             return None
 
         api_keys = APIKeys()
-        existing_position = market.get_position(
-            user_id=market.get_user_id(api_keys=api_keys)
-        )
+        user_id = market.get_user_id(api_keys=api_keys)
+
+        existing_position = market.get_position(user_id=user_id)
         trades = self.build_trades(
             market=market,
             answer=processed_market.answer,
@@ -643,8 +647,20 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                             outcome=trade.outcome, amount=trade.amount
                         )
                     case TradeType.SELL:
+                        # Get actual value of the position we are going to sell, and if it's less than we wanted to sell, simply sell all of it.
+                        current_position_value = check_not_none(
+                            market.get_position(user_id),
+                            "Should exists if we are going to sell outcomes.",
+                        ).amounts_current[
+                            market.get_outcome_str_from_bool(trade.outcome)
+                        ]
+                        if current_position_value < trade.amount:
+                            logger.warning(
+                                f"Current value of position {trade.outcome=}, {current_position_value=} is less than the desired selling amount {trade.amount=}. Selling all."
+                            )
                         id = market.sell_tokens(
-                            outcome=trade.outcome, amount=trade.amount
+                            outcome=trade.outcome,
+                            amount=min(trade.amount, current_position_value),
                         )
                     case _:
                         raise ValueError(f"Unexpected trade type {trade.trade_type}.")

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -47,7 +47,8 @@ class BettingStrategy(ABC):
     @staticmethod
     def assert_buy_trade_wont_be_guaranteed_loss(
         market: AgentMarket, trades: list[Trade]
-    ) -> None:
+    ) -> list[Trade]:
+        clean_trades = []
         for trade in trades:
             if trade.trade_type == TradeType.BUY:
                 outcome_tokens_to_get = market.get_buy_token_amount(
@@ -56,14 +57,28 @@ class BettingStrategy(ABC):
                 outcome_tokens_to_get_in_usd = market.get_token_in_usd(
                     outcome_tokens_to_get.as_token
                 )
+
+                if not outcome_tokens_to_get:
+                    logger.info(
+                        f"Could not determine buy_token_amount for trade {trade}. Skipping trade."
+                    )
+                    continue
+
                 if outcome_tokens_to_get_in_usd <= trade.amount:
                     raise GuaranteedLossError(
-                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}."
+                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
                     )
 
+            clean_trades.append(trade)
+
+        return clean_trades
+
     @staticmethod
-    def check_trades(market: AgentMarket, trades: list[Trade]) -> None:
-        BettingStrategy.assert_buy_trade_wont_be_guaranteed_loss(market, trades)
+    def filter_trades(market: AgentMarket, trades: list[Trade]) -> list[Trade]:
+        trades = BettingStrategy.assert_buy_trade_wont_be_guaranteed_loss(
+            market, trades
+        )
+        return trades
 
     def _build_rebalance_trades_from_positions(
         self,
@@ -109,7 +124,7 @@ class BettingStrategy(ABC):
         trades.sort(key=lambda t: t.trade_type == TradeType.SELL)
 
         # Run some sanity checks to not place unreasonable bets.
-        BettingStrategy.check_trades(market, trades)
+        trades = BettingStrategy.filter_trades(market, trades)
 
         return trades
 

prediction_market_agent_tooling/markets/agent_market.py

@@ -4,6 +4,7 @@ from enum import Enum
 from eth_typing import ChecksumAddress
 from pydantic import BaseModel, field_validator, model_validator
 from pydantic_core.core_schema import FieldValidationInfo
+from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
@@ -235,7 +236,7 @@ class AgentMarket(BaseModel):
 
     def get_buy_token_amount(
         self, bet_amount: USD | CollateralToken, direction: bool
-    ) -> OutcomeToken:
+    ) -> OutcomeToken | None:
         raise NotImplementedError("Subclasses must implement this method")
 
     def sell_tokens(self, outcome: bool, amount: USD | OutcomeToken) -> str:
@@ -293,6 +294,7 @@ class AgentMarket(BaseModel):
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
         """
         If market allows to upload trades somewhere, implement it in this method.

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -22,10 +22,11 @@ def store_trades(
     traded_market: ProcessedTradedMarket | None,
     keys: APIKeys,
     agent_name: str,
+    web3: Web3 | None = None,
 ) -> None:
     if traded_market is None:
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
-        return
+        return None
 
     reasoning = traded_market.answer.reasoning if traded_market.answer.reasoning else ""
 
@@ -37,8 +38,10 @@ def store_trades(
         )
         ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
+    # tx_hashes must be list of bytes32 (see Solidity contract).
+    # For regular tx hashes that's fine, but for other types of IDs we take the first 32 bytes (orderDigest).
     tx_hashes = [
-        HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
+        HexBytes(HexStr(i.id[:32])) for i in traded_market.trades if i.id is not None
     ]
     prediction = ContractPrediction(
         publisher=keys.bet_from_address,
@@ -50,6 +53,7 @@ def store_trades(
         api_keys=keys,
         market_address=Web3.to_checksum_address(market_id),
         prediction=prediction,
+        web3=web3,
     )
     logger.info(
         f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."

prediction_market_agent_tooling/markets/omen/omen.py

@@ -424,6 +424,7 @@ class OmenAgentMarket(AgentMarket):
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
         return store_trades(
             market_id=self.id,

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -5,9 +5,9 @@ from urllib.parse import urljoin
 
 from pydantic import BaseModel, ConfigDict, Field
 from web3 import Web3
-from web3.constants import ADDRESS_ZERO
 
 from prediction_market_agent_tooling.config import RPCConfig
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexAddress, HexBytes
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
@@ -19,7 +19,9 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import Resolution
-from prediction_market_agent_tooling.tools.cow.cow_manager import CowManager
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    SeerParentMarket,
+)
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 
 
@@ -84,10 +86,6 @@ class SeerOutcomeEnum(str, Enum):
             raise ValueError(f"Unknown outcome: {self}")
 
 
-class SeerParentMarket(BaseModel):
-    id: HexBytes
-
-
 SEER_BASE_URL = "https://app.seer.pm"
 
 
@@ -110,6 +108,7 @@ class SeerMarket(BaseModel):
     has_answers: bool | None = Field(alias="hasAnswers")
     payout_reported: bool = Field(alias="payoutReported")
     payout_numerators: list[int] = Field(alias="payoutNumerators")
+    outcomes_supply: int = Field(alias="outcomesSupply")
 
     @property
     def has_valid_answer(self) -> bool:
@@ -186,64 +185,7 @@ class SeerMarket(BaseModel):
     def created_time(self) -> DatetimeUTC:
         return DatetimeUTC.to_datetime_utc(self.block_timestamp)
 
-    @property
-    def current_p_yes(self) -> Probability:
-        price_data = {}
-        for idx in range(len(self.outcomes)):
-            wrapped_token = self.wrapped_tokens[idx]
-            price = self._get_price_for_token(
-                token=Web3.to_checksum_address(wrapped_token)
-            )
-            price_data[idx] = price
-
-        if sum(price_data.values()) == 0:
-            logger.warning(
-                f"Could not get p_yes for market {self.id.hex()}, all price quotes are 0."
-            )
-            return Probability(0)
-
-        yes_idx = self.outcome_as_enums[SeerOutcomeEnum.YES]
-        price_yes = price_data[yes_idx] / sum(price_data.values())
-        return Probability(price_yes)
-
-    def _get_price_for_token(self, token: ChecksumAddress) -> float:
-        collateral_exchange_amount = CollateralToken(1).as_wei
-        try:
-            quote = CowManager().get_quote(
-                collateral_token=self.collateral_token_contract_address_checksummed,
-                buy_token=token,
-                sell_amount=collateral_exchange_amount,
-            )
-        except Exception as e:
-            logger.warning(f"Could not get quote for {token=}, returning price 0. {e=}")
-            return 0
-
-        return collateral_exchange_amount.value / float(quote.quote.buyAmount.root)
-
     @property
     def url(self) -> str:
         chain_id = RPCConfig().chain_id
         return urljoin(SEER_BASE_URL, f"markets/{chain_id}/{self.id.hex()}")
-
-
-class SeerToken(BaseModel):
-    id: HexBytes
-    name: str
-    symbol: str
-
-
-class SeerPool(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    id: HexBytes
-    liquidity: int
-    token0: SeerToken
-    token1: SeerToken
-
-
-class NewMarketEvent(BaseModel):
-    market: HexAddress
-    marketName: str
-    parentMarket: HexAddress
-    conditionId: HexBytes
-    questionId: HexBytes
-    questionsIds: list[HexBytes]

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -0,0 +1,119 @@
+from functools import lru_cache
+
+from web3 import Web3
+
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    Probability,
+    xdai_type,
+    Wei,
+)
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    SeerMarket,
+    SeerOutcomeEnum,
+)
+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_quote
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
+
+
+class PriceManager:
+    def __init__(self, seer_market: SeerMarket, seer_subgraph: SeerSubgraphHandler):
+        self.seer_market = seer_market
+        self.seer_subgraph = seer_subgraph
+
+    @staticmethod
+    def build(market_id: HexBytes) -> "PriceManager":
+        s = SeerSubgraphHandler()
+        market = s.get_market_by_id(market_id=market_id)
+        return PriceManager(seer_market=market, seer_subgraph=s)
+
+    def _log_track_price_normalization_diff(
+        self, old_price: float, normalized_price: float, max_price_diff: float = 0.05
+    ) -> None:
+        price_diff_pct = abs(old_price - normalized_price) / old_price
+        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()} "
+            )
+
+    def current_p_yes(self) -> Probability | None:
+        # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
+        price_data = {}
+        for idx, wrapped_token in enumerate(self.seer_market.wrapped_tokens):
+            price = self.get_price_for_token(
+                token=Web3.to_checksum_address(wrapped_token),
+            )
+
+            price_data[idx] = price
+
+        price_yes = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.YES]]
+        price_no = price_data[self.seer_market.outcome_as_enums[SeerOutcomeEnum.NO]]
+
+        # We only return a probability if we have both price_yes and price_no, since we could place bets
+        # in both sides hence we need current probabilities for both outcomes.
+        if price_yes and price_no:
+            # If other outcome`s price is None, we set it to 0.
+            total_price = sum(
+                price if price is not None else 0.0 for price in price_data.values()
+            )
+            normalized_price_yes = price_yes / total_price
+            self._log_track_price_normalization_diff(
+                old_price=price_yes, normalized_price=normalized_price_yes
+            )
+            return Probability(normalized_price_yes)
+        else:
+            return None
+
+    @lru_cache(typed=True)
+    def get_price_for_token(
+        self,
+        token: ChecksumAddress,
+        collateral_exchange_amount: Wei = xdai_to_wei(xdai_type(1)),
+    ) -> float | None:
+        try:
+            quote = get_quote(
+                amount_wei=collateral_exchange_amount,
+                sell_token=self.seer_market.collateral_token_contract_address_checksummed,
+                buy_token=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)
+
+        return collateral_exchange_amount / float(quote.quote.buyAmount.root)
+
+    @staticmethod
+    def _pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
+        return pool.token0.id.hex().lower() == token.lower()
+
+    def get_token_price_from_pools(
+        self,
+        token: ChecksumAddress,
+    ) -> float | None:
+        pool = SeerSubgraphHandler().get_pool_by_token(
+            token_address=token,
+            collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
+        )
+
+        if not pool:
+            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_in_collateral_units = (
+            pool.token1Price
+            if self._pool_token0_matches_token(token=token, pool=pool)
+            else pool.token0Price
+        )
+        return price_in_collateral_units

prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,5 +1,7 @@
 import typing as t
 
+import tenacity
+from eth_pydantic_types import HexStr
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
@@ -11,6 +13,7 @@ from prediction_market_agent_tooling.gtypes import (
     HexAddress,
     HexBytes,
     OutcomeStr,
+    Wei,
     OutcomeToken,
     OutcomeWei,
     xDai,
@@ -20,33 +23,33 @@ from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     ProcessedMarket,
-    ProcessedTradedMarket,
     SortBy,
+    ProcessedTradedMarket,
 )
-from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
 from prediction_market_agent_tooling.markets.data_models import ExistingPosition
 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.seer.data_models import (
-    NewMarketEvent,
     SeerMarket,
     SeerOutcomeEnum,
 )
+from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     SeerMarketFactory,
 )
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
+    NewMarketEvent,
+)
+from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
-from prediction_market_agent_tooling.tools.cow.cow_manager import (
-    CowManager,
-    NoLiquidityAvailableOnCowException,
-)
+from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
@@ -87,19 +90,16 @@ class SeerAgentMarket(AgentMarket):
         agent_name: str,
     ) -> None:
         """On Seer, we have to store predictions along with trades, see `store_trades`."""
+        pass
 
     def store_trades(
         self,
         traded_market: ProcessedTradedMarket | None,
         keys: APIKeys,
         agent_name: str,
+        web3: Web3 | None = None,
     ) -> None:
-        return store_trades(
-            market_id=self.id,
-            traded_market=traded_market,
-            keys=keys,
-            agent_name=agent_name,
-        )
+        pass
 
     def get_token_in_usd(self, x: CollateralToken) -> USD:
         return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)
@@ -108,20 +108,24 @@ class SeerAgentMarket(AgentMarket):
         return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
 
     def get_buy_token_amount(
-        self, bet_amount: USD | CollateralToken, direction: bool
-    ) -> OutcomeToken:
+        self, bet_amount: BetAmount, direction: bool
+    ) -> OutcomeToken | None:
         """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
 
         outcome_token = self.get_wrapped_token_for_outcome(direction)
         bet_amount_in_tokens = self.get_in_token(bet_amount)
         bet_amount_in_wei = bet_amount_in_tokens.as_wei
 
-        quote = CowManager().get_quote(
-            buy_token=outcome_token,
-            sell_amount=bet_amount_in_wei,
-            collateral_token=self.collateral_token_contract_address_checksummed,
+        p = PriceManager.build(market_id=HexBytes(HexStr(self.id)))
+        price_in_collateral_units = p.get_price_for_token(
+            token=outcome_token, collateral_exchange_amount=bet_amount_in_wei
         )
-        sell_amount = OutcomeWei(quote.quote.buyAmount.root).as_outcome_token
+        if not price_in_collateral_units:
+            logger.info(f"Could not get price for token {outcome_token}")
+            return None
+
+        buy_amount = bet_amount_in_wei / price_in_collateral_units
+        sell_amount = OutcomeWei(buy_amount).as_outcome_token
         return sell_amount
 
     def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
@@ -185,7 +189,17 @@ class SeerAgentMarket(AgentMarket):
         return OmenAgentMarket.verify_operational_balance(api_keys=api_keys)
 
     @staticmethod
-    def from_data_model(model: SeerMarket) -> "SeerAgentMarket":
+    def from_data_model_with_subgraph(
+        model: SeerMarket, seer_subgraph: SeerSubgraphHandler
+    ) -> "SeerAgentMarket" | None:
+        p = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
+        current_p_yes = p.current_p_yes()
+        if not current_p_yes:
+            logger.info(
+                f"p_yes for market {model.id.hex()} could not be calculated. Skipping."
+            )
+            return None
+
         return SeerAgentMarket(
             id=model.id.hex(),
             question=model.title,
@@ -201,7 +215,7 @@ class SeerAgentMarket(AgentMarket):
             outcome_token_pool=None,
             resolution=model.get_resolution_enum(),
             volume=None,
-            current_p_yes=model.current_p_yes,
+            current_p_yes=current_p_yes,
             seer_outcomes=model.outcome_as_enums,
         )
 
@@ -213,31 +227,31 @@ class SeerAgentMarket(AgentMarket):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
     ) -> t.Sequence["SeerAgentMarket"]:
+        seer_subgraph = SeerSubgraphHandler()
+        markets = seer_subgraph.get_binary_markets(
+            limit=limit, sort_by=sort_by, filter_by=filter_by
+        )
+
+        # We exclude the None values below because `from_data_model_with_subgraph` can return None, which
+        # represents an invalid market.
         return [
-            SeerAgentMarket.from_data_model(m)
-            for m in SeerSubgraphHandler().get_binary_markets(
-                limit=limit,
-                sort_by=sort_by,
-                filter_by=filter_by,
+            market
+            for m in markets
+            if (
+                market := SeerAgentMarket.from_data_model_with_subgraph(
+                    model=m, seer_subgraph=seer_subgraph
+                )
             )
+            is not None
         ]
 
     def has_liquidity_for_outcome(self, outcome: bool) -> bool:
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        try:
-            CowManager().get_quote(
-                collateral_token=self.collateral_token_contract_address_checksummed,
-                buy_token=outcome_token,
-                sell_amount=CollateralToken(
-                    1
-                ).as_wei,  # we take 1 as a baseline value for common trades the agents take.
-            )
-            return True
-        except NoLiquidityAvailableOnCowException:
-            logger.info(
-                f"Could not get a quote for {outcome_token=} {outcome=}, returning no liquidity"
-            )
-            return False
+        pool = SeerSubgraphHandler().get_pool_by_token(
+            token_address=outcome_token,
+            collateral_address=self.collateral_token_contract_address_checksummed,
+        )
+        return pool is not None and pool.liquidity > 0
 
     def has_liquidity(self) -> bool:
         # We conservatively define a market as having liquidity if it has liquidity for the `True` outcome token AND the `False` outcome token.
@@ -281,14 +295,57 @@ class SeerAgentMarket(AgentMarket):
             )
 
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        # Sell using token address
-        order_metadata = CowManager().swap(
-            amount=amount_in_token,
+        amount_to_trade = xdai_type(amount.amount)
+
+        #  Sell sDAI using token address
+        order_metadata = swap_tokens_waiting(
+            amount_wei=xdai_to_wei(amount_to_trade),
             sell_token=collateral_contract.address,
             buy_token=outcome_token,
             api_keys=api_keys,
             web3=web3,
         )
+        logger.debug(
+            f"Purchased {outcome_token} in exchange for {collateral_contract.address}. Order details {order_metadata}"
+        )
+
+        return order_metadata.uid.root
+
+    @tenacity.retry(
+        stop=tenacity.stop_after_attempt(3),
+        wait=tenacity.wait_fixed(1),
+        after=lambda x: logger.debug(
+            f"seer_sell_outcome_tx failed, {x.attempt_number=}."
+        ),
+    )
+    def sell_tokens(
+        self,
+        outcome: bool,
+        amount: TokenAmount,
+        auto_withdraw: bool = True,
+        api_keys: APIKeys | None = None,
+        web3: Web3 | None = None,
+    ) -> str:
+        """
+        Sells the given number of shares for the given outcome in the given market.
+        """
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
+        api_keys = api_keys if api_keys is not None else APIKeys()
+        amount_to_trade = xdai_type(amount.amount)
+
+        order_metadata = swap_tokens_waiting(
+            amount_wei=xdai_to_wei(amount_to_trade),
+            sell_token=outcome_token,
+            buy_token=Web3.to_checksum_address(
+                self.collateral_token_contract_address_checksummed
+            ),
+            api_keys=api_keys,
+            web3=web3,
+        )
+
+        logger.debug(
+            f"Sold {outcome_token} in exchange for {self.collateral_token_contract_address_checksummed}. Order details {order_metadata}"
+        )
 
         return order_metadata.uid.root
 

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -11,7 +11,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     xDai,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import (
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
 )
 from prediction_market_agent_tooling.tools.contract import (

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -5,14 +5,14 @@ from typing import Any
 from subgrounds import FieldPath
 from web3.constants import ADDRESS_ZERO
 
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+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.base_subgraph_handler import (
     BaseSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import (
-    SeerMarket,
-    SeerPool,
-)
+from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
+from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
 from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
@@ -50,6 +50,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.creator,
             markets_field.conditionId,
             markets_field.marketName,
+            markets_field.outcomesSupply,
             markets_field.parentOutcome,
             markets_field.outcomes,
             markets_field.payoutReported,
@@ -121,12 +122,16 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         match sort_by:
             case SortBy.NEWEST:
                 sort_direction = "desc"
-                sort_by_field = self.seer_subgraph.Market.block_timestamp
+                sort_by_field = self.seer_subgraph.Market.blockTimestamp
             case SortBy.CLOSING_SOONEST:
                 sort_direction = "asc"
-                sort_by_field = self.seer_subgraph.Market.opening_ts
-            # ToDo - Implement liquidity conditions by looking up Swapr subgraph.
-            case SortBy.NONE | SortBy.HIGHEST_LIQUIDITY | SortBy.LOWEST_LIQUIDITY:
+                sort_by_field = self.seer_subgraph.Market.openingTs
+            case SortBy.HIGHEST_LIQUIDITY | SortBy.LOWEST_LIQUIDITY:
+                sort_direction = (
+                    "desc" if sort_by == SortBy.HIGHEST_LIQUIDITY else "asc"
+                )
+                sort_by_field = self.seer_subgraph.Market.outcomesSupply
+            case SortBy.NONE:
                 sort_direction = None
                 sort_by_field = None
             case _:
@@ -201,6 +206,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         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,
@@ -210,19 +218,40 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         ]
         return fields
 
-    def get_swapr_pools_for_market(self, market: SeerMarket) -> list[SeerPool]:
+    def get_pool_by_token(
+        self, token_address: ChecksumAddress, collateral_address: ChecksumAddress
+    ) -> SeerPool | None:
         # We iterate through the wrapped tokens and put them in a where clause so that we hit the subgraph endpoint just once.
         wheres = []
-        for wrapped_token in market.wrapped_tokens:
-            wheres.extend(
-                [
-                    {"token0": wrapped_token.lower()},
-                    {"token1": wrapped_token.lower()},
-                ]
-            )
+        wheres.extend(
+            [
+                {
+                    "token0": token_address.lower(),
+                    "token1": collateral_address.lower(),
+                },
+                {
+                    "token0": collateral_address.lower(),
+                    "token1": token_address.lower(),
+                },
+            ]
+        )
+
+        optional_params = {}
+        optional_params["orderBy"] = self.swapr_algebra_subgraph.Pool.liquidity
+        optional_params["orderDirection"] = "desc"
+
         pools_field = self.swapr_algebra_subgraph.Query.pools(
-            where=unwrap_generic_value({"or": wheres})
+            where=unwrap_generic_value({"or": wheres}, **optional_params
+        )
         )
         fields = self._get_fields_for_pools(pools_field)
         pools = self.do_query(fields=fields, pydantic_model=SeerPool)
-        return pools
+        # We assume there is only one pool for outcomeToken/sDAI.
+        if len(pools) > 1:
+            logger.info(
+                f"Multiple pools found for token {token_address}, selecting the first."
+            )
+        if pools:
+            # We select the first one
+            return pools[0]
+        return None

prediction_market_agent_tooling/markets/seer/subgraph_data_models.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel, ConfigDict, Field
+from web3.constants import ADDRESS_ZERO
+
+from prediction_market_agent_tooling.gtypes import HexAddress, HexBytes, Wei
+
+
+class SeerToken(BaseModel):
+    id: HexBytes
+    name: str
+    symbol: str
+
+
+class SeerPool(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    id: HexBytes
+    liquidity: int
+    token0: SeerToken
+    token1: SeerToken
+    token0Price: float
+    token1Price: float
+    sqrtPrice: int
+
+
+class NewMarketEvent(BaseModel):
+    market: HexAddress
+    marketName: str
+    parentMarket: HexAddress
+    conditionId: HexBytes
+    questionId: HexBytes
+    questionsIds: list[HexBytes]
+
+
+class CreateCategoricalMarketsParams(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    market_name: str = Field(..., alias="marketName")
+    outcomes: list[str]
+    # Only relevant for scalar markets
+    question_start: str = Field(alias="questionStart", default="")
+    question_end: str = Field(alias="questionEnd", default="")
+    outcome_type: str = Field(alias="outcomeType", default="")
+
+    # Not needed for non-conditional markets.
+    parent_outcome: int = Field(alias="parentOutcome", default=0)
+    parent_market: HexAddress = Field(alias="parentMarket", default=ADDRESS_ZERO)
+
+    category: str
+    lang: str
+    lower_bound: int = Field(alias="lowerBound", default=0)
+    upper_bound: int = Field(alias="upperBound", default=0)
+    min_bond: Wei = Field(..., alias="minBond")
+    opening_time: int = Field(..., alias="openingTime")
+    token_names: list[str] = Field(..., alias="tokenNames")
+
+
+class SeerParentMarket(BaseModel):
+    id: HexBytes

prediction_market_agent_tooling/tools/contract.py

@@ -207,6 +207,17 @@ class ContractERC20BaseClass(ContractBaseClass):
         value: str = self._cache[cache_key]
         return value
 
+    def allowance(
+        self,
+        owner: ChecksumAddress,
+        for_address: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> int:
+        allowance_for_user: int = self.call(
+            "allowance", function_params=[owner, for_address], web3=web3
+        )
+        return allowance_for_user
+
     def approve(
         self,
         api_keys: APIKeys,

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -4,9 +4,11 @@ from datetime import timedelta
 import httpx
 import tenacity
 from cowdao_cowpy import swap_tokens
+from cowdao_cowpy.common.api.errors import UnexpectedResponseError
 from cowdao_cowpy.common.chains import Chain
 from cowdao_cowpy.common.config import SupportedChainId
 from cowdao_cowpy.common.constants import CowContractAddress
+from cowdao_cowpy.cow.swap import get_order_quote
 from cowdao_cowpy.order_book.api import OrderBookApi
 from cowdao_cowpy.order_book.config import Envs, OrderBookAPIConfigFactory
 from cowdao_cowpy.order_book.generated.model import (
@@ -14,25 +16,24 @@ from cowdao_cowpy.order_book.generated.model import (
     OrderMetaData,
     OrderQuoteRequest,
     OrderQuoteSide1,
-    OrderQuoteSide3,
-    OrderQuoteSideKindBuy,
     OrderQuoteSideKindSell,
     OrderStatus,
     TokenAmount,
+    OrderQuoteResponse,
 )
 from eth_account.signers.local import LocalAccount
-from eth_typing.evm import ChecksumAddress
+from tenacity import stop_after_attempt, wait_fixed, retry_if_not_exception_type
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, wei_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.utils import utcnow
 
 
-class OrderStatusError(Exception):
-    pass
+class NoLiquidityAvailableOnCowException(Exception):
+    """Custom exception for handling case where no liquidity available."""
 
 
 def get_order_book_api(env: Envs, chain: Chain) -> OrderBookApi:
@@ -41,20 +42,17 @@ def get_order_book_api(env: Envs, chain: Chain) -> OrderBookApi:
 
 
 @tenacity.retry(
-    stop=tenacity.stop_after_attempt(3),
-    wait=tenacity.wait_fixed(1),
-    after=lambda x: logger.debug(f"get_sell_token_amount failed, {x.attempt_number=}."),
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(2),
+    retry=retry_if_not_exception_type(NoLiquidityAvailableOnCowException),
 )
-def get_sell_token_amount(
-    buy_amount: Wei,
+def get_quote(
+    amount_wei: Wei,
     sell_token: ChecksumAddress,
     buy_token: ChecksumAddress,
     chain: Chain = Chain.GNOSIS,
     env: Envs = "prod",
-) -> Wei:
-    """
-    Calculate how much of the sell_token is needed to obtain a specified amount of buy_token.
-    """
+) -> OrderQuoteResponse:
     order_book_api = get_order_book_api(env, chain)
     order_quote_request = OrderQuoteRequest(
         sellToken=Address(sell_token),
@@ -63,52 +61,49 @@ def get_sell_token_amount(
             "0x1234567890abcdef1234567890abcdef12345678"
         ),  # Just random address, doesn't matter.
     )
-    order_side = OrderQuoteSide3(
-        kind=OrderQuoteSideKindBuy.buy,
-        buyAmountAfterFee=TokenAmount(str(buy_amount)),
-    )
-    order_quote = asyncio.run(
-        order_book_api.post_quote(order_quote_request, order_side)
+    order_side = OrderQuoteSide1(
+        kind=OrderQuoteSideKindSell.sell,
+        sellAmountBeforeFee=TokenAmount(str(amount_wei)),
     )
-    return Wei(order_quote.quote.sellAmount.root)
 
+    try:
+        order_quote = asyncio.run(
+            get_order_quote(
+                order_quote_request=order_quote_request,
+                order_side=order_side,
+                order_book_api=order_book_api,
+            )
+        )
 
-@tenacity.retry(
-    stop=tenacity.stop_after_attempt(3),
-    wait=tenacity.wait_fixed(1),
-    after=lambda x: logger.debug(f"get_buy_token_amount failed, {x.attempt_number=}."),
-)
-def get_buy_token_amount(
-    sell_amount: Wei,
+        return order_quote
+
+    except UnexpectedResponseError as e1:
+        if "NoLiquidity" in e1.message:
+            raise NoLiquidityAvailableOnCowException(e1.message)
+        logger.warning(f"Found unexpected Cow response error: {e1}")
+        raise
+    except Exception as e:
+        logger.warning(f"Found unhandled Cow response error: {e}")
+        raise
+
+
+def get_buy_token_amount_else_raise(
+    amount_wei: Wei,
     sell_token: ChecksumAddress,
     buy_token: ChecksumAddress,
     chain: Chain = Chain.GNOSIS,
     env: Envs = "prod",
 ) -> Wei:
-    order_book_api = get_order_book_api(env, chain)
-    order_quote_request = OrderQuoteRequest(
-        sellToken=Address(sell_token),
-        buyToken=Address(buy_token),
-        from_=Address(
-            "0x1234567890abcdef1234567890abcdef12345678"
-        ),  # Just random address, doesn't matter.
-    )
-    order_side = OrderQuoteSide1(
-        kind=OrderQuoteSideKindSell.sell,
-        sellAmountBeforeFee=TokenAmount(str(sell_amount)),
-    )
-    order_quote = asyncio.run(
-        order_book_api.post_quote(order_quote_request, order_side)
+    order_quote = get_quote(
+        amount_wei=amount_wei,
+        sell_token=sell_token,
+        buy_token=buy_token,
+        chain=chain,
+        env=env,
     )
-    return Wei(order_quote.quote.buyAmount.root)
+    return wei_type(order_quote.quote.buyAmount.root)
 
 
-@tenacity.retry(
-    stop=tenacity.stop_after_attempt(3),
-    wait=tenacity.wait_fixed(1),
-    retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
-    after=lambda x: logger.debug(f"swap_tokens_waiting failed, {x.attempt_number=}."),
-)
 def swap_tokens_waiting(
     amount_wei: Wei,
     sell_token: ChecksumAddress,
@@ -146,7 +141,7 @@ async def swap_tokens_waiting_async(
     timeout: timedelta = timedelta(seconds=60),
 ) -> OrderMetaData:
     order = await swap_tokens(
-        amount=amount_wei.value,
+        amount=amount_wei,
         sell_token=sell_token,
         buy_token=buy_token,
         account=account,
@@ -169,7 +164,7 @@ async def swap_tokens_waiting_async(
             OrderStatus.cancelled,
             OrderStatus.expired,
         ):
-            raise OrderStatusError(f"Order {order.uid} failed. {order.url}")
+            raise ValueError(f"Order {order.uid} failed. {order.url}")
 
         if utcnow() - start_time > timeout:
             raise TimeoutError(

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -10,6 +10,7 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC4626BaseClass,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
+    get_buy_token_amount_else_raise,
     get_sell_token_amount,
     swap_tokens_waiting,
 )

{prediction_market_agent_tooling-0.62.0.dev493.dist-info → prediction_market_agent_tooling-0.63.0.dev498.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.62.0.dev493
+Version: 0.63.0.dev498
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.62.0.dev493.dist-info → prediction_market_agent_tooling-0.63.0.dev498.dist-info}/RECORD

@@ -21,9 +21,9 @@ prediction_market_agent_tooling/benchmark/agents.py,sha256=B1-uWdyeN4GGKMWGK_-Cc
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=MqTiaaJ3cYiOLUVR7OyImLWxcEya3Rl5JyFYW-K0lwM,17097
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
 prediction_market_agent_tooling/config.py,sha256=So5l8KbgmzcCpxzzf13TNrEJPu_4iQnUDhzus6XRvSc,10151
-prediction_market_agent_tooling/deploy/agent.py,sha256=DW9edzHDX7QVURMGyOoIHTIvl3Itpbi8i0l5XPrEkbk,24974
+prediction_market_agent_tooling/deploy/agent.py,sha256=OyrhPOjByQOAi1_VWhef7ieKqREjVhvjGHgnUIQc3gI,25877
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=iU-D7cdcwiCOWbjDt8hin3ZpL633pQbw9GIKRnIR3FY,12494
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=aqDLLVt0ip6gmPAJZcz59HdMS69HqsvsqDCiIKhKP4E,12917
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=OsPboCFGiZKsvGyntGZHwdqPlLTthITkNF5rJFvGgU8,2582
@@ -34,9 +34,9 @@ prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=8vYafsK1cqMWQtjBoq9rruroF84xAVD00vBTMWH6QMg,2166
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=Pf6QxPXGyie-2l_wZUjaGPTjZTlpv50_JhP40mULBaU,5048
 prediction_market_agent_tooling/loggers.py,sha256=MvCkQSJL2_0yErNatqr81sJlc4aOgPzDp9VNrIhKUcc,4140
-prediction_market_agent_tooling/markets/agent_market.py,sha256=A8eHhV68RIBUE1eIxVchp3QstzpnAYdZxaANyS6vg68,14866
+prediction_market_agent_tooling/markets/agent_market.py,sha256=1NomilM0GCXcRq_1N_cr2AbSK5ONTowFeRbrhc7V5zE,14929
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
-prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=1iTU_D-Uof0E442qVUhSBCfc1rJNQpDcd3UjSnilYZg,2129
+prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=rm-nh-FuIMuH3AuneRNfkwOfHc7Cs7DnPAcHtuTFcuw,2363
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
 prediction_market_agent_tooling/markets/data_models.py,sha256=_R9Hr5zwGLpZLPXq0Jo2wZRNRQyOnSi3WVQJZ81syuk,4541
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,7 +51,7 @@ prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=FaBCTPPe
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=86TIx6cavEWc8Cv4KpZxSvwiSw9oFybXE3YB49pg-CA,4377
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=URvplDcTLeL6vfpkSgi8ln2iEKxt8w5qf6mTZkSyrCo,29189
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=_Vt1_w_A6-FHPVgNclwSh2qpABBXXTJ2wKPtcFfrDTQ,51893
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=Jf2qSJJn0UUISpi24xYRwoVycGuYE42kZ2z1HRGl43w,51927
 prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=D9oflYKafLQiHYtB5sScMHqmXyzM8JP8J0yATmc4SQQ,233
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=bCC9A7ZTJxMDJcPbl3jof6HcAGGHv1BrFq3RRWbkQ_c,28739
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=Cyi9Ci-Z-K8WCZWVLs9oSuJC6qRobi_CpqDCno_5F-0,10238
@@ -61,10 +61,12 @@ prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=utGN-Lh
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=LVEsNw2nUx5poiU1m803NNqG5-fs8-MODQRyGLqy4mE,12585
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=6rc9qulPl90MxXKB55XiiWKLhjfAyG_eUzAlqpq1UIE,3339
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=8kTeVjXPcXC6DkDvWYsZQLY7x8DS6CEp_yznSEazsNU,2037
-prediction_market_agent_tooling/markets/seer/data_models.py,sha256=qo8qH-3j0czH8zrgHnaYyB5-f38zZcl9MNtQfXi_JZM,8192
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=l9H7AYRje4bEXMdVzw83cseY46BLgOAgiJarE_8faHk,13189
-prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=XOEhaL5wrKEg7P-xg1mW5mJXVfeALuflJOvqAeuwrWM,2717
-prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=o5Sh_6bpiJQb1KnW3rf4cBqN2PM8IdggQARdBeDMvIE,8725
+prediction_market_agent_tooling/markets/seer/data_models.py,sha256=Rj3Ajs9ZPr_kbCrgtdlsvzgi3ri6e-b2UcSkX2qQ7rs,6519
+prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=S-pAf7a2nfSNoM53xv8p6lV3ipfq0930ivw6IQRcZqw,4759
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=G9QkozlKj4YYgBEJlbWIgdgSvDFeW1OGZlaRZuXqAyY,15314
+prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=JZF4DY8S9P4xzz1pA2y7G2M9WRFrJSN9wx928IIo77E,2726
+prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=bAuMRBmPNax20RvB448U7_OfBtfRf6P6TouoYDu_OfM,9867
+prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=NscHqrfhFVtiHS3edIWLwwE32bBkEzyTZNl7fCvqaqQ,1644
 prediction_market_agent_tooling/monitor/financial_metrics/financial_metrics.py,sha256=fjIgjDIx5MhH5mwf7S0cspLOOSU3elYLhGYoIiM26mU,2746
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=TS4ERwTfQnot8dhekNyVNhJYf5ysYsjF-9v5_kM3aVI,3334
 prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=LOnyWWBFdg10-cTWdb76nOsNjDloO8OfMT85GBzRCFI,1455
@@ -84,10 +86,9 @@ prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=68zFWUj
 prediction_market_agent_tooling/tools/caches/db_cache.py,sha256=dB8LNs2JvVRaFCeAKRmIQRwiirsMgtL31he8051wM-g,11431
 prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjqeAebu5T7ftRnlkxiL02IC-MxCfDB80x7w,1506
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
-prediction_market_agent_tooling/tools/contract.py,sha256=PJaC_Mc06vowyHD6f4MNQuEfo-h0H-Lh741YzRuemUk,21018
+prediction_market_agent_tooling/tools/contract.py,sha256=1ZFp_VoqTjM8cqOfAhco2Ht0DTqakjhZpuZUrAXr28Q,21332
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
-prediction_market_agent_tooling/tools/cow/cow_manager.py,sha256=ZX6K0ZKMpcgiDsIrv4wtZAPg-LTozIbvOyQFyVgDpMA,3812
-prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=4BV9t_RZU07SxwAzjTVkXKoQtm9l-roFHJR_cE8O04A,5837
+prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=F6ZPDGCR9ymLflNc8MNTjt-0TJiuM3gBcZ10Ifk-aBE,5550
 prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
 prediction_market_agent_tooling/tools/datetime_utc.py,sha256=8_WackjtjC8zHXrhQFTGQ6e6Fz_6llWoKR4CSFvIv9I,2766
 prediction_market_agent_tooling/tools/db/db_manager.py,sha256=GtzHH1NLl8HwqC8Z7s6eTlIQXuV0blxfaV2PeQrBnfQ,3013
@@ -112,7 +113,7 @@ prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0r
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=5ldQs1pZe6uJ5eDAuP4OLpzmcqYShlIV67kttNFvGS0,342
 prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=pPs0qZNfJ7G-1ajfz0iaWOBQyiC0TbcShfrW8T39jtg,3859
-prediction_market_agent_tooling/tools/tokens/auto_deposit.py,sha256=MWIRHYCN-7o2uawEBwnBNhlzme1kLyX_5Q2zg7UIegQ,6700
+prediction_market_agent_tooling/tools/tokens/auto_deposit.py,sha256=dO-2XUcsCVvuRpvSN4dr1ZEoVS3Ee9soisLQI3bX8CU,6737
 prediction_market_agent_tooling/tools/tokens/auto_withdraw.py,sha256=22g0SIVmLlgITpdt3kPhJOw0sU4OPeBuYk_7xCrQr9U,2491
 prediction_market_agent_tooling/tools/tokens/main_token.py,sha256=1rbwpdCusPgQIVFuo3m00nBZ_b2lCAoFVm67i-YDcEw,812
 prediction_market_agent_tooling/tools/tokens/token_utils.py,sha256=zwV-jGFkPJu4-IslXOUqnsNQjzh_9CrfkruDQL0dq0c,1381
@@ -120,8 +121,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=l4vPemtF6Zcwh8HNXH3-L
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=1xsyBBJfiEdSoMlceB2F8o2sCb6Z8-qNz11pEJFrdyE,6566
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=eYCc1iWAVtqDKUPTwnMUHuYolPdwh_OTiM3-AdRgDp4,12198
-prediction_market_agent_tooling-0.62.0.dev493.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.62.0.dev493.dist-info/METADATA,sha256=vJ5R6V9K45e251VIx5omIKqUswyEg_i7aU-CsNeHZ9Q,8696
-prediction_market_agent_tooling-0.62.0.dev493.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-prediction_market_agent_tooling-0.62.0.dev493.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.62.0.dev493.dist-info/RECORD,,
+prediction_market_agent_tooling-0.63.0.dev498.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.63.0.dev498.dist-info/METADATA,sha256=AF85f__OPLoNCAibGYaUWCZzHky2cfGdQKeZsBwLQG4,8696
+prediction_market_agent_tooling-0.63.0.dev498.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+prediction_market_agent_tooling-0.63.0.dev498.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.63.0.dev498.dist-info/RECORD,,

prediction_market_agent_tooling/tools/cow/cow_manager.py

@@ -1,112 +0,0 @@
-import asyncio
-
-from cowdao_cowpy.common.api.errors import UnexpectedResponseError
-from cowdao_cowpy.common.config import SupportedChainId
-from cowdao_cowpy.cow.swap import get_order_quote
-from cowdao_cowpy.order_book.api import OrderBookApi
-from cowdao_cowpy.order_book.config import Envs, OrderBookAPIConfigFactory
-from cowdao_cowpy.order_book.generated.model import (
-    Address,
-    OrderMetaData,
-    OrderQuoteRequest,
-    OrderQuoteResponse,
-    OrderQuoteSide1,
-    OrderQuoteSideKindSell,
-)
-from cowdao_cowpy.order_book.generated.model import TokenAmount as TokenAmountCow
-from tenacity import retry, retry_if_not_exception_type, stop_after_attempt, wait_fixed
-from web3 import Web3
-from web3.constants import ADDRESS_ZERO
-
-from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, CollateralToken, Wei
-from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
-
-COW_ENV: Envs = "prod"
-
-
-class NoLiquidityAvailableOnCowException(Exception):
-    """Custom exception for handling case where no liquidity available."""
-
-
-class CowManager:
-    def __init__(self) -> None:
-        self.order_book_api = OrderBookApi(
-            OrderBookAPIConfigFactory.get_config(COW_ENV, SupportedChainId.GNOSIS_CHAIN)
-        )
-        self.precision = 18  # number of token decimals from ERC1155 wrapped tokens.
-
-    @retry(
-        stop=stop_after_attempt(2),
-        wait=wait_fixed(2),
-        retry=retry_if_not_exception_type(NoLiquidityAvailableOnCowException),
-    )
-    def get_quote(
-        self,
-        collateral_token: ChecksumAddress,
-        buy_token: ChecksumAddress,
-        sell_amount: Wei,
-    ) -> OrderQuoteResponse:
-        """
-        Quote the price for a sell order.
-
-        Parameters:
-        - collateral_token: The token being sold.
-        - buy_token: The token being bought.
-        - sell_amount: The amount of collateral to sell in atoms.
-
-        Returns:
-        - An OrderQuoteResponse containing the quote information.
-
-        Raises:
-        - NoLiquidityAvailableOnCowException if no liquidity is available on CoW.
-        """
-
-        order_quote_request = OrderQuoteRequest(
-            buyToken=Address(buy_token),
-            sellToken=Address(collateral_token),
-            from_=Address(ADDRESS_ZERO),
-        )
-
-        order_side = OrderQuoteSide1(
-            kind=OrderQuoteSideKindSell.sell,
-            sellAmountBeforeFee=TokenAmountCow(str(sell_amount)),
-        )
-        try:
-            return asyncio.run(
-                get_order_quote(
-                    order_quote_request=order_quote_request,
-                    order_side=order_side,
-                    order_book_api=self.order_book_api,
-                )
-            )
-
-        except UnexpectedResponseError as e1:
-            if "NoLiquidity" in e1.message:
-                raise NoLiquidityAvailableOnCowException(e1.message)
-            logger.warning(f"Found unexpected Cow response error: {e1}")
-            raise
-        except Exception as e:
-            logger.warning(f"Found unhandled Cow response error: {e}")
-            raise
-
-    @staticmethod
-    def swap(
-        amount: CollateralToken,
-        sell_token: ChecksumAddress,
-        buy_token: ChecksumAddress,
-        api_keys: APIKeys,
-        web3: Web3 | None = None,
-    ) -> OrderMetaData:
-        order_metadata = swap_tokens_waiting(
-            amount_wei=amount.as_wei,
-            sell_token=sell_token,
-            buy_token=buy_token,
-            api_keys=api_keys,
-            web3=web3,
-        )
-        logger.debug(
-            f"Purchased {buy_token} in exchange for {sell_token}. Order details {order_metadata}"
-        )
-        return order_metadata