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

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -67,15 +67,15 @@ class MetaculusAgentMarket(AgentMarket):
         )
 
     @staticmethod
-    def get_markets(  # type: ignore[override]
+    def get_markets(
         limit: int,
         sort_by: SortBy = SortBy.NONE,
         filter_by: FilterBy = FilterBy.OPEN,
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
-        tournament_id: int | None = None,
         market_type: MarketType = MarketType.ALL,
         include_conditional_markets: bool = False,
+        tournament_id: int | None = None,
     ) -> t.Sequence["MetaculusAgentMarket"]:
         order_by: str | None
         if sort_by == SortBy.NONE:

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -1,6 +1,5 @@
-import typing as t
-
 from cachetools import TTLCache, cached
+from pydantic import BaseModel
 from web3 import Web3
 
 from prediction_market_agent_tooling.gtypes import (
@@ -18,32 +17,15 @@ from prediction_market_agent_tooling.markets.seer.exceptions import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
-from prediction_market_agent_tooling.markets.seer.subgraph_data_models import SeerPool
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 
 
-def _make_cache_key(
-    *args: t.Any,
-    token: ChecksumAddress,
-    collateral_exchange_amount: CollateralToken | None = None,
-) -> str:
-    """
-    Generate a unique cache key based on a token address and optional collateral token.
-    """
-
-    if collateral_exchange_amount is None:
-        return f"{token}-no_collateral"
-
-    return "-".join(
-        [
-            token,
-            collateral_exchange_amount.symbol,
-            str(collateral_exchange_amount.value),
-        ]
-    )
+class Prices(BaseModel):
+    priceOfCollateralInAskingToken: CollateralToken
+    priceOfAskingTokenInCollateral: CollateralToken
 
 
 class PriceManager:
@@ -67,17 +49,17 @@ class PriceManager:
                 f"{price_diff_pct=} larger than {max_price_diff=} for seer market {self.seer_market.id.hex()} "
             )
 
-    @cached(TTLCache(maxsize=100, ttl=5 * 60), key=_make_cache_key)
-    def get_price_for_token(
+    def get_price_for_token(self, token: ChecksumAddress) -> CollateralToken | None:
+        return self.get_amount_of_token_in_collateral(token, CollateralToken(1))
+
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_collateral_in_token(
         self,
         token: ChecksumAddress,
-        collateral_exchange_amount: CollateralToken | None = None,
+        collateral_exchange_amount: CollateralToken,
     ) -> CollateralToken | None:
-        collateral_exchange_amount = (
-            collateral_exchange_amount
-            if collateral_exchange_amount is not None
-            else CollateralToken(1)
-        )
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return collateral_exchange_amount
 
         try:
             buy_token_amount = get_buy_token_amount_else_raise(
@@ -85,23 +67,51 @@ class PriceManager:
                 sell_token=self.seer_market.collateral_token_contract_address_checksummed,
                 buy_token=token,
             )
-            price = collateral_exchange_amount.as_wei / buy_token_amount
-            return CollateralToken(price)
+            return buy_token_amount.as_token
 
         except Exception as e:
             logger.warning(
                 f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
             )
-            return self.get_token_price_from_pools(token=token)
+            prices = self.get_token_price_from_pools(token=token)
+            return (
+                prices.priceOfCollateralInAskingToken * collateral_exchange_amount
+                if prices
+                else None
+            )
 
-    @staticmethod
-    def pool_token0_matches_token(token: ChecksumAddress, pool: SeerPool) -> bool:
-        return pool.token0.id.hex().lower() == token.lower()
+    @cached(TTLCache(maxsize=100, ttl=5 * 60))
+    def get_amount_of_token_in_collateral(
+        self,
+        token: ChecksumAddress,
+        token_exchange_amount: CollateralToken,
+    ) -> CollateralToken | None:
+        if token == self.seer_market.collateral_token_contract_address_checksummed:
+            return token_exchange_amount
+
+        try:
+            buy_collateral_amount = get_buy_token_amount_else_raise(
+                sell_amount=token_exchange_amount.as_wei,
+                sell_token=token,
+                buy_token=self.seer_market.collateral_token_contract_address_checksummed,
+            )
+            return buy_collateral_amount.as_token
+
+        except Exception as e:
+            logger.warning(
+                f"Could not get quote for {token=} from Cow, exception {e=}. Falling back to pools. "
+            )
+            prices = self.get_token_price_from_pools(token=token)
+            return (
+                prices.priceOfAskingTokenInCollateral * token_exchange_amount
+                if prices
+                else None
+            )
 
     def get_token_price_from_pools(
         self,
         token: ChecksumAddress,
-    ) -> CollateralToken | None:
+    ) -> Prices | None:
         pool = SeerSubgraphHandler().get_pool_by_token(
             token_address=token,
             collateral_address=self.seer_market.collateral_token_contract_address_checksummed,
@@ -111,15 +121,24 @@ class PriceManager:
             logger.warning(f"Could not find a pool for {token=}")
             return None
 
-        # The mapping below is odd but surprisingly the Algebra subgraph delivers the token1Price
-        # for the token0 and the token0Price for the token1 pool.
-        # For example, in a outcomeYES (token0)/sDAI pool (token1), token1Price is the price of outcomeYES in units of sDAI.
-        price = (
-            pool.token1Price
-            if self.pool_token0_matches_token(token=token, pool=pool)
-            else pool.token0Price
+        if (
+            Web3.to_checksum_address(pool.token0.id)
+            == self.seer_market.collateral_token_contract_address_checksummed
+        ):
+            price_coll_in_asking = (
+                pool.token1Price
+            )  # how many outcome tokens per 1 collateral
+            price_asking_in_coll = (
+                pool.token0Price
+            )  # how many collateral tokens per 1 outcome
+        else:
+            price_coll_in_asking = pool.token0Price
+            price_asking_in_coll = pool.token1Price
+
+        return Prices(
+            priceOfCollateralInAskingToken=price_coll_in_asking,
+            priceOfAskingTokenInCollateral=price_asking_in_coll,
         )
-        return price
 
     def build_probability_map(self) -> dict[OutcomeStr, Probability]:
         # Inspired by https://github.com/seer-pm/demo/blob/ca682153a6b4d4dd3dcc4ad8bdcbe32202fc8fe7/web/src/hooks/useMarketOdds.ts#L15
@@ -160,6 +179,6 @@ class PriceManager:
             outcome = self.seer_market.outcomes[
                 self.seer_market.wrapped_tokens.index(outcome_token)
             ]
-            normalized_prices[OutcomeStr(outcome)] = new_price
+            normalized_prices[outcome] = new_price
 
         return normalized_prices

prediction_market_agent_tooling/markets/seer/seer.py

@@ -68,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,
@@ -137,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
@@ -191,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
@@ -209,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:
@@ -456,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]:
@@ -469,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
 
@@ -542,15 +518,23 @@ class SeerAgentMarket(AgentMarket):
                 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/swap_pool_handler.py

@@ -80,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(

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(
@@ -355,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-0.66.6.dist-info → prediction_market_agent_tooling-0.67.1.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.66.6.dist-info → prediction_market_agent_tooling-0.67.1.dist-info}/RECORD

@@ -54,7 +54,7 @@ prediction_market_agent_tooling/markets/market_fees.py,sha256=YeK3ynjYIguB0xf6sO
 prediction_market_agent_tooling/markets/markets.py,sha256=WAM2Ic8TS5hS1MOgH7zjznBdmCSfO9GaSpypM3a82HE,2922
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=WjPt0MKeJNtoY-8oLQTLC8vQYYQ-dBj8UZoPq-UBYsQ,3288
-prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=ubJoMjDOnz3f7Er5aRJKb-G8_8Kr5DZz-UZ2rgLRgE8,5253
+prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=ipwjj-2lYlTVeu6U9GishGk7ZIqmzwXOIqa1cAoWazU,5227
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/cow_contracts.py,sha256=sFaW82u_haL4nze8fjTmnQsOuV0OecunQlAhh1OAw0w,1091
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=RsBYSbM4deA6Os4kQ3egH3HvwT80tQho6T1yyoATCMs,31103
@@ -71,12 +71,12 @@ prediction_market_agent_tooling/markets/polymarket/polymarket_subgraph_handler.p
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=A_diygWKYyp4WHbxAlAVAuC0S0ZqbEKE80wxL6mxHKQ,1275
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=Fkn9jG8f0W8XlfM4EFfMSw0V0c3IGSqnKPt1UnG34Ag,6084
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
-prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=MClY2NGwOV70nZYIcmzXFy6Ogd8NBIq7telQcQ3VcU4,6243
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=SZ-01FntWjmhaMQpMe3td9tQ6LYFKdL2r-IVBlWNgNo,27361
+prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=PZf6-6zc6DvH1u65wHWyeD55lgG-UGnN_xzBMvrb3ug,7120
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=V3yBrnAO9sTpRRHVBp5HorW-XgkQMyKY-A4lP1GkT1s,26323
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=uMzpHpI6_tgfhWxPzupLdUJlZ1P2wr0rRiYjAGClKgU,4984
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=kNmWzCsKsMn_NUP3eiELl2Ldwx-bg2HojOgKtDXMZ0U,11704
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=0izxS8Mtzonfdl9UqvFVXrdj0hVzieroekXhogfZKCw,1817
-prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=q5AtlcYcMrD45bfo_ffPSdpmW1h1TU4xbZ4tdj1KMAk,3904
+prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=kS_fJg4XvlMDKhDtVIjQViCtX2luCnTKL1Sd-3gd9pE,3935
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/_generic_value.py,sha256=pD_PI13lpPp1gFoljHwa_Lzlp-u2pu0m-Z7LcxwDM2U,10618
 prediction_market_agent_tooling/tools/balances.py,sha256=Osab21btfJDw2Y-jT_TV-KHGrseCRxcsYeW6WcOMB8E,1050
@@ -88,8 +88,8 @@ prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjq
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
 prediction_market_agent_tooling/tools/contract.py,sha256=pdr9ZYmj4QVUfgVKdvOU6ucYdBpJGdha_FMR_LgtcEs,22912
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
-prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=ZM6W0_LprH7iWEgTVKFgcBVbDrBDBuTEM-Kkg2R-DqY,13361
-prediction_market_agent_tooling/tools/cow/models.py,sha256=jAITIcg8GXEGtRQpezVvlqaQ5M8OEiiHqLwoyUeX3JM,655
+prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=CtCPnBcHSrWmcCuNxqqPHQwyBTL6pLqtSvNJt49nHno,13810
+prediction_market_agent_tooling/tools/cow/models.py,sha256=Z_XUAMj5AGHZE-A92oRG0DuPeXTSyWnZRIwKQ49LaXU,709
 prediction_market_agent_tooling/tools/cow/semaphore.py,sha256=IJGKRgvXnRSkEt_z1i5-eFIoVMcyhr7HK0JfIz1MXdQ,3738
 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
@@ -127,8 +127,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMD
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=mbOGoWKalNIm7M2K51TEPGwU9oVp1Z6SPsFaBgbn6ws,7397
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=0r26snqCXGdLKCWA8jpe7DV8x2NPYWZwOy4oyKyDCYk,12615
-prediction_market_agent_tooling-0.66.6.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.66.6.dist-info/METADATA,sha256=zs-VgqXzeMZUqr0GWFQG4mrZ6W91ca3vySAs8c5Zuvo,8726
-prediction_market_agent_tooling-0.66.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.66.6.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.66.6.dist-info/RECORD,,
+prediction_market_agent_tooling-0.67.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.67.1.dist-info/METADATA,sha256=P0pmEOh1l9XQz-FdVuWakPmPcM8PKvyx7Ae-kALL-7U,8726
+prediction_market_agent_tooling-0.67.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.67.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.67.1.dist-info/RECORD,,