prediction-market-agent-tooling 0.66.0.dev791__py3-none-any.whl → 0.66.2__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -571,7 +571,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
         """
         total_amount = self.get_total_amount_to_bet(market)
-        return MultiCategoricalMaxAccuracyBettingStrategy(bet_amount=total_amount)
+        return MultiCategoricalMaxAccuracyBettingStrategy(
+            max_position_amount=total_amount
+        )
 
     def build_trades(
         self,

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Sequence
 
+import numpy as np
 from scipy.optimize import minimize_scalar
 
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
@@ -94,6 +95,76 @@ class BettingStrategy(ABC):
         )
         return trades
 
+    @staticmethod
+    def cap_to_profitable_bet_amount(
+        market: AgentMarket,
+        bet_amount: USD,
+        outcome: OutcomeStr,
+        iters: int = 10,
+    ) -> USD:
+        """
+        Use a binary search (tree-based search) to efficiently find the largest profitable bet amount.
+        """
+        # First, try it with the desired amount right away.
+        if (
+            market.get_in_usd(
+                check_not_none(
+                    market.get_buy_token_amount(bet_amount, outcome)
+                ).as_token
+            )
+            > bet_amount
+        ):
+            return bet_amount
+
+        # If it wasn't profitable, try binary search to find the highest, but profitable, amount.
+        lower = USD(0)
+        # It doesn't make sense to try to bet more than the liquidity itself, so override it as maximal value if it's lower.
+        upper = min(bet_amount, market.get_in_usd(market.get_liquidity()))
+        best_profitable = USD(0)
+
+        for _ in range(iters):
+            mid = (lower + upper) / 2
+            potential_outcome_value = market.get_in_usd(
+                check_not_none(market.get_buy_token_amount(mid, outcome)).as_token
+            )
+
+            if potential_outcome_value > mid:
+                # Profitable, try higher
+                best_profitable = mid
+                lower = mid
+
+            else:
+                # Not profitable, try lower
+                upper = mid
+
+            # If the search interval is very small, break early
+            if float(upper - lower) < 1e-8:
+                break
+
+        if np.isclose(best_profitable.value, 0):
+            best_profitable = USD(0)
+
+        return best_profitable
+
+    @staticmethod
+    def cap_to_profitable_position(
+        market: AgentMarket,
+        existing_position: USD,
+        wanted_position: USD,
+        outcome_to_bet_on: OutcomeStr,
+    ) -> USD:
+        # If the wanted position is lower, it means the agent is gonna sell and that's profitable always.
+        if wanted_position > existing_position:
+            difference = wanted_position - existing_position
+            # Cap the difference we would like to buy to a profitable one.
+            capped_difference = BettingStrategy.cap_to_profitable_bet_amount(
+                market, difference, outcome_to_bet_on
+            )
+            # Lowered the actual wanted position such that it remains profitable.
+            wanted_position = existing_position + capped_difference
+
+        return wanted_position
+
     def _build_rebalance_trades_from_positions(
         self,
         existing_position: ExistingPosition | None,
@@ -160,12 +231,12 @@ class BettingStrategy(ABC):
 
 
 class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: USD):
-        self.bet_amount = bet_amount
+    def __init__(self, max_position_amount: USD):
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def calculate_direction(
@@ -196,11 +267,23 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         """We place bet on only one outcome."""
-
         outcome_to_bet_on = self.calculate_direction(market, answer)
 
+        # Will be lowered if the amount that we would need to buy would be unprofitable.
+        actual_wanted_position = BettingStrategy.cap_to_profitable_position(
+            market,
+            (
+                existing_position.amounts_current.get(outcome_to_bet_on, USD(0))
+                if existing_position
+                else USD(0)
+            ),
+            self.max_position_amount,
+            outcome_to_bet_on,
+        )
+
         target_position = Position(
-            market_id=market.id, amounts_current={outcome_to_bet_on: self.bet_amount}
+            market_id=market.id,
+            amounts_current={outcome_to_bet_on: actual_wanted_position},
         )
         trades = self._build_rebalance_trades_from_positions(
             existing_position=existing_position,
@@ -253,13 +336,13 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD, max_price_impact: float | None = None):
-        self.max_bet_amount = max_bet_amount
+    def __init__(self, max_position_amount: USD, max_price_impact: float | None = None):
+        self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def get_kelly_bet(
@@ -321,7 +404,7 @@ class KellyBettingStrategy(BettingStrategy):
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_bet_amount,
+            max_bet_amount=self.max_position_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -405,16 +488,16 @@ class KellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount}, max_price_impact={self.max_price_impact})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount}, max_price_impact={self.max_price_impact})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD):
-        self.max_bet_amount = max_bet_amount
+    def __init__(self, max_position_amount: USD):
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     def adjust_bet_amount(
         self, existing_position: ExistingPosition | None, market: AgentMarket
@@ -422,7 +505,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         existing_position_total_amount = (
             existing_position.total_amount_current if existing_position else USD(0)
         )
-        return self.max_bet_amount + existing_position_total_amount
+        return self.max_position_amount + existing_position_total_amount
 
     def calculate_trades(
         self,
@@ -471,4 +554,4 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount})"

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -93,7 +93,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def get_job_trade(self, max_bond: USD, result: str) -> Trade:
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-        strategy = KellyBettingStrategy(max_bet_amount=max_bond)
+        strategy = KellyBettingStrategy(max_position_amount=max_bond)
         required_trades = strategy.calculate_trades(
             existing_position=None,
             answer=self.get_job_answer(result),

prediction_market_agent_tooling/markets/data_models.py

@@ -15,7 +15,7 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
-from prediction_market_agent_tooling.markets.omen.omen import (
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
     OMEN_FALSE_OUTCOME,
     OMEN_TRUE_OUTCOME,
 )

prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -14,13 +14,13 @@ class QuestionType(str, Enum):
 class AggregationItem(BaseModel):
     start_time: DatetimeUTC
     end_time: DatetimeUTC | None
-    forecast_values: list[float] | None
+    forecast_values: list[float] | None = None
     forecaster_count: int
     interval_lower_bounds: list[float] | None
     centers: list[float] | None
     interval_upper_bounds: list[float] | None
-    means: list[float] | None
-    histogram: list[list[float]] | None
+    means: list[float] | None = None
+    histogram: list[list[float]] | None = None
 
 
 class Aggregation(BaseModel):

prediction_market_agent_tooling/markets/omen/cow_contracts.py

@@ -3,7 +3,7 @@ import os
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ABI, HexBytes
+from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, HexBytes
 from prediction_market_agent_tooling.tools.contract import (
     ContractOnGnosisChain,
     abi_field_validator,
@@ -19,6 +19,10 @@ class CowGPv2SettlementContract(ContractOnGnosisChain):
         )
     )
 
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+    )
+
     def setPreSignature(
         self,
         api_keys: APIKeys,

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -23,6 +23,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
     ResolvedBet,
 )
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
@@ -37,8 +41,6 @@ from prediction_market_agent_tooling.tools.utils import (
     utcnow,
 )
 
-OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
-OMEN_FALSE_OUTCOME = OutcomeStr("No")
 OMEN_BINARY_MARKET_OUTCOMES: t.Sequence[OutcomeStr] = [
     OMEN_TRUE_OUTCOME,
     OMEN_FALSE_OUTCOME,

prediction_market_agent_tooling/markets/omen/omen.py

@@ -104,6 +104,7 @@ class OmenAgentMarket(AgentMarket):
 
     collateral_token_contract_address_checksummed: ChecksumAddress
     market_maker_contract_address_checksummed: ChecksumAddress
+    outcome_token_pool: dict[OutcomeStr, OutcomeToken]
     condition: Condition
     finalized_time: DatetimeUTC | None
     created_time: DatetimeUTC
@@ -620,11 +621,10 @@ class OmenAgentMarket(AgentMarket):
         Note: this is only valid if the market instance's token pool is
         up-to-date with the smart contract.
         """
-        outcome_token_pool = check_not_none(self.outcome_token_pool)
         amount = get_buy_outcome_token_amount(
             investment_amount=self.get_in_token(bet_amount),
             outcome_index=self.get_outcome_index(outcome),
-            pool_balances=[outcome_token_pool[x] for x in self.outcomes],
+            pool_balances=[self.outcome_token_pool[x] for x in self.outcomes],
             fees=self.fees,
         )
         return amount

prediction_market_agent_tooling/markets/omen/omen_constants.py

@@ -1,5 +1,10 @@
 from web3 import Web3
 
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+
+OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
+OMEN_FALSE_OUTCOME = OutcomeStr("No")
+
 WRAPPED_XDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
 )

prediction_market_agent_tooling/markets/seer/seer.py

@@ -2,6 +2,7 @@ import asyncio
 import typing as t
 from datetime import timedelta
 
+from cowdao_cowpy.common.api.errors import UnexpectedResponseError
 from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
@@ -61,7 +62,6 @@ from prediction_market_agent_tooling.tools.contract import (
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
-    cancel_order,
     get_buy_token_amount_else_raise,
     get_orders_by_owner,
     get_trades_by_owner,
@@ -198,9 +198,7 @@ class SeerAgentMarket(AgentMarket):
                 )
             )
 
-            amounts_ot[
-                OutcomeStr(outcome_str)
-            ] = outcome_token_balance_wei.as_outcome_token
+            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
 
         amounts_current = {
             k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
@@ -481,26 +479,32 @@ class SeerAgentMarket(AgentMarket):
         Returns:
             Transaction hash of the successful swap
         """
-        _, order = swap_tokens_waiting(
-            amount_wei=amount_wei,
-            sell_token=sell_token,
-            buy_token=buy_token,
-            api_keys=api_keys,
-            web3=web3,
-            wait_order_complete=False,
-        )
 
         try:
+            _, order = swap_tokens_waiting(
+                amount_wei=amount_wei,
+                sell_token=sell_token,
+                buy_token=buy_token,
+                api_keys=api_keys,
+                web3=web3,
+                wait_order_complete=False,
+                timeout=timedelta(minutes=2),
+            )
             order_metadata = asyncio.run(wait_for_order_completion(order=order))
             logger.debug(
                 f"Swapped {sell_token} for {buy_token}. Order details {order_metadata}"
             )
             return order_metadata.uid.root
 
-        except TimeoutError:
-            # Since timeout occurred, we need to cancel the order before trying to swap again.
-            asyncio.run(cancel_order(order_uids=[order.uid.root], api_keys=api_keys))
-            logger.info("TimeoutError. Trying to swap directly on Swapr pools.")
+        except (UnexpectedResponseError, TimeoutError) as e:
+            # We don't retry if not enough balance.
+            if "InsufficientBalance" in str(e):
+                raise e
+            # Note that we don't need to cancel the order because we are setting
+            # timeout and valid_to in the order, thus the order simply expires.
+            logger.info(
+                f"Exception occured when swapping tokens via Cowswap, doing swap via pools. {e}"
+            )
 
             tx_receipt = SwapPoolHandler(
                 api_keys=api_keys,

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -55,7 +55,8 @@ from prediction_market_agent_tooling.markets.omen.cow_contracts import (
 )
 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.utils import check_not_none, utcnow
+from prediction_market_agent_tooling.tools.cow.semaphore import postgres_rate_limited
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class OrderStatusError(Exception):
@@ -190,7 +191,11 @@ def handle_allowance(
         )
 
 
+@postgres_rate_limited(
+    api_keys=APIKeys(), rate_id="swap_tokens_waiting", interval_seconds=60.0
+)
 @tenacity.retry(
+    reraise=True,
     stop=stop_after_attempt(3),
     wait=wait_fixed(1),
     retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
@@ -205,6 +210,7 @@ def swap_tokens_waiting(
     env: Envs = "prod",
     web3: Web3 | None = None,
     wait_order_complete: bool = True,
+    timeout: timedelta = timedelta(seconds=120),
 ) -> 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(
@@ -215,6 +221,7 @@ def swap_tokens_waiting(
             api_keys,
             chain,
             env,
+            timeout=timeout,
             web3=web3,
             wait_order_complete=wait_order_complete,
         )
@@ -229,6 +236,7 @@ async def place_swap_order(
     chain: Chain,
     env: Envs,
     slippage_tolerance: float = 0.01,
+    valid_to: int | None = None,
 ) -> CompletedOrder:
     account = api_keys.get_account()
     safe_address = api_keys.safe_address_checksum
@@ -242,6 +250,7 @@ async def place_swap_order(
         chain=chain,
         env=env,
         slippage_tolerance=slippage_tolerance,
+        valid_to=valid_to,
     )
     logger.info(f"Order created: {order}")
 
@@ -299,6 +308,7 @@ async def swap_tokens_waiting_async(
     handle_allowance(
         api_keys=api_keys, sell_token=sell_token, amount_wei=amount_wei, web3=web3
     )
+    valid_to = (utcnow() + timeout).timestamp()
     order = await place_swap_order(
         api_keys=api_keys,
         amount_wei=amount_wei,
@@ -307,6 +317,7 @@ async def swap_tokens_waiting_async(
         chain=chain,
         env=env,
         slippage_tolerance=slippage_tolerance,
+        valid_to=int(valid_to),
     )
     if wait_order_complete:
         order_metadata = await wait_for_order_completion(order=order, timeout=timeout)
@@ -327,11 +338,8 @@ async def sign_safe_cow_swap(
 ) -> None:
     order_book_api = get_order_book_api(env, chain)
     posted_order = await order_book_api.get_order_by_uid(order.uid)
-    CowGPv2SettlementContract(
-        address=Web3.to_checksum_address(
-            check_not_none(posted_order.settlementContract).root
-        )
-    ).setPreSignature(
+
+    CowGPv2SettlementContract().setPreSignature(
         api_keys,
         HexBytes(posted_order.uid.root),
         True,

prediction_market_agent_tooling/tools/cow/models.py

@@ -1,7 +1,9 @@
 from pydantic import BaseModel
+from sqlmodel import Field, SQLModel
 
 from prediction_market_agent_tooling.gtypes import ChecksumAddress
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class MinimalisticToken(BaseModel):
@@ -14,3 +16,9 @@ class Order(BaseModel):
     sellToken: str
     buyToken: str
     creationDate: DatetimeUTC
+
+
+class RateLimit(SQLModel, table=True):
+    __tablename__ = "rate_limit"
+    id: str = Field(primary_key=True)
+    last_called_at: DatetimeUTC = Field(default_factory=utcnow)

prediction_market_agent_tooling/tools/cow/semaphore.py

@@ -0,0 +1,101 @@
+import time
+from datetime import timedelta
+from functools import wraps
+from typing import Any, Callable, Optional, TypeVar, cast
+
+from sqlalchemy.exc import OperationalError
+from sqlmodel import Session, select
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.cow.models import RateLimit
+from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.db.db_manager import DBManager
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+FALLBACK_SQL_ENGINE = "sqlite:///rate_limit.db"
+
+
+def postgres_rate_limited(
+    api_keys: APIKeys, rate_id: str = "default", interval_seconds: float = 1.0
+) -> Callable[[F], F]:
+    """rate_id is used to distinguish between different rate limits for different functions"""
+    limiter = RateLimiter(id=rate_id, interval_seconds=interval_seconds)
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            sqlalchemy_db_url = (
+                api_keys.sqlalchemy_db_url.get_secret_value()
+                if api_keys.SQLALCHEMY_DB_URL
+                else FALLBACK_SQL_ENGINE
+            )
+
+            db_manager = DBManager(sqlalchemy_db_url)
+            db_manager.create_tables([RateLimit])
+
+            with db_manager.get_session() as session:
+                limiter.enforce(session)
+            return func(*args, **kwargs)
+
+        return cast(F, wrapper)
+
+    return decorator
+
+
+class RateLimiter:
+    def __init__(self, id: str, interval_seconds: float = 1.0) -> None:
+        self.id = id
+        self.interval = timedelta(seconds=interval_seconds)
+
+    def enforce(self, session: Session, timeout_seconds: float = 30.0) -> None:
+        """
+        Enforces the rate limit inside a transaction.
+        Blocks until allowed or timeout is reached.
+
+        Args:
+            session: The database session to use
+            timeout_seconds: Maximum time in seconds to wait before giving up
+
+        Raises:
+            TimeoutError: If the rate limit cannot be acquired within the timeout period
+        """
+        start_time = time.monotonic()
+
+        while True:
+            try:
+                with session.begin():
+                    stmt = (
+                        select(RateLimit)
+                        .where(RateLimit.id == self.id)
+                        .with_for_update()
+                    )
+                    result: Optional[RateLimit] = session.exec(stmt).first()
+
+                    now = utcnow()
+
+                    if result is None:
+                        # First time this limiter is used
+                        session.add(RateLimit(id=self.id))
+                        return
+
+                    last_called_aware = DatetimeUTC.from_datetime(result.last_called_at)
+                    elapsed = now - last_called_aware
+                    if elapsed >= self.interval:
+                        result.last_called_at = now
+                        session.add(result)
+                        return
+
+                    # Not enough time passed, sleep and retry
+                    to_sleep = (self.interval - elapsed).total_seconds()
+                    time.sleep(to_sleep)
+            except OperationalError:
+                # Backoff if DB is under contention
+                elapsed_time = time.monotonic() - start_time
+                if elapsed_time > timeout_seconds:
+                    raise TimeoutError(
+                        f"Could not acquire rate limit '{self.id}' "
+                        f"after {elapsed_time:.1f} seconds due to database contention"
+                    )
+                time.sleep(0.5)

{prediction_market_agent_tooling-0.66.0.dev791.dist-info → prediction_market_agent_tooling-0.66.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.66.0.dev791
+Version: 0.66.2
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -14,7 +14,7 @@ Provides-Extra: openai
 Provides-Extra: optuna
 Requires-Dist: autoflake (>=2.2.1,<3.0.0)
 Requires-Dist: base58 (>=1.0.2,<2.0)
-Requires-Dist: cowdao-cowpy-kongzii (==1.0.0rc2)
+Requires-Dist: cowdao-cowpy (==1.0.0rc5)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
 Requires-Dist: eth-account (>=0.8.0,<0.12.0)
 Requires-Dist: eth-keys (>=0.6.1,<0.7.0)

{prediction_market_agent_tooling-0.66.0.dev791.dist-info → prediction_market_agent_tooling-0.66.2.dist-info}/RECORD

@@ -26,9 +26,9 @@ prediction_market_agent_tooling/benchmark/utils.py,sha256=xQd7p9H08-OtN3iC4QT2i9
 prediction_market_agent_tooling/chains.py,sha256=1qQstoqXMwqwM7k-KH7MjMz8Ei-D83KZByvDbCZpAxs,116
 prediction_market_agent_tooling/config.py,sha256=-kJfdDr-m0R-tGZ1KRI-hJJk0mXDt142CAlvwaJ2N2I,11778
 prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=VY23h324VKIVkevj1B1O-zL1eEp9AElmcfn6SwYDUSc,14246
-prediction_market_agent_tooling/deploy/agent.py,sha256=HLK5rf38PWgKydc_aIUck-wYzWQUnPdhto3Evoq82Lg,26282
+prediction_market_agent_tooling/deploy/agent.py,sha256=EEAZQnOqsru1xRzt141iBy_9tG7zo1vnxkLqpg1SuDw,26313
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=YYayGjTKW02d3BUavJ8M3NmFk41oldEM3FHbwppZGRM,17184
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=jyBz1vIRXWxzDoC5AeO-r-V6qntaSfJ-QoHSc_I7JBM,20268
 prediction_market_agent_tooling/deploy/constants.py,sha256=Qe9cllgsGMkecfmbhXoFkPxuJyG6ATsrT87RF9SmPWM,249
 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
@@ -37,14 +37,14 @@ prediction_market_agent_tooling/deploy/trade_interval.py,sha256=Xk9j45alQ_vrasGv
 prediction_market_agent_tooling/gtypes.py,sha256=bUIZfZIGvIi3aiZNu5rVE9kRevw8sfMa4bcze6QeBg8,6058
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=DoZ9dlvVhpNrnINiR1uy6YUOsuzI_L-avBt362y5xXM,2467
-prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=qbTZ9HVvu_iP4dDxuvOZxAp6JsRKejvEW2YDYCnRmd4,5039
+prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=UN7OF-oi3_cgaGEBxJO2SxzURnuTFFEUcrUWM2rnSGA,5044
 prediction_market_agent_tooling/loggers.py,sha256=o1HyvwtK1DbuC0YWQwJNqzXLLbSC41gNBkEUxiAziEg,5796
 prediction_market_agent_tooling/logprobs_parser.py,sha256=DBlBQtWX8_URXhzTU3YWIPa76Zx3QDHlx1ARqbgJsVI,5008
 prediction_market_agent_tooling/markets/agent_market.py,sha256=nMIa6BkoUWdiz12kFDKuKXD_m6PhLzp3to1vgyj63ZQ,18834
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
 prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=6REOt70v3vnzmtCbuRcUTdwt6htXy9nAfNkLOH3Bv1U,2987
 prediction_market_agent_tooling/markets/categorize.py,sha256=orLZlPaHgeREU66m1amxfWikeV77idV4sZDPB8NgSD0,1300
-prediction_market_agent_tooling/markets/data_models.py,sha256=Cua28jBom3lBuOifwQLEWb1MrKq2epnA5qognaV5VRM,8006
+prediction_market_agent_tooling/markets/data_models.py,sha256=H3G-2I9QFhWrBY_KI-4BO2jMtb_f9yauzHz-zA4NI5Q,8016
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=tWnjuqvU8pcCuja2B_ynHeds1iiEFc6QWHjeSO_GSxY,7676
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=3z1gFbPMEgCDGqeH-IK8wcvqmIHgLdZX8C2M1UQ7iDw,6740
@@ -53,13 +53,13 @@ prediction_market_agent_tooling/markets/manifold/utils.py,sha256=DCigEbpGWkXR-RZ
 prediction_market_agent_tooling/markets/market_fees.py,sha256=YeK3ynjYIguB0xf6sO5iyg9lOdW_HD4C6nbJfiGyRCU,1351
 prediction_market_agent_tooling/markets/markets.py,sha256=lIEPfPJD1Gz90pTvN2pZi51rpb969STPgQtNFCqHUJg,2667
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
-prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=FaBCTPPezXbBwZ9p791CiVgQ4vB696xnMbz9XVXmiVI,3267
+prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=WjPt0MKeJNtoY-8oLQTLC8vQYYQ-dBj8UZoPq-UBYsQ,3288
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=S1Kkf_F3KuqFO938d5bun60wd8lsGvnGqxsW-tgEBgw,5110
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/omen/cow_contracts.py,sha256=sl1L4cK5nAJwZ2wdhLzqh8p7h_IEValNvLwKUlInKxw,957
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=-EhjQRQLxI0O3m4eOKUMH10_RS4tOBwIvMSnbIIHu10,31056
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=hTHqS_-Z7jocrwuisqymYWLUUn8bK_WSRwaKPgXz1es,50477
-prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=pYcdK5a1nPte9x7E154vkIiM6cLw1JvqpLibs9HsBbo,347
+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
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=fYDP64-gL3n18K86BXMrM9nO8ZQ4FQY8LynVL7Xm588,50468
+prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=XtRk4vpxwUYkTndfjlcmghA-NOIneV8zdHFdyI7tHhM,487
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=27-HRngTqfk_wgvttB3GeVHhy_O2YZcz9izo9OufOI0,29991
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=D-ubf_LumHs_c5rBAAntQ8wGKprtO2V1JZeedmChNIE,11035
 prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=h-YFRLY5rlhM9RqqceyfbHlno3elltN8Nr_Mnu1kJ90,40006
@@ -71,7 +71,7 @@ prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=8kTeVjXPcXC6D
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=osM9WaLsxQf-pfVGq0O-IkM93ehP9a7fVUf-hi2VlMs,5523
 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=vXSJ-iqkO44q4HVsKbu_6gD8lpx7t70Rbx-Or6xOao8,24354
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=_9NAisDsk9cu9RP3O-cphiefENN2nPK1Puk0C5eiGWg,24630
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=uMzpHpI6_tgfhWxPzupLdUJlZ1P2wr0rRiYjAGClKgU,4984
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=pJxch9_u0EdiIatQP1-UFClt8UEfMZAXBlk5wDO_ovk,9940
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=0izxS8Mtzonfdl9UqvFVXrdj0hVzieroekXhogfZKCw,1817
@@ -87,8 +87,9 @@ 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=yTUG6VPVe292R_5IG8F90kfZfAeun8G1TL6mHsnaXM0,12984
-prediction_market_agent_tooling/tools/cow/models.py,sha256=ZWGW0og5vXjgZVXxkx4uV2m61Q8AmL-L-D_D4f7ApR0,379
+prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=cKjyVbBblOkVjBbLyJ8w7qnzkxRhawtQYeNb4rymZwc,13272
+prediction_market_agent_tooling/tools/cow/models.py,sha256=jAITIcg8GXEGtRQpezVvlqaQ5M8OEiiHqLwoyUeX3JM,655
+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
 prediction_market_agent_tooling/tools/db/db_manager.py,sha256=GtzHH1NLl8HwqC8Z7s6eTlIQXuV0blxfaV2PeQrBnfQ,3013
@@ -124,8 +125,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=RlWSlzS2LavMIWrpwn1fevbzgPZruD4VcXTa-XxjWnE,7343
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=0r26snqCXGdLKCWA8jpe7DV8x2NPYWZwOy4oyKyDCYk,12615
-prediction_market_agent_tooling-0.66.0.dev791.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.66.0.dev791.dist-info/METADATA,sha256=UAUwDR0E0lNWDUcntavNgEX5gQEWBo5Jpu3kF0lA3xo,8741
-prediction_market_agent_tooling-0.66.0.dev791.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.66.0.dev791.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.66.0.dev791.dist-info/RECORD,,
+prediction_market_agent_tooling-0.66.2.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.66.2.dist-info/METADATA,sha256=LrUMj4jSVZ9kX_y8LfK8xuGtbNElU3PnpqbJDPSjs_8,8726
+prediction_market_agent_tooling-0.66.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.66.2.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.66.2.dist-info/RECORD,,